Docker on Google Cloud

Deploying Docker containers on Google Cloud allows you to leverage Google's robust cloud infrastructure to manage and scale your applications. This guide covers key concepts, steps to deploy Docker containers on Google Cloud, examples, and best practices for deploying Dockerized Express.js applications on Google Cloud.

Key Concepts of Docker on Google Cloud

• Google Kubernetes Engine (GKE): GKE is a managed Kubernetes service that simplifies deploying and managing Kubernetes clusters on Google Cloud.
• Google Container Registry (GCR): GCR is a private Docker image storage service on Google Cloud.
• Google Cloud Run: Cloud Run is a fully managed compute platform that automatically scales your stateless containers.
• Google Compute Engine (GCE): GCE provides scalable virtual machines for containerized applications.
• Identity and Access Management (IAM): IAM provides fine-grained access control to Google Cloud resources.

Setting Up the Project

Initialize a new Express.js project and create a Dockerfile:

// Initialize a new project
// npm init -y

// Install Express
// npm install express

// Create the project structure
// mkdir src
// touch src/index.js Dockerfile .dockerignore .gitignore

// .gitignore
node_modules
.env

// .dockerignore
node_modules
npm-debug.log

Creating an Express Application

Create a simple Express application:

Example: index.js

// src/index.js
const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
    res.send('Hello, Docker on Google Cloud!');
});

app.listen(port, () => {
    console.log(`Server running at http://localhost:${port}/`);
});

Creating a Dockerfile

Create a Dockerfile to containerize your Express application:

Example: Dockerfile

// Dockerfile
FROM node:14

# Create app directory
WORKDIR /usr/src/app

# Install app dependencies
COPY package*.json ./
RUN npm install

# Bundle app source
COPY . .

# Expose port 3000 to the outside world
EXPOSE 3000

# Run app when the container launches
CMD ["node", "src/index.js"]

Building and Running the Docker Container

Build and run the Docker container for your Express application:

// Build the Docker image
docker build -t my-express-app .

// Run the Docker container
docker run -d -p 3000:3000 --name my-express-app my-express-app

// Open http://localhost:3000 in your browser to see the application running

Setting Up Google Cloud

Install Google Cloud SDK, create a GCR repository, and push your Docker image to GCR:

Install Google Cloud SDK

// On a Linux or macOS system
// Install Google Cloud SDK using a package manager or download from the official website
brew install --cask google-cloud-sdk

// Initialize Google Cloud SDK
gcloud init

Create a GCR Repository

// Configure Docker to use gcloud command-line tool as a credential helper
gcloud auth configure-docker

// Tag the Docker image
docker tag my-express-app gcr.io//my-express-app

// Push the Docker image to GCR
docker push gcr.io//my-express-app

Deploying to Google Kubernetes Engine (GKE)

Create a GKE cluster, deploy your Docker container using Kubernetes manifests:

Create a GKE Cluster

// Create a GKE cluster
gcloud container clusters create my-cluster --num-nodes=1

// Get GKE credentials
gcloud container clusters get-credentials my-cluster

Deploy Docker Container to GKE

// Create a Kubernetes deployment file
// deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-express-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-express-app
  template:
    metadata:
      labels:
        app: my-express-app
    spec:
      containers:
      - name: my-express-app
        image: gcr.io//my-express-app
        ports:
        - containerPort: 3000

// Create a Kubernetes service file
// service.yaml
apiVersion: v1
kind: Service
metadata:
  name: my-express-app
spec:
  type: LoadBalancer
  ports:
  - port: 3000
    targetPort: 3000
  selector:
    app: my-express-app

// Apply the deployment and service
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

// Get the external IP of the service
kubectl get services

Deploying to Google Cloud Run

Deploy your Docker container to Cloud Run:

// Enable Cloud Run API
gcloud services enable run.googleapis.com

// Deploy to Cloud Run
gcloud run deploy my-express-app --image gcr.io//my-express-app --platform managed --region us-central1 --allow-unauthenticated

Best Practices for Docker on Google Cloud

• Use Managed Services: Leverage managed services like GKE and Cloud Run to simplify container orchestration and management.
• Enable Monitoring and Logging: Use Google Cloud Operations (formerly Stackdriver) for monitoring and logging your container instances and clusters.
• Secure Your Containers: Use IAM and Google Cloud Security Command Center to secure your containerized applications.
• Auto Scale: Configure auto-scaling for your GKE clusters and Cloud Run services to handle varying loads.
• Use CI/CD Pipelines: Implement CI/CD pipelines with Google Cloud Build or GitHub Actions to automate the deployment process.

Testing Docker on Google Cloud

Test your Dockerized application deployed on Google Cloud to ensure it works correctly:

Example: Testing with Mocha and Chai

// Install Mocha and Chai
// npm install --save-dev mocha chai

// test/app.test.js
const chai = require('chai');
const expect = chai.expect;
const axios = require('axios');

describe('Express App', () => {
    it('should return Hello, Docker on Google Cloud!', async () => {
        const response = await axios.get('http://:3000');
        expect(response.data).to.equal('Hello, Docker on Google Cloud!');
    });
});

// Add test script to package.json
// "scripts": {
//   "test": "mocha"
// }

// Run tests
// npm test

Key Points

Conclusion

Deploying Docker containers on Google Cloud allows you to leverage Google's robust cloud infrastructure to manage and scale your applications. By understanding and implementing the key concepts, steps, examples, and best practices covered in this guide, you can effectively deploy Dockerized Express.js applications on Google Cloud. Happy coding!