Cloud Run is a fully managed compute platform that automatically scales your stateless containers. It abstracts away all infrastructure management, allowing you to focus on writing code. This module will cover the basics of Cloud Run, how to deploy applications, and best practices for using this service.

1. Serverless Computing: No need to manage servers; you only pay for the resources you use.
2. Containers: Cloud Run runs your application in a container, which can be any language or library.
3. Automatic Scaling: Cloud Run scales your application up or down based on traffic.
4. Stateless Applications: Cloud Run is designed for stateless applications, meaning each request is independent.

• A Google Cloud Platform account.
• Basic knowledge of Docker and containerization.

1. Enable Cloud Run API:

   gcloud services enable run.googleapis.com
   

2. Install Cloud SDK: Follow the instructions here to install the Google Cloud SDK.

3. Authenticate with GCP:

   gcloud auth login
   

4. Set Your Project:

   gcloud config set project [PROJECT_ID]
   

1. Create a Simple Application: Create a simple Python application and save it as app.py:

   from flask import Flask
   
   app = Flask(__name__)
   
   @app.route('/')
   def hello():
       return "Hello, World!"
   
   if __name__ == '__main__':
       app.run(host='0.0.0.0', port=8080)
   

2. Create a Dockerfile: Create a Dockerfile to containerize the application:

   # Use the official Python image from the Docker Hub
   FROM python:3.8-slim
   
   # Set the working directory
   WORKDIR /app
   
   # Copy the current directory contents into the container at /app
   COPY . /app
   
   # Install any needed packages specified in requirements.txt
   RUN pip install flask
   
   # Make port 8080 available to the world outside this container
   EXPOSE 8080
   
   # Define environment variable
   ENV NAME World
   
   # Run app.py when the container launches
   CMD ["python", "app.py"]
   

3. Build the Docker Image:

   docker build -t gcr.io/[PROJECT_ID]/hello-world .
   

4. Push the Docker Image to Google Container Registry:

   docker push gcr.io/[PROJECT_ID]/hello-world
   

5. Deploy to Cloud Run:

   gcloud run deploy hello-world --image gcr.io/[PROJECT_ID]/hello-world --platform managed --region us-central1 --allow-unauthenticated
   

1. Use Environment Variables: Store configuration settings in environment variables.
2. Optimize Docker Images: Use slim or alpine versions of base images to reduce the size.
3. Monitor and Log: Use Stackdriver for monitoring and logging.
4. Security: Ensure your container images are secure and free from vulnerabilities.

1. Create a Node.js Application:

   const express = require('express');
   const app = express();
   
   app.get('/', (req, res) => {
       res.send('Hello, Node.js!');
   });
   
   const PORT = process.env.PORT || 8080;
   app.listen(PORT, () => {
       console.log(`Server is running on port ${PORT}`);
   });
   

2. Create a Dockerfile:

   FROM node:14
   
   WORKDIR /app
   
   COPY package*.json ./
   RUN npm install
   
   COPY . .
   
   EXPOSE 8080
   
   CMD ["node", "index.js"]
   

3. Build and Push the Docker Image:

   docker build -t gcr.io/[PROJECT_ID]/node-app .
   docker push gcr.io/[PROJECT_ID]/node-app
   

4. Deploy to Cloud Run:

   gcloud run deploy node-app --image gcr.io/[PROJECT_ID]/node-app --platform managed --region us-central1 --allow-unauthenticated
   

Follow the steps provided in the exercise to deploy the Node.js application. Ensure you replace [PROJECT_ID] with your actual GCP project ID.

• Incorrect Dockerfile: Ensure your Dockerfile is correctly set up to expose the right port and run the correct command.
• Authentication Issues: Make sure you are authenticated with GCP and have the necessary permissions.
• Region Selection: Choose the appropriate region for your deployment to minimize latency.

In this module, you learned about Cloud Run, a serverless compute platform on GCP. You now know how to set up Cloud Run, deploy a containerized application, and follow best practices. This knowledge will help you build scalable and efficient applications without worrying about infrastructure management.