import { MermaidDiagram } from '@/components/mermaid-diagram'

Learn how to implement container orchestration using Kubernetes. This comprehensive guide covers architecture, deployment strategies, and best practices for managing containerized applications at scale.

diagram={

graph TB

subgraph "Control Plane"

API["API Server"]

Scheduler["Scheduler"]

Controller["Controller Manager"]

ETCD["etcd"]

end

subgraph "Worker Nodes"

Kubelet["Kubelet"]

Proxy["Kube Proxy"]

Runtime["Container Runtime"]

end

subgraph "Workloads"

Pod["Pods"]

Service["Services"]

Volume["Volumes"]

end

API --> Scheduler

API --> Controller

API --> ETCD

Scheduler --> Kubelet

Controller --> Kubelet

Kubelet --> Runtime

Runtime --> Pod

Pod --> Service

Pod --> Volume

style API fill:#3b82f6,stroke:#2563eb,color:white

style Scheduler fill:#3b82f6,stroke:#2563eb,color:white

style Controller fill:#3b82f6,stroke:#2563eb,color:white

style ETCD fill:#3b82f6,stroke:#2563eb,color:white

style Kubelet fill:#f1f5f9,stroke:#64748b

style Proxy fill:#f1f5f9,stroke:#64748b

style Runtime fill:#f1f5f9,stroke:#64748b

style Pod fill:#f1f5f9,stroke:#64748b

style Service fill:#f1f5f9,stroke:#64748b

style Volume fill:#f1f5f9,stroke:#64748b

}

$1

Container orchestration with Kubernetes provides:

1. Automated Deployment: Declarative application deployment

2. Scaling: Horizontal and vertical scaling capabilities

3. Service Discovery: Automatic service registration and discovery

4. Load Balancing: Traffic distribution across replicas

5. Self-healing: Automatic recovery from failures

$1

Define deployment manifests for your applications:

``yaml

`deployment.yaml`


apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
  labels:
    app: myapp
    environment: production
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "8080"
    spec:
      securityContext:
        runAsUser: 1000
        runAsGroup: 3000
        fsGroup: 2000
      containers:
        - name: myapp
          image: myapp:latest
          imagePullPolicy: Always
          ports:
            - containerPort: 8080
              name: http
          resources:
            requests:
              cpu: "100m"
              memory: "128Mi"
            limits:
              cpu: "500m"
              memory: "512Mi"
          livenessProbe:
            httpGet:
              path: /health
              port: http
            initialDelaySeconds: 30
            periodSeconds: 10
            timeoutSeconds: 5
            failureThreshold: 3
          readinessProbe:
            httpGet:
              path: /ready
              port: http
            initialDelaySeconds: 5
            periodSeconds: 5
          startupProbe:
            httpGet:
              path: /startup
              port: http
            failureThreshold: 30
            periodSeconds: 10
          env:
            - name: POD_NAME
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
            - name: POD_NAMESPACE
              valueFrom:
                fieldRef:
                  fieldPath: metadata.namespace
            - name: NODE_NAME
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName
          envFrom:
            - configMapRef:
                name: myapp-config
            - secretRef:
                name: myapp-secrets
          volumeMounts:
            - name: config-volume
              mountPath: /app/config
              readOnly: true
            - name: data-volume
              mountPath: /app/data
      volumes:
        - name: config-volume
          configMap:
            name: myapp-config
        - name: data-volume
          persistentVolumeClaim:
            claimName: myapp-data
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 100
              podAffinityTerm:
                labelSelector:
                  matchExpressions:
                    - key: app
                      operator: In
                      values:
                        - myapp
                topologyKey: kubernetes.io/hostname
      tolerations:
        - key: "node-role.kubernetes.io/master"
          operator: "Exists"
          effect: "NoSchedule"

`$1`

Configure service and ingress resources:

`yaml

`service.yaml`


apiVersion: v1
kind: Service
metadata:
  name: myapp
  labels:
    app: myapp
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: nlb
    service.beta.kubernetes.io/aws-load-balancer-cross-zone-load-balancing-enabled: "true"
spec:
  type: LoadBalancer
  ports:
    - port: 80
      targetPort: http
      protocol: TCP
      name: http
  selector:
    app: myapp
  sessionAffinity: ClientIP
  sessionAffinityConfig:
    clientIP:
      timeoutSeconds: 10800
ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myapp
  annotations:
    kubernetes.io/ingress.class: nginx
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    nginx.ingress.kubernetes.io/force-ssl-redirect: "true"
    nginx.ingress.kubernetes.io/proxy-body-size: "50m"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
    nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  tls:
    - hosts:
        - myapp.example.com
      secretName: myapp-tls
  rules:
    - host: myapp.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: myapp
                port:
                  name: http

`$1`

Manage application configuration:

`yaml

`configmap.yaml`


apiVersion: v1
kind: ConfigMap
metadata:
  name: myapp-config
