Our application will be selling cooking products from a manufactuer that wants to go worldwide. So, we have a marketing service that has a frontend with SEO capabilities, and a frontend for customer management - both are built in NodeJS. An online shop and a backend in Java Spring-Boot that creates reports and puts it to a database. Besides services we have also static files like compiled js and pictures that should be served on websites. What kind of configuration should we consider then? Well, let's go point by point what comes to our mind:

One of the latest innovations in these cases is GCP Cloud Run for managing containers, GCP global load balancing for good edge networking and GCP Firestore for database. Here I provided some guidelines on how to connect those things together.

The easiest part comes with GCP Cloud Run, as we want to build containers and put them online. Cloud Run is the best solution here, because it is like fully manged kubernetes but only with the part to deploy the service and the rest - creating a deployment, scaling and starting a service - is done automatically within Cloud Run. Briefly speaking - you just point to a container and the outcome is a link for your service.

Before going to deployments we need to setup our workspace, what we need:

We have three services to deploy:

Each of them must be built locally and you should create a docker image out of every service:

Try to build the images as small as possible.

For Cloud Run you need to store the image on GCR (Google Container Registry) if you want your images to be private. You can also store them in any other public registry as long as the image is publicly available - no privacy here.

To publish images to GCR you need to enable the registry, retag the image and push the image:

1. Enable the service

2. Before you can push images you need to authenticate yourself within the docker daemon.
Best way is to use credential helper

3. Now you can retag the images and push them, for each of the services just do:

Now, we have our images in the registry, then it's time to launch first cloud run services.

As it seems we have our services deployed, but the setup is not finished yet, we still have some things to do:

Best way of serving static resources is to save them on Google Storage in some bucket and making this bucket publicly visible. Also we want the static resources to be accessible within the /static path in the address

1. Using command line enable google cloud storage.

2. Compile static resources with any tool that you have (e.g. yarn build etc.)

3. Create a bucket that will serve the resurces

With this command we have created a bucket that is multiregion and placed in datacenters in EU. Please, mind that bucket name should be globally unique.

4. Copy all resources to your bucket. In this point static is the directory and favicon.ico is the file with website icon.

5. Make all of the resources readable on the internet with public visibility.

We have sent static resources to the bucket, but the URL of the bucket does not satisfy us and also we need to serve our services with proper URLs. With succor comes Global Load Balancer which we will be using not only to load balance our resources, but also to properly set traffic routes.

1. For services we need to create Network Endpoint Groups, use the command line:

2. Next, Google Load Balancers require us to set the backend services, as we can have multiple services and they can be balanced on different terms. For those services there should set proper backends which will be our network endpoint groups we created in previous point.

3. Now we need also to create backend service for the static resources in bucket.

The last stage is to setup the global load balancer, which requires:

• Proper URL Map
• TLS certificates
• Forwarded ports (because we can have services internally load balanced)

To setup URL maps we have to first organize how our application should be visited. We have a domain spicy-pot.com and also we have complete control over it. So:

spicy-pot.com - this will be the page that will access marketing-service.
customer.spicy-pot.com - this page will show the customer-service.
shop.spicy-pot.com - this will access the shop-service.

Don't forget to serve /static for all of the services.

1. Create a yaml file with name main-url-map.yaml with contents:

2. Upload this URL map

3. You need also to setup SSL certificates in order for HTTPS to work. The certificates is managed by google, so it also needs to be verified which is explained further.

4. Obtain a global IP address and create a DNS record within your provider with a type A. The address can be obtained like this:

For all the domains set the same IP address:
— sales-pot.com
— customer.sales-pot.com
— shop.sales-pot.com

5. With URL map created, SSL certificate added and IP addresses set in DNS we can now create the load balancer entity which is also called "target HTTPS proxy"

6. One more thing in the end - Load balancer needs to be forwarded.

From now on you must wait approx. 15 to 45 minutes in order to validate certificates and after validation sites should be reachable within addresses:

— spicy-pot.com
— customer.spicy-pot.com
— shop.spicy-pot.com

We have setup a cheap infrastructure for our application which should be reachable globally. Fixed costs related to the infrastructure are billed for bucket, other cost regarding services and load balancing may vary depending on the application usage by clients.

This is still a cheap situation, because with this configuration we can:

easily deploy patched and updated services with no downtime - Cloud Run does the blue/green deployment automatically.

scalability is also done automatically by Cloud Run as it increases the number of service instances depending on the traffic.

application is easily reachable, because it is globally load balanced.

And a tip - recommended way to setup all of the infrastructure is to use IaaS tools like Terraform, Pulumi, Ansible, Saltstack etc. in order not to loose or confuse yourself during setup.