DOLPA

Setting Up a Kubernetes Cluster and Deploying Docker Containers: A Comprehensive Guide

As containerization continues to dominate modern software development, learning how to manage containers is becoming an essential skill. Kubernetes, a container orchestration platform, makes it easier to deploy, manage, and scale containerized applications across a distributed infrastructure.

Setting Up a Kubernetes Cluster and Deploying Docker Containers: A Comprehensive Guide

Introduction

As containerization continues to dominate modern software development, learning how to manage containers at scale is becoming an essential skill. Kubernetes, a container orchestration platform, makes it easier to deploy, manage, and scale containerized applications across a distributed infrastructure.

In this blog post, we’ll walk you through setting up a Kubernetes cluster and deploying Docker containers on it. This post is aimed at providing a detailed, step-by-step guide for developers and DevOps professionals who are just starting with Kubernetes and Docker. We will cover everything from setting up the Kubernetes cluster (locally and in the cloud) to deploying Docker containers on it.

1. Introduction to Kubernetes Cluster Setup

Kubernetes clusters consist of multiple nodes, each responsible for running containers. A Kubernetes cluster consists of at least one master node (which controls the cluster) and multiple worker nodes (which run containers). The master node manages the overall state of the cluster, while worker nodes host the application containers.

The process of setting up a Kubernetes cluster varies depending on where you want to deploy it—locally for development and testing or in the cloud for production. For this post, we’ll cover both Minikube (for local clusters) and Google Kubernetes Engine (GKE) (for cloud-based clusters).

2. Prerequisites

Before setting up a Kubernetes cluster and deploying Docker containers, you need to ensure you have the following tools installed:

  • Docker: Docker is required to create container images. If you don’t have Docker installed, you can find the installation instructions in this post about installing Docker.
  • kubectl: The Kubernetes command-line tool kubectl is used to interact with your Kubernetes cluster. You can download it from the Kubernetes official site.
  • Minikube (optional for local setup): Minikube is a tool that makes it easy to run Kubernetes locally.
  • Google Cloud SDK (optional for GKE): If you want to deploy your Kubernetes cluster on Google Cloud Platform (GCP), you will need the Google Cloud SDK.

3. Setting Up a Kubernetes Cluster Locally (Using Minikube)

For local development and testing, Minikube is an excellent tool. It allows you to run a Kubernetes cluster on your local machine. Here's how to set up a local Kubernetes cluster with Minikube:

Step 1: Install Minikube

You can download and install Minikube by following the instructions for your operating system here.

On macOS (with Homebrew), you can install Minikube with the following command:

brew install minikube

On Linux:

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

On Windows:

You can use Chocolatey or download the executable from the official website.

Step 2: Start Minikube

Once Minikube is installed, you can start a local Kubernetes cluster with the following command:

minikube start

Minikube will set up a single-node Kubernetes cluster on your local machine. You can verify that Minikube has started successfully by running:

kubectl get nodes

This command should list the local node managed by Minikube.

Step 3: Interact with the Cluster

