DevOpsified | Complete DevOps Implementation in one project

Summary

Abhishek Veeramalla demonstrates how to add end-to-end DevOps practices to a Go web application. The project is a portfolio-style site that includes source code, tests, and instructions for running locally. It serves traffic on port 8080; during the walkthrough, the presenter discovers that the site is available at /courses.

Implementation Walkthrough

1. Containerization

• Builds a multi-stage Docker image: a Go image compiles the application, then a distroless image receives the compiled binary and required static files.
• Explains that multi-stage builds can reduce the final image size and limit its contents.
• Tests the image locally, then pushes it to Docker Hub.
• Fixes a build mismatch by aligning the Go base-image version with the version required by the project.

2. Kubernetes Manifests

• Creates a Deployment, ClusterIP Service, and host-based Ingress.
• Emphasizes matching Pod labels to the Deployment selector and Service selector.
• Advises beginners to understand Kubernetes manifest fields and consult the documentation rather than trying to memorize YAML.

3. EKS Cluster and Deployment Checks

• Outlines the prerequisites for creating an AWS EKS cluster: kubectl, eksctl, AWS CLI, and AWS credentials.
• Uses an EKS cluster backed by EC2 instances. The cluster is already available for the live demonstration; the presenter notes that cluster creation can take around 30 minutes or more.
• Applies the manifests and verifies the application through a temporary NodePort before configuring Ingress.

4. Ingress Controller and DNS

• Installs the community NGINX Ingress Controller, which watches Ingress resources and provisions a load balancer according to their rules. In this AWS setup, it creates a Network Load Balancer.
• Explains the roles of the Ingress resource, controller, and load balancer, and how the Ingress class identifies which controller should handle a resource.
• Maps the load balancer’s address to a local hostname using /etc/hosts for testing. In production, the hostname would instead be connected to DNS through the organization’s DNS setup.

5. Helm

• Creates a Helm chart and places the Kubernetes manifests in its templates directory.
• Uses values.yaml to make the image tag configurable, showing how one chart can support different environments without separate hard-coded manifests.
• Installs and uninstalls the chart to confirm that Helm renders and manages the resources.

6. Continuous Integration and Delivery

• Implements GitHub Actions for CI, triggered by pushes to the main branch. The workflow:
  • Builds the Go application and runs unit tests.
  • Performs static analysis and linting.
  • Builds and pushes a Docker image tagged with a unique GitHub run ID.
  • Updates the Helm chart’s values.yaml with the new tag and commits the change.
• Stores Docker Hub credentials and a GitHub token as repository secrets rather than placing credentials directly in the workflow.
• Configures Argo CD for GitOps-based delivery. Argo CD watches the repository, detects Helm chart changes, and automatically deploys them to the cluster. Automatic sync and self-healing are enabled.
• Demonstrates the complete workflow with a small application-content change: GitHub Actions builds and publishes a new image, updates the Helm values, and Argo CD deploys the new version.

Guides and Resources

• The companion go-web-app-devops repository is presented as a reference for the Dockerfile, Kubernetes manifests, Helm chart, CI/CD configuration, Ingress setup, EKS steps, Argo CD installation, and written notes.
• The presenter points viewers to Kubernetes and NGINX Ingress documentation, the GitHub Actions Marketplace, and AWS CLI and eksctl installation instructions.
• He recommends cleaning up the EKS cluster after experimentation to avoid leaving cloud resources running.

Main Speaker and Sources

• Main speaker: Abhishek Veeramalla, presenting and narrating the tutorial.
• Referenced sources and tools: The go-web-app and go-web-app-devops GitHub repositories; Kubernetes, AWS/EKS, NGINX Ingress, GitHub Actions, Docker Hub, Helm, and Argo CD documentation or interfaces.