data:
  application.properties: |
    server.port=8080
    spring.application.name=myapp
    management.endpoints.web.exposure.include=health,metrics,prometheus
    logging.level.root=INFO
    logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n
  feature-flags.properties: |
    feature.new-ui=true
    feature.beta-api=false
  nginx.conf: |
    worker_processes auto;
    events {
      worker_connections 1024;
    }
    http {
      upstream backend {
        server localhost:8080;
      }
      server {
        listen 80;
        location / {
          proxy_pass http://backend;
        }
      }
    }
secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: myapp-secrets
type: Opaque
stringData:
  DB_URL: jdbc:postgresql://db.example.com:5432/myapp
  DB_USER: myapp
  DB_PASSWORD: ${DB_PASSWORD}
  API_KEY: ${API_KEY}
  JWT_SECRET: ${JWT_SECRET}

`$1`

Configure persistent storage:

`yaml

`storage.yaml`


apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: myapp-data
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
  storageClassName: gp2
storage-class.yaml
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: gp2
provisioner: kubernetes.io/aws-ebs
parameters:
  type: gp2
  encrypted: "true"
  kmsKeyId: ${KMS_KEY_ID}
reclaimPolicy: Retain
allowVolumeExpansion: true
volumeBindingMode: WaitForFirstConsumer

`$1`

Configure horizontal pod autoscaling:

`yaml

`hpa.yaml`


apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: myapp
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp
  minReplicas: 3
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 80
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 80
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 0
      policies:
        - type: Percent
          value: 100
          periodSeconds: 15
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
        - type: Percent
          value: 100
          periodSeconds: 15

diagram={

graph TB

subgraph "Build"

Code["Source Code"]

Image["Container Image"]

Registry["Container Registry"]

end

subgraph "Deploy"

Deploy["Deployment"]

Service["Service"]

Ingress["Ingress"]

end

subgraph "Scale"

HPA["HPA"]

VPA["VPA"]

CA["Cluster Autoscaler"]

end

Code --> Image

Image --> Registry

Registry --> Deploy

Deploy --> Service

Service --> Ingress

Deploy --> HPA

HPA --> CA

Deploy --> VPA

style Code fill:#3b82f6,stroke:#2563eb,color:white

style Image fill:#3b82f6,stroke:#2563eb,color:white

style Registry fill:#3b82f6,stroke:#2563eb,color:white

style Deploy fill:#f1f5f9,stroke:#64748b

style Service fill:#f1f5f9,stroke:#64748b

style Ingress fill:#f1f5f9,stroke:#64748b

style HPA fill:#f1f5f9,stroke:#64748b

style VPA fill:#f1f5f9,stroke:#64748b

style CA fill:#f1f5f9,stroke:#64748b

$1

Set resource requests and limits

Implement horizontal pod autoscaling

Use node affinity and anti-affinity

Configure pod disruption budgets

Monitor resource utilization

$1

Deploy across multiple zones

Implement pod anti-affinity

Use PodDisruptionBudgets

Configure proper health checks

Implement proper backup strategies

$1

Use network policies

Implement RBAC

Secure sensitive data

Regular security scanning

Monitor security events

$1

Implement proper logging

Set up metrics collection

Configure alerts

Use distributed tracing

Regular auditing

$1

Effective container orchestration requires:

1. Proper configuration

2. Resource management

3. Security controls

4. Monitoring

5. Automation

Remember to:

Follow best practices

Monitor continuously

Update regularly

Document everything

Test thoroughly

$1

1. [Kubernetes Documentation](https://kubernetes.io/docs/)

2. [Container Security](https://kubernetes.io/docs/concepts/security/)

3. [Kubernetes Patterns](https://k8spatterns.io/)

4. [Cloud Native Trail Map](https://landscape.cncf.io/)

5. [Kubernetes Best Practices](https://kubernetes.io/docs/concepts/configuration/overview/)

6. [Container Networking](https://kubernetes.io/docs/concepts/cluster-administration/networking/)

Container Orchestration: A Deep Dive into Kubernetes and Beyond

TL;DR

$1

$1

$1

`deployment.yaml`

`$1`

`service.yaml`

ingress.yaml

`$1`

`configmap.yaml`

secret.yaml

`$1`

`storage.yaml`

storage-class.yaml

`$1`

`hpa.yaml`

$1

$1

$1

$1

$1

$1

$1

Why This Matters

Trade-offs to Consider

When NOT to Use This

Decision Framework

Related Articles

gitops-infrastructure

containers-docker

ansible-tips

Related Articles

gitops-infrastructure
DevopsIntermediate
gitops-infrastructure
Aug 30, 20261 min
DevopsIntermediate
gitops-infrastructure
Aug 30, 20261 min

containers-docker
DevopsIntermediate
containers-docker
Aug 30, 20261 min
DevopsIntermediate
containers-docker
Aug 30, 20261 min

ansible-tips
DevopsIntermediate
ansible-tips
Aug 30, 20261 min
DevopsIntermediate
ansible-tips
Aug 30, 20261 min