Cloud-Plattformen und Big Data - Kubernetes Demo

A simple microservices application demonstrating Kubernetes deployment with auto-scaling on DigitalOcean. This project was created for the CS1025 Hauptseminar "Cloud-Plattformen und Big Data" (Rupp).

🎯 Project Overview

This application consists of a Go backend and an HTML/JavaScript frontend that displays the current time. It demonstrates:

• Containerization with Docker
• Kubernetes orchestration
• Horizontal Pod Autoscaling (HPA)
• Infrastructure as Code with Terraform
• DigitalOcean cloud deployment
• NGINX Ingress Controller

🏗️ Architecture

┌─────────────────────────────────────────────────────┐
│                   Ingress (NGINX)                   │
│              time.webnils.de                        │
└────────────┬─────────────────────┬──────────────────┘
             │                     │
             │ /                   │ /api
             ▼                     ▼
     ┌───────────────┐     ┌───────────────┐
     │   Frontend    │     │    Backend    │
     │  (nginx:80)   │────▶│   (Go:8080)   │
     │               │     │   + HPA       │
     └───────────────┘     └───────────────┘

Components

• Frontend: Static HTML page served by NGINX that fetches and displays the current time
• Backend: Go HTTP server that provides a REST API endpoint (/api/time) returning the current time in JSON format
• Auto-scaling: HPA configured to scale backend pods (1-5 replicas) based on 50% CPU utilization
• Infrastructure: DigitalOcean Kubernetes cluster (3 nodes, s-2vcpu-4gb) provisioned via Terraform

📁 Project Structure

.
├── Backend/
│   ├── Dockerfile          # Multi-stage build for Go backend
│   ├── go.mod              # Go module definition
│   └── main.go             # Backend API server
├── Frontend/
│   ├── Dockerfile          # NGINX container for static frontend
│   └── index.html          # Time display UI
├── K8S/
│   ├── backend.yaml        # Backend deployment, service, and HPA
│   ├── frontend.yaml       # Frontend deployment and service
│   └── ingress.yaml        # Ingress routing configuration
├── terraform/
│   ├── main.tf             # DigitalOcean cluster and infrastructure
│   ├── input.tf            # Terraform variables
│   └── output.tf           # Terraform outputs
└── presi.txt               # Deployment commands and notes

🚀 Deployment

Prerequisites

• Docker with buildx support
• doctl (DigitalOcean CLI)
• kubectl
• Terraform
• DigitalOcean account with API token

1. Provision Infrastructure

cd terraform
terraform init
terraform apply

This creates:

• Kubernetes cluster (3-node, fra1 region)
• Container registry
• NGINX Ingress Controller
• Metrics Server (for HPA)

2. Build and Push Docker Images

Login to DigitalOcean container registry:

doctl registry login

Build and push backend:

cd Backend
docker buildx build --platform linux/amd64 \
  -t registry.digitalocean.com/hauptseminar/backend:latest \
  --push .

Build and push frontend:

cd Frontend
docker buildx build --platform linux/amd64 \
  -t registry.digitalocean.com/hauptseminar/frontend:latest \
  --push .

3. Configure kubectl

doctl kubernetes cluster list
doctl kubernetes cluster kubeconfig save hs-cluster

4. Deploy to Kubernetes

kubectl apply -f K8S/backend.yaml
kubectl apply -f K8S/frontend.yaml
kubectl apply -f K8S/ingress.yaml

5. Verify Deployment

kubectl get pods
kubectl get services
kubectl get ingress
kubectl get hpa

🔧 Configuration

Backend

• Port: 8080
• Endpoint: /api/time
• CPU Requests: 100m
• CPU Limits: 500m
• Auto-scaling: 1-5 replicas at 50% CPU

Frontend

• Port: 80
• Update Interval: 1 second

Ingress

• Host: time.webnils.de
• Routes:
  • / → Frontend
  • /api → Backend

📊 Monitoring

Check HPA status:

kubectl get hpa backend-hpa --watch

View backend logs:

kubectl logs -l app=backend -f

View metrics:

kubectl top pods
kubectl top nodes

🧪 Testing Auto-Scaling

The backend includes a CPU-intensive loop in each request to simulate load. Generate traffic to trigger auto-scaling:

# Simple load test
while true; do curl https://time.webnils.de/api/time; done

Watch pods scale:

kubectl get hpa backend-hpa --watch
kubectl get pods -l app=backend --watch

🛠️ Development

Local Backend Development

cd Backend
go run main.go
# Server runs on http://localhost:8080

Test endpoint:

curl http://localhost:8080/api/time

Local Frontend Development

cd Frontend
python3 -m http.server 8080
# Open http://localhost:8080

📝 API Reference

GET /api/time

Returns the current server time in RFC3339 format.

Response:

{
  "time": "2025-12-16T10:30:45+01:00"
}

🧹 Cleanup

Remove Kubernetes resources:

kubectl delete -f K8S/

Destroy infrastructure:

cd terraform
terraform destroy

📚 Technologies Used

• Backend: Go 1.25
• Frontend: HTML, JavaScript, NGINX
• Container: Docker, Multi-stage builds
• Orchestration: Kubernetes 1.34
• Cloud: DigitalOcean
• IaC: Terraform
• Ingress: NGINX Ingress Controller
• Monitoring: Kubernetes Metrics Server

📄 License

This is an educational project created for the Hauptseminar "Cloud-Plattformen und Big Data" at the university.

👤 Author

Nils Polek

---

Note: This project demonstrates cloud-native development principles including containerization, orchestration, auto-scaling, and infrastructure as code for educational purposes.

This README was created with AI assistance.