How to deploy a containerized application to Google Kubernetes Engine?

Type Your Question

How to deploy a containerized application to Google Kubernetes Engine?

Sunday, 16 March 2025

GOOGLE

Google Kubernetes Engine (GKE) provides a managed environment for deploying, managing, and scaling containerized applications using Kubernetes. This comprehensive guide will walk you through the process of deploying your application to GKE, from containerization to monitoring. It will cover best practices for ensuring a scalable, reliable and maintainable deployment.

1. Prerequisites

Before you begin, ensure you have the following:

A Google Cloud Platform (GCP) account: Sign up for a free trial if you don't have one.
A GCP Project: Create a project within your GCP account. This is the container for all your GKE resources.
Google Cloud SDK (gcloud CLI): Install and configure the gcloud CLI to interact with GCP. Detailed installation instructions are available on the Google Cloud website. Initialize it with gcloud init.
kubectl CLI: Install the Kubernetes command-line tool, kubectl. This is essential for interacting with your GKE cluster. You can often install this via gcloud components install kubectl.
Docker: Install Docker on your local machine for building and testing container images.

2. Containerizing Your Application with Docker

The first step is to package your application into a Docker container. This ensures consistent execution across different environments.

2.1. Creating a Dockerfile

Create a Dockerfile in your application's root directory. This file contains instructions on how to build your container image. Here's an example:

 # Use an official base image (e.g., Python, Node.js, Java)
 FROM python:3.9-slim-buster

 # Set the working directory inside the container
 WORKDIR /app

 # Copy requirements file
 COPY requirements.txt .

 # Install application dependencies
 RUN pip install --no-cache-dir -r requirements.txt

 # Copy application code
 COPY . .

 # Expose the application port (e.g., 8080)
 EXPOSE 8080

 # Define the command to run the application
 CMD ["python", "app.py"]

Explanation:

FROM: Specifies the base image. Choose one appropriate for your application (e.g., node:16, java:8).
WORKDIR: Sets the working directory inside the container.
COPY: Copies files and directories from your host machine to the container.
RUN: Executes commands inside the container. Used here to install dependencies. The --no-cache-dir flag prevents caching package downloads and reduces image size.
EXPOSE: Declares which port the application listens on. Important for networking.
CMD: Specifies the default command to run when the container starts.

2.2. Building the Docker Image

In your application's directory, build the Docker image using the following command:

 docker build -t your-image-name:tag .

Replace your-image-name with a name for your image (e.g., my-app) and tag with a version tag (e.g., v1.0). The . specifies the current directory as the build context.

2.3. Testing the Docker Image (Optional)

Before pushing the image to a registry, run it locally to ensure it works as expected:

 docker run -p 8080:8080 your-image-name:tag

This will map port 8080 on your host machine to port 8080 inside the container. You should be able to access your application at http://localhost:8080.

3. Pushing the Docker Image to Google Container Registry (GCR)

Google Container Registry (GCR) is a private Docker registry for storing your container images. You can also use Artifact Registry for greater flexibility, but GCR is tightly integrated with GKE and often simpler for basic usage.

3.1. Authenticating with GCR

Authenticate your Docker CLI with your Google Cloud account:

 gcloud auth configure-docker

3.2. Tagging the Image for GCR

Tag your Docker image with the GCR registry path:

 docker tag your-image-name:tag gcr.io/your-project-id/your-image-name:tag

Replace your-project-id with your GCP project ID.

3.3. Pushing the Image

Push the image to GCR:

 docker push gcr.io/your-project-id/your-image-name:tag

4. Creating a Google Kubernetes Engine (GKE) Cluster

Now, create a GKE cluster to run your application.

4.1. Using the gcloud CLI

Create a new GKE cluster using the following command:

 gcloud container clusters create your-cluster-name \
 --zone your-zone \
 --machine-type e2-medium \
 --num-nodes 3

Replace:

your-cluster-name with a name for your cluster (e.g., my-gke-cluster).
your-zone with a GCP zone in your region (e.g., us-central1-a). Choose a zone closest to your users for lower latency.
e2-medium with the desired machine type for your nodes. Consider your application's resource requirements when selecting a machine type. Other options include n1-standard-1, e2-standard-2, etc. Explore pricing implications.
3 with the number of nodes in your cluster. This determines the cluster's capacity. Increase this for higher availability and resilience.

