🚀 DevOps Portfolio

End-to-end DevOps project showcasing containerization, orchestration, CI/CD, Infrastructure as Code, monitoring, security, and cloud deployment.

⚙ Node.js | 🐳 Docker | ☸ Kubernetes | ☁ AWS EC2 | 🔄 CI/CD | ◆ Terraform | 🛡 Security
Platform Design

🏗 Cloud-Native GitOps Architecture

Live on AWS

The platform evolved from direct server deployments into a GitOps-driven Kubernetes architecture. GitHub Actions now handles Continuous Integration, while Argo CD continuously reconciles the Kubernetes cluster with the desired state stored in Git.

💻
Development

Local Workstation

Application code, Docker resources, Helm charts, Kubernetes configuration, Terraform, and frontend changes are developed and validated locally.

→
💻
Source Control

GitHub

Git stores the application code, Helm desired state, infrastructure configuration, and GitOps definitions.

→
🔄
Continuous Integration

GitHub Actions

CI builds the Docker image, performs Trivy security scanning, pushes immutable Git-SHA images to Docker Hub, and updates Helm values in Git.

🐳
Image Registry

Docker Hub

Stores versioned application images using immutable Git commit tags, providing direct traceability from source commit to running container.

→
🔁
Continuous Delivery

Argo CD

Argo CD watches the Git repository, detects drift, renders the Helm chart, and automatically reconciles Kubernetes with the desired Git state.

→
⎈
Application Packaging

Helm

Helm templates define reusable Kubernetes resources while values.yaml centralizes image tags, replica counts, networking, resource limits, and deployment metadata.

☁️
Infrastructure

AWS EC2 + Terraform

Terraform provisions the Kubernetes worker node in AWS inside the same VPC as the control-plane EC2 instance.

→
☸
Runtime

K3s Kubernetes

The two-node K3s cluster runs the Node.js replicas, Redis, Traefik, Prometheus, Grafana, cert-manager, Argo CD, and supporting workloads.

→
🌐
Public Access

Traefik + HTTPS

Traefik exposes the application, Grafana, and Argo CD through custom HTTPS endpoints secured using cert-manager and Let's Encrypt.

Production Environment

☸ Runtime Architecture

Public traffic enters through Traefik and is routed to a stable Kubernetes Service, which distributes requests across three healthy Node.js application replicas.

🌍

Internet Traffic

Users access the platform through ipg-devops.online over secure HTTPS.

🔀

Traefik Ingress

Routes public requests to the internal Node.js Kubernetes Service based on the configured hostname.

🔌

node-service

Provides one stable ClusterIP endpoint and distributes traffic across healthy application Pods.

📦

Node.js Replicas

Three Node.js Pods run across the K3s control-plane and worker nodes.

Pod 1 Pod 2 Pod 3
🟥

Redis

Stores shared visitor analytics, page views, browser visitor identities, and deployment metadata across all replicas.

📈

Prometheus

Collects node, Kubernetes, Deployment, Service, Pod, and cluster health metrics.

📊

Grafana

Visualizes Prometheus metrics through detailed dashboards and historical resource views.

🔐

cert-manager

Automates Let's Encrypt certificate creation and renewal for secure HTTPS access.

Tools and Platforms

⚙ Technology Stack

🟢

Application

Node.js Express Redis REST API
🐳

Containers

Docker Docker Hub Docker Compose Trivy
☸

Kubernetes

K3s Deployments ReplicaSets Services Ingress ConfigMaps
⎈

Helm

Helm Charts values.yaml Templates Release Management
🔁

GitOps

Argo CD Auto Sync Self-Healing Pruning
☁️

Cloud and IaC

AWS EC2 Terraform Ubuntu AWS VPC Elastic IP
🔄

Continuous Integration

GitHub Actions Git Docker Build Trivy Scan Git-SHA Images
📊

Observability

Prometheus Grafana Node Exporter kube-state-metrics
🌐

Networking

Traefik ClusterIP DNS HTTPS
🛡️

Security

Let's Encrypt cert-manager Trivy Non-root Containers GitHub Secrets
Automated Delivery

🚀 GitOps CI/CD Pipeline

Fully Automated

GitHub Actions is responsible for Continuous Integration, while Argo CD provides Continuous Delivery. Production no longer requires GitHub Actions to SSH into the Kubernetes control plane.

💻 Local Development
→
Git Push
→
GitHub
→
GitHub Actions CI
→
Docker Build
→
Trivy Scan
→
Docker Hub
→
Update Helm Values
→
GitOps Commit
→
Argo CD
→
Helm Rendering
→
Kubernetes Rolling Update
Platform Evolution

🧭 Project Evolution

1

Static Nginx Website

The project started as a manually deployed static website served by Nginx on an AWS EC2 instance.

2

Docker Containerization

The application was containerized using Docker and integrated with GitHub Actions for automated image builds and delivery.

3

Docker Compose

Docker Compose introduced multi-container local orchestration and Redis-backed application state.