Now that your Minikube cluster is up and running, you can interact with it using kubectl, the command-line tool for Kubernetes. Test the cluster by deploying a simple application (we'll cover deployment in a later section).

4. Setting Up a Kubernetes Cluster on the Cloud (Using Google Kubernetes Engine - GKE)

For production environments or when you need to scale beyond a local machine, deploying your Kubernetes cluster on a cloud provider is the best approach. In this section, we’ll set up a cluster on Google Kubernetes Engine (GKE).

Step 1: Create a Google Cloud Platform (GCP) Account

If you don’t have a GCP account, create one here. GCP offers a free tier that includes $300 in credit, which can be used for testing services like Kubernetes.

Step 2: Install Google Cloud SDK

To interact with GKE, you’ll need to install the Google Cloud SDK. You can download the SDK from this page.

After installation, authenticate the SDK using:

gcloud auth login

This will prompt you to log in to your Google account.

Step 3: Create a Kubernetes Cluster on GKE

First, set your preferred project and compute zone:

gcloud config set project [PROJECT_ID]
gcloud config set compute/zone [COMPUTE_ZONE]

Replace [PROJECT_ID] with your project ID and [COMPUTE_ZONE] with your preferred zone (e.g., us-central1-a).

Next, create a Kubernetes cluster with the following command:

gcloud container clusters create my-cluster --num-nodes=3

This will create a Kubernetes cluster with three nodes.

Step 4: Connect to Your Cluster

Once the cluster is created, you need to configure kubectl to communicate with it:

gcloud container clusters get-credentials my-cluster

Now, you can use kubectl to interact with your GKE cluster.

5. Building and Pushing a Docker Image

Before deploying a container to your Kubernetes cluster, you need a Docker image. Let's assume you're deploying a simple Node.js application. Here's how to build and push a Docker image.

Step 1: Write a Dockerfile

Create a Dockerfile that defines the image for your application. Here’s a sample Dockerfile for a Node.js application:

# Use an official Node.js runtime as the base image
FROM node:14

# Set the working directory inside the container
WORKDIR /usr/src/app

# Copy package.json and install dependencies
COPY package.json ./
RUN npm install

# Copy the application code
COPY . .

# Expose the application port
EXPOSE 3000

# Command to run the application
CMD ["node", "app.js"]

Step 2: Build the Docker Image

Build the Docker image locally using the following command:

docker build -t my-node-app .

Step 3: Push the Docker Image to a Registry

To deploy the Docker image to Kubernetes, you need to push it to a container registry like Docker Hub or Google Container Registry (GCR).

For Docker Hub:

Push the image to Docker Hub:

docker push [DOCKERHUB_USERNAME]/my-node-app

Tag your image:

docker tag my-node-app [DOCKERHUB_USERNAME]/my-node-app

Log in to your Docker Hub account:

docker login

Alternatively, for GCR, you can follow these instructions to push your image.

6. Deploying Docker Containers to the Kubernetes Cluster

With the Docker image ready and accessible from a registry, you can now deploy the container to your Kubernetes cluster.

Step 1: Create a Deployment Manifest

Create a Kubernetes deployment manifest (deployment.yaml) to define the desired state of the application. Here’s a sample manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: node-app
  template:
    metadata:
      labels:
        app: node-app
    spec:
      containers:
      - name: node-app
        image: [DOCKERHUB_USERNAME]/my-node-app:latest
        ports:
        - containerPort: 3000

This manifest creates a deployment named node-app with 3 replicas. The containers will be created from the Docker image you previously pushed to Docker Hub.

Step 2: Deploy the Application

Apply the deployment manifest to your Kubernetes cluster using kubectl:

kubectl apply -f deployment.yaml

Kubernetes will now pull the Docker image from the registry and create the specified number of container replicas across the nodes in your cluster.

7. Accessing the Deployed Application

To access the application deployed in the cluster, you need to expose it as a service. You can create a LoadBalancer service that routes external traffic to your containers.

Step 1: Create a Service Manifest

Create a service manifest (service.yaml) that defines how the application will be exposed:

apiVersion: v1
kind: Service
metadata:
  name

: node-app-service
spec:
  selector:
    app: node-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
  type: LoadBalancer

This service will forward traffic from port 80 to port 3000 (where the Node.js app is running inside the container).

Step 2: Expose the Service

Apply the service manifest to Kubernetes:

kubectl apply -f service.yaml

Once the service is created, Kubernetes will provision a LoadBalancer, and you can access your application via the external IP address assigned to the LoadBalancer.

8. Scaling the Deployment

Kubernetes makes it easy to scale your applications. You can scale the number of replicas for your deployment using kubectl.

For example, to scale the deployment to 5 replicas, run:

kubectl scale deployment node-app --replicas=5

This command will increase the number of running containers to 5.

9. Monitoring and Managing Pods

You can monitor the status of your pods using kubectl. For example, to view the running pods:

kubectl get pods

To get detailed information about a specific pod:

kubectl describe pod [POD_NAME]

Additionally, if a pod fails or encounters issues, you can view the logs using:

kubectl logs [POD_NAME]

Conclusion

Setting up a Kubernetes cluster and deploying Docker containers may seem daunting at first, but with the right tools and a clear understanding of the steps involved, it becomes a manageable process. Kubernetes provides powerful orchestration capabilities that allow you to deploy and manage containerized applications at scale, making it an essential tool for any DevOps professional.

In this post, we’ve covered how to set up a Kubernetes cluster locally with Minikube and on the cloud with GKE. We’ve also shown you how to build and push Docker images, deploy containers to the Kubernetes cluster, and expose them using services. Additionally, we’ve demonstrated how to scale and monitor your deployments.

With this knowledge, you can now confidently set up your own Kubernetes clusters and deploy Docker containers. Stay tuned for more advanced topics in the Docker-Kubernetes space!

Share Share Share Share Share Email

Read next

Choosing Lightweight Base Images (e.g., Alpine)

When building Docker images, the choice of the base image can significantly impact the final image size, performance, and security. Lightweight base images, such as Alpine Linux, have gained popularity in the Docker community for their minimal footprint and efficiency.