This command creates a basic cluster. For production environments, consider using more advanced configuration options such as:

Specifying node pools with different machine types.
Enabling autoscaling. This automatically adjusts the number of nodes based on resource utilization.
Using a private cluster. Limits external access to your cluster.
Configuring network policies. Restricts network traffic within the cluster.

4.2. Connecting to the Cluster

Configure kubectl to connect to your new cluster:

 gcloud container clusters get-credentials your-cluster-name --zone your-zone

Now kubectl is configured to interact with your cluster.

5. Deploying Your Application to GKE

To deploy your application, you'll define Kubernetes resources like Deployments and Services using YAML files.

5.1. Deployment YAML

Create a deployment.yaml file. A Deployment ensures that a specified number of replicas of your application are running at all times. It also allows you to update your application without downtime.

 apiVersion: apps/v1
 kind: Deployment
 metadata:
 name: your-app-deployment
 spec:
 replicas: 3 # Desired number of pods
 selector:
 matchLabels:
 app: your-app
 template:
 metadata:
 labels:
 app: your-app
 spec:
 containers:
 - name: your-app-container
 image: gcr.io/your-project-id/your-image-name:tag
 ports:
 - containerPort: 8080
 resources:
 requests:
 cpu: 100m
 memory: 128Mi
 limits:
 cpu: 500m
 memory: 256Mi

Explanation:

apiVersion, kind, metadata: Standard Kubernetes resource definition.
spec.replicas: The desired number of pod replicas.
spec.selector: Matches pods based on labels.
spec.template: Defines the pod template. All pods created by this deployment will use this template.
spec.template.spec.containers: Defines the containers within the pod.
spec.template.spec.containers.image: The GCR image to use for the container.
spec.template.spec.containers.ports: Exposes port 8080 from the container.
spec.template.spec.containers.resources: Defines resource requests and limits for the container. Important for resource allocation and scheduling.
- requests: Guaranteed resources for the pod. The scheduler will ensure enough resources are available on a node before scheduling the pod.
- limits: The maximum resources a pod can use. If the pod exceeds the limits, it may be throttled or terminated.

Resource Management Notes: Properly setting resource requests and limits is critical. Under-provisioning can lead to performance issues and resource starvation. Over-provisioning can lead to wasted resources and higher costs. Start with reasonable values based on testing, and then monitor and adjust as needed.

5.2. Service YAML

Create a service.yaml file. A Service provides a stable IP address and DNS name to access your application.

 apiVersion: v1
 kind: Service
 metadata:
 name: your-app-service
 spec:
 selector:
 app: your-app
 ports:
 - protocol: TCP
 port: 80
 targetPort: 8080
 type: LoadBalancer

Explanation:

spec.selector: Matches pods based on the app: your-app label (from the Deployment).
spec.ports: Maps port 80 on the Service to port 8080 on the pod.
spec.type: LoadBalancer provisions a Google Cloud Load Balancer, making your application accessible from the internet. Other types, such as ClusterIP, are used for internal services.

5.3. Applying the YAML Files

Apply the YAML files using kubectl:

 kubectl apply -f deployment.yaml
 kubectl apply -f service.yaml

5.4. Verifying the Deployment

Check the status of your deployment and service:

 kubectl get deployments
 kubectl get services
 kubectl get pods

The kubectl get services command will show the external IP address assigned to your service (if using type: LoadBalancer). Access your application using this IP address in a web browser.

6. Ingress (Optional, Recommended for Production)

For more complex deployments, especially those with multiple services or domains, an Ingress controller is highly recommended. It acts as a reverse proxy and load balancer, routing traffic to the appropriate services based on rules you define.

6.1. Installing an Ingress Controller

The most common Ingress controller for GKE is the GKE Ingress, which is managed by Google. You can also use other Ingress controllers like Nginx Ingress Controller or Traefik.

If using the GKE Ingress, ensure that you have HTTP load balancing enabled on your cluster.

6.2. Ingress YAML

