Manideep Tangallapally

DevOps Learning Portal

A professional, project-based guide to building CI/CD, GitOps, and monitoring from scratch.

What We Built

This portal documents a practical path from source code to a running Kubernetes application with GitOps delivery and monitoring. The pages are written like project notes: what each tool did in the pipeline, how we implemented it, what commands mattered, and what an interviewer expects you to understand.

End state: a developer pushes code, GitHub Actions builds and publishes a Docker image, Kubernetes manifests are updated, ArgoCD syncs the cluster, Prometheus scrapes metrics, and Grafana shows the health of the system.
Developer laptop
  | git add / commit / push
  v
GitHub repository
  | pull request + branch rules
  v
GitHub Actions workflow
  | test -> docker build -> tag -> push
  v
Docker Hub image registry
  | immutable image tag
  v
GitOps manifests repository/path
  | ArgoCD watches desired state
  v
Kubernetes cluster
  | app pods + services + ingress
  v
Prometheus scrapes metrics -> Grafana dashboards

Learning Path

Docker

The container artifact that connects CI builds to Kubernetes runtime.

Kubernetes

The runtime platform where our container becomes a resilient service.

GitHub Actions

Automation that turns repository events into tested, built, published artifacts.

ArgoCD

The GitOps controller that deploys what Git declares.

Prometheus

Metrics collection for the app and cluster after deployment.

Grafana

Operational dashboards for the CI/CD and Kubernetes system.

Project Assumptions

  • The application can be any web API or frontend service; the DevOps flow is the important part.
  • GitHub is the source of truth for code and automation, while ArgoCD treats Git as the source of truth for Kubernetes desired state.
  • Docker Hub is used as the image registry because it is simple to understand and works well for a first complete pipeline.
  • Examples use realistic names such as devops-demo, main, staging, and prod. Replace them with your repository, namespace, and Docker Hub account.

Architecture

+----------------+       +--------------------+       +----------------+
| Developer      | push  | GitHub Repository  | event | GitHub Actions |
| local machine  +------>+ code + manifests   +------>+ CI workflow    |
+----------------+       +---------+----------+       +-------+--------+
                                     |                          |
                                     | manifest update          | docker push
                                     v                          v
                              +------+-------+          +-------+--------+
                              | ArgoCD       | watches  | Docker Hub     |
                              | Application  +--------->+ image registry |
                              +------+-------+          +-------+--------+
                                     |                          |
                                     | sync                     | image pull
                                     v                          v
                              +------+--------------------------+--------+
                              | Kubernetes cluster: deployments, services |
                              +------+--------------------------+--------+
                                     |
                                     | scrape and visualize
                                     v
                              +------+----------+       +-------+--------+
                              | Prometheus      +------>+ Grafana        |
                              +-----------------+       +----------------+

How To Use These Pages

  1. Read Git first because every later tool depends on clean commits and branches.
  2. Move to Docker to package the app into a repeatable artifact.
  3. Use Kubernetes to understand how that artifact runs in the cluster.
  4. Use GitHub Actions and Runners to automate the repeatable steps.
  5. Use ArgoCD, Prometheus, and Grafana to turn deployment into an observable operating model.
Git and GitHub →