CodingDrills logoAll problemsAll tutorials

GitHub Actions with Docker and Kubernetes

Introduction

In today's fast-paced software development landscape, efficient containerization and orchestration are essential for seamless deployment and scaling of applications. Docker and Kubernetes have become go-to technologies for achieving these goals. In this tutorial, we will delve into the intricacies of Docker and Kubernetes, and explore how they can be used together to implement continuous integration and continuous deployment (CI/CD). Additionally, we will explore the integration of GitHub Actions with Docker and Kubernetes to enhance the development workflow.

Docker: Introduction and Basics

Docker is an open-source platform that enables developers to automate the deployment of applications inside containers. Containers are lightweight, portable, and isolated environments that contain all the necessary dependencies to run an application. Unlike virtual machines, containers do not require a separate operating system, making them incredibly fast and efficient.

To get started with Docker, we need to install the Docker engine on our development machine. You can find the installation instructions for your specific operating system on the Docker website [^1^]. Once Docker is up and running, we can start creating and managing containers using simple command-line interface (CLI) commands.

# Run a container from an image
$ docker run <image_name>

# List running containers
$ docker ps

# Stop a running container
$ docker stop <container_id>

Docker images act as the building blocks for containers. We can build our images from scratch, or use pre-built images from the Docker Hub, a vast repository of ready-to-use images. To create a Docker image, we define a Dockerfile, which contains a set of instructions for building the image. Let's take a look at a simple example:

# Use the base Python image
FROM python:3.8-slim

# Set the working directory
WORKDIR /app

# Copy the requirements file
COPY requirements.txt .

# Install dependencies
RUN pip install -r requirements.txt

# Copy the application files
COPY . .

# Specify the command to run on container startup
CMD ["python", "app.py"]

Once we have defined our Dockerfile, we can use the docker build command to build the image.

$ docker build -t my_app .

Kubernetes: Orchestrating Containers

Kubernetes is a container orchestration platform that simplifies the management and scaling of containerized applications. It provides a highly available and resilient infrastructure for running containers across multiple hosts. With Kubernetes, we can define the desired state of our application, and Kubernetes ensures that the actual state matches the desired state.

To get started with Kubernetes, we need to set up a Kubernetes cluster. There are various ways to do this, including using managed Kubernetes services like Amazon Elastic Kubernetes Service (EKS) or Google Kubernetes Engine (GKE), or setting up a local cluster using tools like Minikube. Once our cluster is up and running, we can start deploying our applications.

In Kubernetes, we define our application deployments using YAML files, known as Kubernetes manifests. A manifest consists of a set of resources, such as deployments, services, and ingress rules. Let's take a look at an example deployment manifest:

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

We can apply the manifest using the kubectl apply command:

$ kubectl apply -f deployment.yaml

Kubernetes ensures that the desired number of replicas of our application are running and handles scaling, load balancing, and self-healing of containers. Additionally, it provides features like rolling updates and canary deployments to ensure smooth application updates.

CI/CD with Docker and Kubernetes

CI/CD is a set of practices that enable developers to automate the process of integrating code changes, testing those changes, and deploying them to production environments. Docker and Kubernetes play a crucial role in facilitating CI/CD, providing efficient and scalable infrastructure for building, testing, and deploying applications.

To implement CI/CD with Docker and Kubernetes, we can use popular tools like Jenkins, GitLab CI/CD, or even leverage cloud-based CI/CD services like GitHub Actions. These tools allow us to define pipelines that automate the various stages of the build, test, and deploy process.

Let's take a brief look at a sample CI/CD pipeline using GitHub Actions:

name: CI/CD

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Build and push Docker image
        uses: docker/build-push-action@v2
        with:
          context: .
          push: true
          tags: my_app:latest

      - name: Deploy to Kubernetes
        uses: azure/k8s-set-context@v1
        with:
          kubeconfig: ${{ secrets.KUBECONFIG }}
          host-type: 'aks'
          cluster-name: 'my-cluster'
          command-type: 'kubectl'
          command: 'apply -f deployment.yaml'

In this example, the pipeline is triggered whenever code is pushed to the main branch. It checks out the code, builds a Docker image, and pushes it to a container registry. Finally, it uses kubectl to apply the Kubernetes manifest for deploying the application to a Kubernetes cluster.

GitHub Actions with Docker and Kubernetes

GitHub Actions is a powerful workflow automation tool provided by GitHub. It allows us to define custom workflows that are triggered by specific events, such as pushes to a repository, pull requests, or the creation of new releases. With the power of GitHub Actions, we can incorporate Docker and Kubernetes seamlessly into our development workflow.

To get started with GitHub Actions, we need to define a workflow YAML file in the .github/workflows directory of our repository. Let's take a look at a simple example workflow that builds and tests a Dockerized application:

name: CI

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Build and test Docker image
        run: |
          docker build -t my_app .
          docker run my_app pytest

  deploy:
    needs: build

    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Build and push Docker image
        uses: docker/build-push-action@v2
        with:
          context: .
          push: true
          tags: my_app:latest

      - name: Deploy to Kubernetes
        uses: azure/k8s-set-context@v1
        with:
          kubeconfig: ${{ secrets.KUBECONFIG }}
          host-type: 'aks'
          cluster-name: 'my-cluster'
          command-type: 'kubectl'
          command: 'apply -f deployment.yaml'

In this workflow, the build job is triggered whenever code is pushed to the main branch. It builds a Docker image, runs tests inside a container, and reports the results. If the build is successful, the deploy job is triggered. This job builds and pushes the Docker image and deploys the application to the Kubernetes cluster.

Conclusion

Docker and Kubernetes provide developers with powerful tools for containerization and orchestration, improving the efficiency and scalability of software development. By incorporating CI/CD practices and leveraging the functionality of GitHub Actions, we can streamline the development workflow and ensure faster and more reliable deployments. Start exploring the possibilities of Docker, Kubernetes, and GitHub Actions today and take your development process to new heights!

References:
[^1^]: Docker Installation Guide, https://docs.docker.com/get-docker/