Create an ingress.yaml file:

 apiVersion: networking.k8s.io/v1
 kind: Ingress
 metadata:
 name: your-app-ingress
 annotations:
 kubernetes.io/ingress.global-static-ip-name: your-static-ip # Optional, but recommended for stable IP
 spec:
 rules:
 - host: your-domain.com #Replace this
 http:
 paths:
 - path: /
 pathType: Prefix
 backend:
 service:
 name: your-app-service
 port:
 number: 80

Explanation:

annotations: Allow customization of ingress configuration. kubernetes.io/ingress.global-static-ip-name annotation is very useful, it links the ingress with a static public IP on GCP
spec.rules: Defines rules for routing traffic based on hostname. You must own the domain specified and point its DNS records to the Ingress's IP address.
spec.rules.http.paths: Defines path-based routing. All requests to your-domain.com/ will be routed to the your-app-service.

Before setting annotation kubernetes.io/ingress.global-static-ip-name, make sure a global static ip exist with command: gcloud compute addresses create your-static-ip --global

6.3. Applying the Ingress YAML

 kubectl apply -f ingress.yaml

After creating the Ingress, it may take a few minutes for the load balancer to be provisioned. You can check the status with kubectl get ingress. You may need to reserve and assign a static public IP address to your Ingress to prevent the IP address from changing.

7. Monitoring and Logging

Monitoring and logging are crucial for maintaining a healthy application. GKE integrates with Google Cloud Monitoring (formerly Stackdriver Monitoring) and Google Cloud Logging (formerly Stackdriver Logging).

Cloud Monitoring: Provides metrics for CPU utilization, memory usage, network traffic, and more. You can create dashboards and set up alerts based on these metrics.
Cloud Logging: Collects logs from your application and system components. You can search, filter, and analyze these logs to troubleshoot issues.

Configure your application to emit structured logs for easier analysis in Cloud Logging. Consider using tools like Prometheus and Grafana for more advanced monitoring solutions.

8. Scaling Your Application

Kubernetes provides several ways to scale your application based on demand:

Horizontal Pod Autoscaling (HPA): Automatically adjusts the number of pod replicas based on metrics like CPU utilization.
Cluster Autoscaling: Automatically adjusts the number of nodes in your cluster based on resource demand.

Configure HPA to automatically scale your deployment based on CPU or memory utilization:

 kubectl autoscale deployment your-app-deployment --cpu-percent=70 --min=1 --max=10

This command will create an HPA that scales the your-app-deployment between 1 and 10 replicas, targeting 70% CPU utilization.

9. Updates and Rollbacks

Kubernetes Deployments support rolling updates, allowing you to update your application without downtime. Simply update the image field in your deployment.yaml file and apply the changes with kubectl apply -f deployment.yaml. Kubernetes will gradually replace the old pods with the new pods, ensuring continuous availability.

If an update fails, you can easily roll back to a previous version using kubectl rollout undo deployment/your-app-deployment.

10. Best Practices

Use a Continuous Integration/Continuous Deployment (CI/CD) pipeline. Automate the build, test, and deployment process. Cloud Build integrates well with GKE.
Externalize Configuration. Store configuration data in ConfigMaps and Secrets, and mount them into your pods as environment variables or files. Avoid hardcoding configuration in your application code.
Implement health checks (liveness and readiness probes). Configure health checks in your pod definitions to ensure Kubernetes restarts unhealthy containers.
Use namespaces. Organize your resources into namespaces for better isolation and management.
Secure your cluster. Implement security best practices, such as enabling RBAC (Role-Based Access Control), using network policies, and keeping your Kubernetes version up to date.
Regularly monitor your application and infrastructure. Set up alerts for critical metrics to proactively identify and resolve issues.
Follow the Principle of Least Privilege. When creating service accounts, grant them only the minimum necessary permissions to perform their tasks.
Implement proper security policies to govern ingress and egress traffic to and from the cluster This ensures malicious actors don't leverage open entry points to impact overall service performance.

Conclusion

Deploying to Google Kubernetes Engine (GKE) offers numerous benefits, including scalability, resilience, and ease of management. By following these steps and best practices, you can successfully deploy your containerized applications to GKE and leverage its powerful features.