Using a Global Load Balancer with Cloud Run

Configure the Environment

1. Enable Cloud Run API

   gcloud services enable run.googleapis.com

2. Set the compute and run regions

   gcloud config set compute/region us-central1
   gcloud config set run/region us-central1

3. Create a LOCATION environment variable

   LOCATION="us-central1"
   

Write a simple application

1. In Cloud Shell create a new directory named helloworld, then move your view into that directory:
   mkdir helloworld && cd helloworld
2. Next you’ll be creating and editing files. To edit files, use vi, emac, nano or the Cloud Shell Editor by clicking on the pencil icon in Cloud Shell (“Open Editor”).
   
3. Create a main.py file, then add the following content to it:

   import os
   from flask import Flask
   app = Flask(__name__)
   @app.route("/")
   def hello_world():
   name = os.environ.get("NAME", "World")
   return "Hello {}!".format(name)
   if __name__ == "__main__":
   app.run(debug=True, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))

Containerize your app and upload it to Container Registry (Artifact Registry)

1. To containerize the sample app you just made, create a new file named Dockerfile in the same directory as the main.py file, and add the following content :

   # Use the official lightweight Python image.
   # https://hub.docker.com/_/python
   FROM python:3.9-slim
   # Allow statements and log messages to immediately appear in the Knative logs
   ENV PYTHONUNBUFFERED True
   # Copy local code to the container image.
   ENV APP_HOME /app
   WORKDIR $APP_HOME
   COPY . ./
   # Install production dependencies.
   RUN pip install Flask gunicorn
   # Run the web service on container startup. Here we use the gunicorn
   # webserver, with one worker process and 8 threads.
   # For environments with multiple CPU cores, increase the number of workers
   # to be equal to the cores available.
   # Timeout is set to 0 to disable the timeouts of the workers to allow Cloud Run to handle instance scaling.
   CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 main:app

2. Now, build your container image using Cloud Build, by running the following command from the directory containing the Dockerfile:

   gcloud builds submit --tag gcr.io/$GOOGLE_CLOUD_PROJECT/helloworld

Deploy your container to Cloud Run

1. Now that we have our containerized image, we will need to use the gcloud command below to deploy it to Cloud Run. Replace PROJECT-ID with your GCP project ID. You can view your project ID by running the command gcloud config get-value project.

   gcloud run deploy --image gcr.io/$GOOGLE_CLOUD_PROJECT/helloworld

2. You will then be prompted for the service name: press Enter to accept the default name, helloworld.
3. If prompted for region: in this case, select us-central1.
4. Visit your deployed container by opening the service URL in a web browser.

Reserve an external IP address

1. Use the following command to reserve your static IP address:

   gcloud compute addresses create example-ip \
   --ip-version=IPV4 \
   --global

2. To display the IP address that was just reserved, use:

   gcloud compute addresses describe example-ip \
   --format="get(address)" \
   --global

Create the external HTTP load balancer

1. To create a serverless NEG with a Cloud Run service, enter the following in Cloud Shell:

   gcloud compute network-endpoint-groups create myneg \
   --region=$LOCATION \
   --network-endpoint-type=serverless \
   --cloud-run-service=helloworld

2. Now, we need to create a backend service:

   gcloud compute backend-services create mybackendservice \
   --global

3. And then add the serverless NEG as a backend to this backend service:

   gcloud compute backend-services add-backend mybackendservice \
   --global \
   --network-endpoint-group=myneg \
   --network-endpoint-group-region=$LOCATION

4. Finally, create a URL map to route incoming requests to the backend service:

   gcloud compute url-maps create myurlmap \
   --default-service mybackendservice

5. Now, create a target HTTP(S) proxy to route requests to your URL map:

   gcloud compute target-http-proxies create mytargetproxy \
   --url-map=myurlmap

6. Create a global forwarding rule to route incoming requests to the proxy:

   gcloud compute forwarding-rules create myforwardingrule \
   --address=example-ip \
   --target-http-proxy=mytargetproxy \
   --global \
   --ports=80

7. You can test your HTTP load balancer by going to http://IP_ADDRESS, where IP_ADDRESS is the load balancer’s IP address you reserved earlier in this lab. When you open this URL, you should see the helloworld service homepage.