# Day 34: CI/CD - GitHub Actions with Docker, and Kubernetes Deployment

In today's fast-paced software development landscape, automating the deployment process is crucial to ensure efficiency and consistency. This guide will walk you through the process of setting up a GitHub Action workflow, building a Docker image using a Dockerfile, and deploying the image to a Kubernetes cluster.

## Deploying a Node.js Application to Kubernetes

### Step 1: Setting up GitHub Repository

1. Create a new repository named "nodejs-k8s-deployment" on GitHub.
    
2. Clone the repository to your local machine: `git clone` [`https://github.com/your-username/nodejs-k8s-deployment.git`](https://github.com/your-username/nodejs-k8s-deployment.git)
    
3. Navigate to the repository's directory: `cd nodejs-k8s-deployment`
    

### Step 2: Dockerfile Creation

1. Create a `Dockerfile` in the repository directory:
    
    ```Dockerfile
    # Use the official Node.js image as the base image
    FROM node:14
    
    # Set the working directory
    WORKDIR /app
    
    # Copy package.json and package-lock.json to the working directory
    COPY package*.json ./
    
    # Install dependencies
    RUN npm install
    
    # Copy application code
    COPY . .
    
    # Specify the startup command
    CMD ["node", "app.js"]
    ```
    
2. Commit the `Dockerfile` to your repository:
    
    ```sh
    git add Dockerfile
    git commit -m "Add Dockerfile for Node.js app"
    git push origin main
    ```
    

### Step 3: GitHub Action Workflow

1. Create a `.github/workflows/build-deploy.yaml` file:
    
    ```yaml
    name: Build and Deploy
    
    on:
      push:
        branches:
          - main
    
    jobs:
      build-deploy:
        runs-on: ubuntu-latest
    
        steps:
          - name: Checkout code
            uses: actions/checkout@v2
    
          - name: Set up Docker
            uses: actions/setup-docker@v2
    
          - name: Build Docker image
            run: docker build -t your-username/nodejs-app:latest .
    
          - name: Log in to Docker Hub
            uses: docker/login-action@v1
            with:
              username: ${{ secrets.DOCKER_USERNAME }}
              password: ${{ secrets.DOCKER_PASSWORD }}
    
          - name: Push Docker image
            run: docker push your-username/nodejs-app:latest
    
          - name: Deploy to Kubernetes
            run: kubectl apply -f kubernetes/
    ```
    
2. Commit and push the workflow YAML file:
    
    ```sh
    git add .github/workflows/build-deploy.yaml
    git commit -m "Add GitHub Action workflow for build and deploy"
    git push origin main
    ```
    

### Step 4: Docker Registry Setup (if needed)

1. Create Docker Hub account and create a repository named "nodejs-app".
    
2. Generate a Docker Hub access token and save it as a secret in your GitHub repository named `DOCKER_USERNAME` and `DOCKER_PASSWORD`.
    

### Step 5: Kubernetes Configuration

1. Create a `kubernetes` directory in the repository.
    
2. Inside the `kubernetes` directory, create a `deployment.yaml` file:
    
    ```yaml
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nodejs-app
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: nodejs-app
      template:
        metadata:
          labels:
            app: nodejs-app
        spec:
          containers:
            - name: nodejs-app
              image: your-username/nodejs-app:latest
              ports:
                - containerPort: 3000
    ```
    
3. Create a `service.yaml` file:
    
    ```yaml
    apiVersion: v1
    kind: Service
    metadata:
      name: nodejs-app
    spec:
      selector:
        app: nodejs-app
      ports:
        - protocol: TCP
          port: 80
          targetPort: 3000
      type: LoadBalancer
    ```
    
4. Commit the Kubernetes manifests to your repository:
    
    ```sh
    git add kubernetes/
    git commit -m "Add Kubernetes deployment and service manifests"
    git push origin main
    ```
    

### Step 6: Deploying to Kubernetes

1. Update the GitHub Action workflow to apply Kubernetes manifests:
    
    ```yaml
    # ...
          - name: Deploy to Kubernetes
            run: |
              kubectl apply -f kubernetes/
              kubectl rollout restart deployment/nodejs-app
    ```
    
2. Commit and push the changes to the workflow YAML file.
    

### Step 7: Testing the Workflow

1. Make a code change in your Node.js application.
    
2. Push the change to your repository.
    
3. Monitor the GitHub Actions workflow under the "Actions" tab in your repository to ensure it completes successfully.
    
4. Access your Kubernetes cluster and verify that the updated application is running.
    

## **Conclusion:**

Congratulations! You've successfully set up a GitHub Action workflow that builds a Docker image using a Dockerfile and deploys it to a Kubernetes cluster. This automated process will streamline your development and deployment workflows, making them more consistent and efficient.

Remember to regularly review and update your workflows as your application and infrastructure evolve. Happy coding and deploying!

Thanks for reading! I hope you found this blog informative and insightful. For more technology-related content, don't forget to follow me on [GitHub](https://github.com/techwithankush) and [LinkedIn](https://www.linkedin.com/in/techwithankush)