Advanced Kubernetes: Scaling and Production Patterns

2025-10-22 · Pavan Y N · kubernetes, advanced, scaling, production

# title: "Advanced Kubernetes: Helm, Ingress & Auto-scaling" date: "2025-10-22" tags: ["kubernetes", "helm", "ingress", "scaling", "advanced"]

Advanced Kubernetes: Helm, Ingress & Auto-scaling

Take your Kubernetes skills to the next level with Helm charts, Ingress controllers, and horizontal pod autoscaling.

# Helm: The Kubernetes Package Manager

Helm simplifies Kubernetes application deployment through templating and versioning.

## Why Helm?

→Templating: Reusable Kubernetes manifests
→Versioning: Track application versions
→Rollback: Easy rollback to previous versions
→Dependencies: Manage chart dependencies
→Sharing: Distribute applications via Helm repositories

## Installing Helm

code

# Install Helm
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# Verify installation
helm version

## Creating a Helm Chart

code

# Create new chart
helm create myapp

# Chart structure
myapp/
├── Chart.yaml          # Chart metadata
├── values.yaml         # Default values
├── templates/          # Kubernetes manifests
│   ├── deployment.yaml
│   ├── service.yaml
│   └── ingress.yaml
└── charts/            # Dependencies

## Chart.yaml Example

code

apiVersion: v2
name: myapp
description: My application Helm chart
version: 1.0.0
appVersion: "1.0"

## values.yaml Example

code

replicaCount: 3

image:
  repository: myapp
  tag: "1.0.0"
  pullPolicy: IfNotPresent

service:
  type: ClusterIP
  port: 80

resources:
  limits:
    cpu: 500m
    memory: 512Mi
  requests:
    cpu: 250m
    memory: 256Mi

## Template Example

code

# templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-{{ .Chart.Name }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: {{ .Chart.Name }}
  template:
    metadata:
      labels:
        app: {{ .Chart.Name }}
    spec:
      containers:
      - name: {{ .Chart.Name }}
        image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
        ports:
        - containerPort: 8080
        resources:
          {{- toYaml .Values.resources | nindent 12 }}

## Helm Commands

code

# Install chart
helm install myapp ./myapp

# Install with custom values
helm install myapp ./myapp -f custom-values.yaml

# Upgrade release
helm upgrade myapp ./myapp

# Rollback to previous version
helm rollback myapp 1

# List releases
helm list

# Uninstall release
helm uninstall myapp

# View release history
helm history myapp

# Ingress Controllers

Ingress manages external access to services in a cluster.

## What is Ingress?

Ingress provides:

→HTTP/HTTPS routing
→Load balancing
→SSL/TLS termination
→Name-based virtual hosting
→Path-based routing

## Installing NGINX Ingress Controller

code

# Add Helm repository
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

# Install NGINX Ingress
helm install nginx-ingress ingress-nginx/ingress-nginx \
  --set controller.replicaCount=2 \
  --set controller.nodeSelector."kubernetes\.io/os"=linux

## Ingress Resource Example

code

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myapp-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - myapp.example.com
    secretName: myapp-tls
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: myapp-service
            port:
              number: 80
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 8080

## Multiple Host Routing

code

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: multi-host-ingress
spec:
  rules:
  - host: app1.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app1-service
            port:
              number: 80
  - host: app2.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app2-service
            port:
              number: 80

# Horizontal Pod Autoscaling (HPA)

HPA automatically scales pods based on metrics.

## Metrics Server Installation

code

# Install metrics server
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

## CPU-Based Autoscaling

code

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: myapp-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

## Memory-Based Autoscaling

code

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: myapp-memory-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

## Custom Metrics Autoscaling

code

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: myapp-custom-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp
  minReplicas: 2
  maxReplicas: 20
  metrics:
  - type: Pods
    pods:
      metric:
        name: http_requests_per_second
      target:
        type: AverageValue
        averageValue: "1000"

## HPA Commands

code

# Create HPA
kubectl autoscale deployment myapp --cpu-percent=70 --min=2 --max=10

# View HPA status
kubectl get hpa

# Describe HPA
kubectl describe hpa myapp-hpa

# Delete HPA
kubectl delete hpa myapp-hpa

# Resource Management

## Resource Requests and Limits

code

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"

## Quality of Service (QoS) Classes

Guaranteed: Requests = Limits

code

resources:
  requests:
    memory: "512Mi"
    cpu: "500m"
  limits:
    memory: "512Mi"
    cpu: "500m"

Burstable: Requests < Limits

code

resources:
  requests:
    memory: "256Mi"
    cpu: "250m"
  limits:
    memory: "512Mi"
    cpu: "500m"

BestEffort: No requests or limits

## Resource Quotas

code

apiVersion: v1
kind: ResourceQuota
metadata:
  name: compute-quota
  namespace: production
spec:
  hard:
    requests.cpu: "10"
    requests.memory: 20Gi
    limits.cpu: "20"
    limits.memory: 40Gi
    pods: "50"

# Troubleshooting Pod Restarts

## Common Causes

•OOMKilled: Out of memory
•CrashLoopBackOff: Application crashes
•ImagePullBackOff: Cannot pull image
•Liveness probe failures
•Resource constraints

## Debugging Steps

code

# Check pod status
kubectl get pods
kubectl describe pod <pod-name>

# View pod events
kubectl get events --sort-by='.lastTimestamp'

# Check logs
kubectl logs <pod-name>
kubectl logs <pod-name> --previous  # Previous container

# Check resource usage
kubectl top pod <pod-name>

# Execute commands in pod
kubectl exec -it <pod-name> -- /bin/bash

# Check node resources
kubectl top nodes
kubectl describe node <node-name>

## Fixing High Restart Counts

code

# Increase memory limits
kubectl set resources deployment myapp \
  --limits=memory=1Gi \
  --requests=memory=512Mi

# Adjust liveness probe
kubectl patch deployment myapp -p '
{
  "spec": {
    "template": {
      "spec": {
        "containers": [{
          "name": "myapp",
          "livenessProbe": {
            "initialDelaySeconds": 60,
            "periodSeconds": 30
          }
        }]
      }
    }
  }
}'

# Best Practices

•Use Helm for complex applications
•Implement proper resource limits
•Configure HPA for variable loads
•Use Ingress for external access
•Monitor resource usage
•Set appropriate probe timings
•Use namespaces for isolation
•Implement network policies

# Conclusion

Advanced Kubernetes features like Helm, Ingress, and HPA enable production-grade deployments. Master these concepts to build scalable, reliable applications.

# Next Steps

•Create Helm charts for your applications
•Set up Ingress with SSL/TLS
•Implement HPA with custom metrics
•Practice troubleshooting scenarios
•Explore service mesh (Istio, Linkerd)

Happy Kubernetes orchestrating! ☸️