Deploying Serverless Applications with Cloud Run on Google Cloud

Google Cloud Run is a serverless compute platform that allows you to run containers without managing the underlying infrastructure. It's an excellent choice for deploying microservices, APIs, web applications, and batch jobs that need to scale rapidly and only pay for what you use.

In this tutorial, we'll explore the key concepts of Cloud Run and guide you through the process of deploying a sample application.

🚀 What is Google Cloud Run?

Cloud Run is a fully managed service that lets you run stateless containers on Google Cloud. This means Google handles all server provisioning, scaling, patching, and management, allowing you to focus solely on your code.

💡 Key Benefits of Cloud Run

• Serverless: No server management required. Google handles the infrastructure.
• Containers: Deploy any application packaged as a Docker container, with no language or library restrictions.
• Pay-per-use: You only pay when your code is running, down to the nearest millisecond of CPU and memory usage.
• Automatic Scaling: Scales from zero to thousands of instances and back down automatically based on demand.
• Integration: Seamlessly integrates with other Google Cloud services like Cloud Build, Cloud SQL, VPCs, and more.
• Custom Domain: Easy mapping of custom domains to your Cloud Run services.

🛠️ Required Tools

Before you begin, make sure you have the following:

1. A Google Cloud Account: If you don't have one, you can sign up for a free trial that includes generous credits.
2. Google Cloud SDK (gcloud CLI): Installed and configured on your local machine. This will allow you to interact with Google Cloud from the command line.
   • You can verify the installation with: gcloud --version
   • If you don't have it, follow the installation instructions in the official Google Cloud documentation.
3. Docker: Installed on your local machine. We'll use it to build our container image.
   • You can verify the installation with: docker --version

🚀 Step 1: Set Up Your Google Cloud Project

First, ensure that the necessary services are enabled in your project.

1.1 Enable APIs

We need to enable the Cloud Run and Artifact Registry APIs (or Container Registry if you prefer).

gcloud services enable run.googleapis.com
gcloud services enable artifactregistry.googleapis.com

1.2 Create an Artifact Registry Repository

Let's create a repository in Artifact Registry to store our Docker image. Choose a region that is close to your users or other GCP services you use.

gcloud artifacts repositories create my-cloudrun-repo \
    --repository-format=docker \
    --location=us-central1 \
    --description="Docker repository for Cloud Run images"

Replace my-cloudrun-repo with a unique name for your repository and us-central1 with your preferred region.

💻 Step 2: Create a Sample Application

For this tutorial, we'll use a simple web application written in Python with Flask. This application will respond with a welcome message.

2.1 Project Structure

Create a folder for your project and, inside it, the following files:

my-cloudrun-app/
├── app.py
├── requirements.txt
└── Dockerfile

2.2 app.py

This file will contain the code for our Flask application.

from flask import Flask
import os

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello from Cloud Run! Greetings from GPT-4o!\n'

if __name__ == '__main__':
    # Get the port from the PORT environment variable, if it doesn't exist, use 8080
    port = int(os.environ.get('PORT', 8080))
    app.run(debug=True, host='0.0.0.0', port=port)

2.3 requirements.txt

This file will list the Python dependencies.

Flask==2.3.3

2.4 Dockerfile

This file defines how our Docker image will be built.

# Usa una imagen base de Python ligera
FROM python:3.9-slim-buster

# Establece el directorio de trabajo dentro del contenedor
WORKDIR /app

# Copia los archivos de requerimientos e instala las dependencias
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copia el código de tu aplicación
COPY .

# Expone el puerto que usará la aplicación (Cloud Run lo manejará)
EXPOSE 8080

# Comando para ejecutar la aplicación cuando el contenedor se inicie
# Usamos gunicorn para producción, pero para este ejemplo simple, python app.py es suficiente
# CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:$PORT"]
CMD ["python", "app.py"]

📦 Step 3: Build and Push the Docker Image

Now that we have our application and Dockerfile, we'll build the Docker image and upload it to Artifact Registry.

3.1 Build the Image

Navigate to the my-cloudrun-app folder in your terminal and run the following command. Replace my-cloudrun-repo and us-central1 with your values.

docker build -t us-central1-docker.pkg.dev/YOUR_PROJECT_ID/my-cloudrun-repo/my-cloudrun-app:1.0 .

Make sure to replace YOUR_PROJECT_ID with your Google Cloud project ID.

3.2 Authenticate Docker with Artifact Registry

To push the image, Docker needs to authenticate with Artifact Registry. Run:

gcloud auth configure-docker us-central1-docker.pkg.dev

Replace us-central1 with your repository's region.

3.3 Push the Image to Artifact Registry

docker push us-central1-docker.pkg.dev/YOUR_PROJECT_ID/my-cloudrun-repo/my-cloudrun-app:1.0

Verify that the image has been uploaded correctly by visiting the Artifact Registry section in the Google Cloud console, or by listing the images with gcloud artifacts docker images list.

🚀 Step 4: Deploy the Application to Cloud Run

