Docker and Kubernetes Tutorial

Introduction

Docker is a platform that simplifies software deployment by allowing you to bundle an application with its runtime environment into a single package called a container. This ensures that the application will run the same regardless of where it's deployed.

Kubernetes (often abbreviated as K8s) is an open-source container-orchestration system. It's used to automate deployment, scaling, and management of containerized applications, such as those created with Docker.

Prerequisites

• Basic understanding of Linux commands
• Docker installed on your machine. Follow Docker's installation guide to set this up.
• Kubernetes installed on your machine. Follow the official Kubernetes installation guide.

Step 1: Docker - Building an Image

First, let's create a simple Dockerfile for a Node.js app.

Create a new directory on your local machine and navigate into it.

mkdir my-node-app && cd my-node-app

Create a file named Dockerfile.

touch Dockerfile

Open the Dockerfile and add the following code:

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

# Set the working directory in the container to /app
WORKDIR /app

# Copy package.json and package-lock.json to the working directory
COPY package*.json ./

# Install the application dependencies
RUN npm install

# Copy the rest of your application's source code to the working directory
COPY . .

# Make the container listen on port 8080 at runtime
EXPOSE 8080

# Define the command to run the app
CMD [ "node", "server.js" ]

Build the Docker image using the docker build command.

docker build -t my-node-app .

Step 2: Docker - Running a Container

Once the image is built, you can run it as a container using docker run.

docker run -p 8080:8080 -d my-node-app

This command tells Docker to run a container with the my-node-app image, map port 8080 inside the Docker container to port 8080 on the host machine, and run the container in the background (detached mode).

Step 3: Kubernetes - Creating a Deployment

Kubernetes manages Docker containers through objects like Pods and Deployments. A Pod is the smallest and simplest Kubernetes object. It represents a single instance of a running process in a cluster and can contain one or more containers.

Create a file named deployment.yaml with the following content:

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

Apply this Deployment to your Kubernetes cluster using the kubectl apply command.

kubectl apply -f deployment.yaml

This Deployment creates three replicated Pods that run the my-node-app container. If a Pod goes down, the Deployment will automatically recreate it to maintain a count of three.

Step 4: Kubernetes - Exposing Your Deployment

Once the Deployment is up, you might want to expose it to the Internet. In Kubernetes, you can do this using a Service, which is an abstraction that defines a set of Pods and a policy by which to access them.

Create a file named service.yaml with the following content:

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

Apply this Service to your Kubernetes cluster using the kubectl apply command.

kubectl apply -f service.yaml

This Service exposes the my-node-app Deployment outside of the cluster. The type "LoadBalancer" ensures that the Service is accessible through a dedicated network IP on the cloud, if supported by your cloud provider.

Step 5: Kubernetes - Verifying Deployment and Service

To verify if the Deployment is working as expected, run the following command:

kubectl get deployments

You should see the "my-node-app" Deployment with three replicas.

Similarly, to verify the Service, use the following command:

kubectl get services

You should see the "my-node-app" Service with an external IP address. You can use this IP address to access your application from a web browser.

Conclusion

And that's it! This is a very basic example, but it should give you an idea of how to use Docker and Kubernetes to containerize an application and deploy it to a Kubernetes cluster.