Step-by-Step Guide to Setting Up a DevOps Pipeline for an Application

Overview

This guide provides a step-by-step process to set up a DevOps pipeline for an application. The pipeline covers the following key areas:

Initializing a repository.
Creating a Dockerfile.
Building a Docker image and pushing it to DockerHub.
Creating Helm charts for deployment.
Setting up GitHub Actions workflows for automation.
Deploying the application using Helm.
Verifying GitHub Actions.

Prerequisites

A GitHub account.
Docker installed on your local machine.
A DockerHub account.
kubectl and Helm installed.
A Kubernetes cluster (can be a local setup like Minikube or a cloud-based cluster).
Basic understanding of DevOps and CI/CD concepts.

Steps

Step 1: Initialize a GitHub Repository

Create a new GitHub repository for your application.

Clone the repository to your local machine:

git clone https://github.com/<YOUR_GITHUB_USERNAME>/<YOUR_REPO>.git
cd your-repo

Add your application source code to the repository.

Step 2: Create a Dockerfile

In the root of your repository, create a file named Dockerfile.

Add the necessary instructions based on your application type (Node.js example shown below):

# Use an official Node.js runtime as a parent image
FROM node:16

# Set the working directory
WORKDIR /app

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

# Copy the rest of the application
COPY . .

# Expose the port the app runs on
EXPOSE 3000

# Start the application
CMD ["npm", "start"]

Step 3: Build and Push the Docker Image

Build the Docker image:

docker build -t <DOCKERHUB_USERNAME>/<APP_NAME>:<TAG> .

Push the image to DockerHub:

docker push <DOCKERHUB_USERNAME>/<APP_NAME>:<TAG>

Step 4: Create Helm Charts

Create a new directory for Helm charts:

mkdir helm-chart
cd helm-chart
helm create <APP_NAME>

Update the values.yaml file with your Docker image details:

image:
  repository: <DOCKERHUB_USERNAME>/<APP_NAME>
  tag: latest

Create the following files in the templates folder:

deployment.yaml: Defines the deployment specification.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: <APP_NAME>
  labels:
    app: <APP_NAME>
spec:
  replicas: 1
  selector:
    matchLabels:
      app: <APP_NAME>
  template:
    metadata:
      labels:
        app: <APP_NAME>
    spec:
      containers:
      - name: <APP_NAME>
        image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
        ports:
        - containerPort: 3000

service.yaml: Defines the service specification.

apiVersion: v1
kind: Service
metadata:
  name: <APP_NAME>
spec:
  type: NodePort
  selector:
    app: <APP_NAME>
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000

ingress.yaml (optional): Defines an ingress resource for exposing the application externally.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: <APP_NAME>-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
  - host: <YOUR_DOMAIN>
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: <APP_NAME>
            port:
              number: 80

Step 5: Create GitHub Actions Workflow

Create a directory named .github/workflows in the repository.

Add a workflow file named ci-cd.yml:

name: CI/CD Pipeline

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

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

      - name: Set up Docker
        uses: docker/setup-buildx-action@v2

      - name: Log in to DockerHub
        uses: docker/login-action@v2
        with:
          username: \${{ secrets.<DOCKER_USERNAME_SECRET> }}
          password: \${{ secrets.<DOCKER_PASSWORD_SECRET> }}

      - name: Build and push Docker image
        run: |
          docker build -t <DOCKERHUB_USERNAME>/<APP_NAME>:<TAG> .
          docker push <DOCKERHUB_USERNAME>/<APP_NAME>:<TAG>

  deploy:
    runs-on: ubuntu-latest
    needs: build

    steps:
      - name: Set up kubectl
        uses: azure/setup-kubectl@v3

      - name: Deploy using Helm
        run: |
          helm upgrade --install <APP_NAME> ./helm-chart --namespace <NAMESPACE>

Add your DockerHub credentials as GitHub secrets (DOCKER_USERNAME and DOCKER_PASSWORD).

Step 6: Deploy Helm Charts

Ensure your Kubernetes cluster is up and running:
```
kubectl cluster-info
```

Deploy the application using Helm:

helm upgrade --install <APP_NAME> ./helm-chart --namespace <NAMESPACE>

Verify the deployment:
```
kubectl get all -n <NAMESPACE>
```

Verification

Verify Docker Image

Ensure the image is available on DockerHub by visiting your repository.

Verify Helm Deployment

Check that the pods are running:
```
kubectl get pods -n <NAMESPACE>
```
Access the application using the service's external IP or NodePort.

Verify GitHub Actions

Go to the Actions tab in your GitHub repository.
Check the status of the CI/CD pipeline runs.
Ensure that both build and deploy jobs have completed successfully.

Identifying Metadata

Repository: GitHub repository containing the application and pipeline files.
Docker Image: Image pushed to DockerHub for deployment.
Helm Chart: Chart used for deploying the application to Kubernetes.
GitHub Actions Workflow: CI/CD pipeline defined in .github/workflows/ci-cd.yml.

Conclusion

By following this guide, you have successfully set up a complete DevOps pipeline for your application. This pipeline automates the process from building and pushing a Docker image to deploying it on Kubernetes using Helm. You can extend this further by adding more stages, such as automated testing and security scanning.

debianmaster/devops-pipeline.md