With the container image in Artifact Registry, we are ready to deploy it to Cloud Run.

4.1 Deploy the Service

gcloud run deploy my-cloudrun-service \
    --image us-central1-docker.pkg.dev/YOUR_PROJECT_ID/my-cloudrun-repo/my-cloudrun-app:1.0 \
    --platform managed \
    --region us-central1 \
    --allow-unauthenticated \
    --max-instances 10 \
    --cpu 1 \
    --memory 512Mi \
    --port 8080

Let's break down the arguments:

• my-cloudrun-service: The name you give your Cloud Run service.
• --image: Full path to your Docker image in Artifact Registry.
• --platform managed: Specifies that we'll use the managed version of Cloud Run (the most common and easiest to use).
• --region: The region where your service will be deployed. It should be the same as your Artifact Registry repository or nearby.
• --allow-unauthenticated: Allows the service to be invoked without authentication credentials. Ideal for public web applications or APIs.
• --max-instances: The maximum number of instances Cloud Run can scale for your service. Adjust as needed.
• --cpu: The amount of vCPU allocated to each instance. A minimum of 1 vCPU is recommended for most web applications.
• --memory: The amount of memory allocated to each instance. Adjust according to your application's requirements.
• --port: The port your container listens for traffic on. This must match the EXPOSE in your Dockerfile and the port your Flask application is listening on.

During deployment, the gcloud CLI will ask if you want to create new permissions or if you agree with the configuration. Confirm to continue.

4.2 Verify the Deployment

Once the deployment is complete, the terminal will show you the service URL. Open this URL in your browser. You should see the message: Hello from Cloud Run! Greetings from GPT-4o!

You can also get service details with:

gcloud run services describe my-cloudrun-service --platform managed --region us-central1

This will give you detailed information, including the URL, service status, and scaling configuration.

📊 Step 5: Cloud Run Management and Scalability

Cloud Run offers powerful features for managing and scaling your services.

5.1 Adjust Concurrency

Concurrency is the maximum number of simultaneous requests each instance of your service can handle. The default value is 80.

To adjust it, you can use the update command:

gcloud run services update my-cloudrun-service \
    --platform managed \
    --region us-central1 \
    --concurrency 50

5.2 Set a Minimum Number of Instances

By default, Cloud Run scales to zero instances when there's no traffic. If you need consistent low startup latency or have specific requirements, you can keep a minimum number of instances always active.

gcloud run services update my-cloudrun-service \
    --platform managed \
    --region us-central1 \
    --min-instances 1

This ensures that at least one instance is always ready to respond to requests, though it will incur an associated cost.

5.3 Custom Domain Mapping

To use your own domain (e.g., api.mysite.com) with Cloud Run, follow these steps:

1. Add domain mapping:

gcloud run domains add-mapping --service my-cloudrun-service --domain api.mysite.com --platform managed --region us-central1

2. Update DNS records: Cloud Run will provide you with CNAME or A/AAAA records that you'll need to add to your domain's DNS configuration.

5.4 Environment Variables

You can inject environment variables into your Cloud Run services for configurations, API keys, etc.

gcloud run services update my-cloudrun-service \
    --platform managed \
    --region us-central1 \
    --set-env-vars ENV_VAR_NAME=value,ANOTHER_VAR=another_value

5.5 Integration with Cloud SQL

If your application needs a database, Cloud Run easily integrates with Cloud SQL. Simply authorize your Cloud Run service to connect to your Cloud SQL instance.

gcloud run services update my-cloudrun-service \
    --platform managed \
    --region us-central1 \
    --add-cloudsql-instances YOUR_CLOUD_SQL_CONNECTION_NAME

Where YOUR_CLOUD_SQL_CONNECTION_NAME is in the format PROJECT_ID:REGION:INSTANCE_NAME.

🗑️ Cleaning Up Resources

To avoid unexpected charges, it's good practice to delete resources you no longer need.

1. Delete the Cloud Run service:

gcloud run services delete my-cloudrun-service --platform managed --region us-central1

2. Delete the Artifact Registry image:

gcloud artifacts docker images delete us-central1-docker.pkg.dev/YOUR_PROJECT_ID/my-cloudrun-repo/my-cloudrun-app:1.0 --delete-tags --delete-metadata

3. Delete the Artifact Registry repository (optional):

gcloud artifacts repositories delete my-cloudrun-repo --location=us-central1

4. Disable APIs (optional):

gcloud services disable run.googleapis.com
gcloud services disable artifactregistry.googleapis.com

❓ Frequently Asked Questions (FAQ)

Conclusion ✨

You've completed this tutorial on how to deploy serverless applications with Cloud Run on Google Cloud. You've learned how to build a Docker image, upload it to Artifact Registry, and deploy it as a scalable service on Cloud Run. You've also explored advanced configuration and management options.

Cloud Run is a powerful tool for modernizing your applications and reducing operational overhead. Experiment with different configurations and explore its integrations with other Google Cloud services to take your projects to the next level.

Happy deploying!