4

K3s Kubernetes

Raw Kubernetes manifests replaced Docker Compose for production deployment, introducing Deployments, Services, rolling updates, and Traefik Ingress.

5

Terraform + Two-Node Cluster

Terraform provisioned a dedicated AWS EC2 worker node inside the same VPC as the control plane, evolving the platform into a two-node Kubernetes cluster.

6

Prometheus + Grafana

Full-stack monitoring was added using Prometheus, Grafana, Node Exporter, kube-state-metrics, and live Kubernetes health APIs exposed by the application.

7

Helm Application Packaging

Raw Kubernetes manifests were converted into a Helm chart with centralized values, reusable templates, release history, and configurable deployment metadata.

8

Argo CD + GitOps

Deployment ownership moved from SSH-driven GitHub Actions to Argo CD. Git became the source of truth, with automated sync, self-healing, pruning, and immutable Git-SHA container images.

Current Platform

⭐ Implemented Features

Production Ready

The following capabilities are currently implemented and running in the live AWS-hosted Kubernetes environment.

📦

Application and Containers

  • Node.js and Express REST API
  • Docker containerization
  • Docker Hub image registry
  • Non-root container execution
  • Redis-backed shared state
  • Visitor and page-view analytics
☸

Kubernetes Platform

  • Two-node K3s Kubernetes cluster
  • Control-plane and worker nodes
  • Three application replicas
  • Deployments and ReplicaSets
  • Rolling updates and self-healing
  • Namespaces, ConfigMaps, and Services
🌐

Networking and Security

  • Traefik Ingress Controller
  • ClusterIP application Services
  • Custom domain and DNS
  • HTTPS with Let's Encrypt
  • Certificate automation
  • AWS security-group configuration
🔄

CI/CD and GitOps

  • GitHub Actions Continuous Integration
  • Automated Docker image builds
  • Trivy vulnerability scanning
  • Docker Hub image publishing
  • Immutable Git-SHA image tags
  • Automated Helm values updates
  • Argo CD Continuous Delivery
  • Automatic Git-to-cluster synchronization
  • Argo CD self-healing
  • Automatic resource pruning
  • Git as the deployment source of truth
⎈

Helm Application Management

  • Reusable Helm application chart
  • Centralized values.yaml configuration
  • Templated Kubernetes resources
  • Versioned Helm chart metadata
  • Release history and rollback capability
  • Configurable images, replicas, resources and ingress
🏗️

Infrastructure as Code

  • AWS EC2 infrastructure
  • Terraform worker provisioning
  • Terraform-managed security groups
  • Automated networking rules
  • Elastic IP configuration
  • Version-controlled infrastructure
📊

Monitoring and Observability

  • Prometheus metrics collection
  • Grafana dashboards
  • Node Exporter metrics
  • kube-state-metrics integration
  • Live cluster-health dashboard
  • Interactive resource details
Next Development Stages

🚀 Future Roadmap

Planned
1

Centralized Logging

Next

Introduce Grafana Loki and a Kubernetes log collector to centralize application, Traefik, Kubernetes, and system logs inside Grafana.

Loki Grafana Logs
2

Horizontal Pod Autoscaling

Planned

Scale application replicas automatically according to CPU, memory, or custom metrics.

HPA Metrics Server Scaling
3

Advanced Alerting

Planned

Expand Prometheus Alertmanager rules with actionable notifications, runbooks, and incident response flows.

Alertmanager Runbooks Notifications
4

Kubernetes Security Hardening

Planned

Add NetworkPolicies, stricter RBAC, security contexts, secret management, and stronger workload isolation.

RBAC NetworkPolicy Secrets
5

Multi-Environment GitOps

Planned

Introduce development, staging, and production environments using separate Helm values and Argo CD Applications.

Development Staging Production
6

Progressive Delivery

Planned

Introduce canary or blue/green deployments for safer production releases.

Canary Blue/Green Argo Rollouts
7

Backup and Disaster Recovery

Planned

Add automated Kubernetes backups and documented recovery procedures.

Velero Backup Recovery
Explore the Platform

🔗 Project Links

🌐
Live Application ipg-devops.online

Open the production application and inspect the live cluster dashboard.

↗ 🔁
GitOps Delivery Argo CD

View the live GitOps application state, synchronization status, Kubernetes resource health, and deployment history.

↗ 💻
GitHub Repository GruiaIP/DevOpsApp

Explore the source code, Kubernetes resources, Terraform infrastructure, and CI/CD workflow.

↗ 📊
Grafana Monitoring Dashboards

View detailed Kubernetes, node, Pod, and infrastructure monitoring dashboards.

↗ ✉️
Contact Get in Touch

View my contact information and professional links.

→
🚀

Built as a Continuous Learning Platform

This project continues to evolve as new DevOps, cloud-native, automation, security, and observability technologies are introduced. Every implementation is developed locally, version-controlled in GitHub, validated through CI/CD, and deployed to the live Kubernetes environment.