Kubernetes Web Stack: Ingress, TLS und Deployments richtig planen

Ein Kubernetes-basierter Web Stack ermöglicht skalierbare, hochverfügbare und containerisierte Web-Anwendungen. Durch die Nutzung von Ingress-Ressourcen, TLS-Zertifikaten und strategisch geplanten Deployments können Webanwendungen performant und sicher betrieben werden. Dieser Leitfaden richtet sich an Einsteiger, IT-Studierende und Junior Network Engineers und erklärt praxisnah, wie ein Kubernetes Web Stack aufgebaut und konfiguriert wird.

Kubernetes Cluster Voraussetzungen

• Kubernetes 1.27+ Cluster (Minikube, K3s, oder Cloud Provider wie GKE/AKS/EKS)
• kubectl CLI installiert
• Helm 3 für Chart-Management
• Root- oder Cluster-Admin-Zugriff
• Namespace für die Web-Anwendung: webstack

Namespace erstellen

kubectl create namespace webstack

Deployments für App und Datenbank

Eine typische Web-Anwendung benötigt einen Application Server (z. B. PHP-FPM, Node.js, Django) und eine Datenbank (MySQL, PostgreSQL).

App Deployment Beispiel

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
  namespace: webstack
spec:
  replicas: 3
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: webapp
        image: myregistry/webapp:latest
        ports:
        - containerPort: 3000
        env:
        - name: DB_HOST
          value: "db"
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: username
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: password

Datenbank Deployment Beispiel

apiVersion: apps/v1
kind: Deployment
metadata:
  name: db
  namespace: webstack
spec:
  replicas: 1
  selector:
    matchLabels:
      app: db
  template:
    metadata:
      labels:
        app: db
    spec:
      containers:
      - name: db
        image: postgres:15
        ports:
        - containerPort: 5432
        env:
        - name: POSTGRES_DB
          value: "webapp"
        - name: POSTGRES_USER
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: username
        - name: POSTGRES_PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: password
        volumeMounts:
        - name: db-data
          mountPath: /var/lib/postgresql/data
      volumes:
      - name: db-data
        persistentVolumeClaim:
          claimName: db-pvc

Secrets für Datenbank-Zugang

kubectl create secret generic db-credentials 
  --namespace webstack 
  --from-literal=username=webuser 
  --from-literal=password=Str0ngP@ss

Persistent Volume Claims

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: db-pvc
  namespace: webstack
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

Service Ressourcen

Services abstrahieren die Pods und ermöglichen eine stabile interne Kommunikation.

apiVersion: v1
kind: Service
metadata:
  name: webapp-svc
  namespace: webstack
spec:
  selector:
    app: webapp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
  type: ClusterIP

---
apiVersion: v1
kind: Service
metadata:
  name: db-svc
  namespace: webstack
spec:
  selector:
    app: db
  ports:
    - protocol: TCP
      port: 5432
      targetPort: 5432
  type: ClusterIP

Ingress Ressourcen für HTTP/HTTPS

Ingress stellt den Zugriff von außen bereit, inklusive TLS-Termination und Host-basiertem Routing.

Ingress Controller installieren

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.14.0/deploy/static/provider/cloud/deploy.yaml

Ingress Ressource konfigurieren

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: webapp-ingress
  namespace: webstack
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - example.com
    secretName: webapp-tls
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: webapp-svc
            port:
              number: 80

TLS Zertifikate

Für HTTPS können TLS-Zertifikate manuell oder per Let’s Encrypt via cert-manager bereitgestellt werden.

kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.14.0/cert-manager.yaml

ClusterIssuer für Let’s Encrypt

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: admin@example.com
    privateKeySecretRef:
      name: letsencrypt-prod
    solvers:
    - http01:
        ingress:
          class: nginx

Deployments und Rollouts

Für Zero-Downtime Deployments empfiehlt sich die Nutzung von Rolling Updates.

spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
      maxSurge: 1

Netzwerk- und Subnetzplanung

Bei Multi-Node Clustern sollten ClusterIP, NodePort und LoadBalancer-Dienste sinnvoll auf IPv4/IPv6 Subnetzen geplant werden.

Beispiel IPv4 Subnetz

<math>
WebApp-Pod-IP = 10.244.1.10/24
DB-Pod-IP = 10.244.2.10/24
Ingress-IP = 10.244.0.5/24
Subnetzadresse = 10.244.0.0
Broadcastadresse = 10.244.0.255
</math>

Beispiel IPv6 Subnetz (optional)

<math>
WebApp-Pod-IP = fd00:abcd:1::10/64
DB-Pod-IP = fd00:abcd:2::10/64
Ingress-IP = fd00:abcd:0::5/64
Subnetzadresse = fd00:abcd::0
Broadcastadresse = fd00:abcd::ffff:ffff:ffff:ffff
</math>

Best Practices

• Namespaces für Trennung von Umgebungen (Dev/Prod) nutzen
• Secrets und ConfigMaps für sensible Daten und Konfigurationen
• Rolling Updates für Deployments konfigurieren
• Ingress TLS für HTTPS erzwingen
• Health Checks für Pods definieren (readinessProbe und livenessProbe)
• Ressourcenlimits (CPU/RAM) für Pods setzen
• Monitoring via Prometheus/Grafana implementieren
• Logs zentralisieren (ELK Stack oder Loki)
• Netzwerk-Policies für interne Sicherheit nutzen
• Backup-Strategien für Datenbanken und Persistent Volumes planen

Konfiguriere Cisco Router & Switches und liefere ein Packet-Tracer-Lab/GNS3

Ich biete professionelle Unterstützung im Bereich Netzwerkkonfiguration und Network Automation für private Anforderungen, Studienprojekte, Lernlabore, kleine Unternehmen sowie technische Projekte. Ich unterstütze Sie bei der Konfiguration von Routern und Switches, der Erstellung praxisnaher Topologien in Cisco Packet Tracer, dem Aufbau und Troubleshooting von GNS3- und EVE-NG-Labs sowie bei der Automatisierung von Netzwerkaufgaben mit Netmiko, Paramiko, NAPALM und Ansible. Kontaktieren Sie mich jetzt – klicken Sie hier.

Meine Leistungen umfassen:

• Professionelle Konfiguration von Routern und Switches

• Einrichtung von VLANs, Trunks, Routing, DHCP, NAT, ACLs und weiteren Netzwerkfunktionen

• Erstellung von Topologien und Simulationen in Cisco Packet Tracer

• Aufbau, Analyse und Fehlerbehebung von Netzwerk-Labs in GNS3 und EVE-NG

• Automatisierung von Netzwerkkonfigurationen mit Python, Netmiko, Paramiko, NAPALM und Ansible

• Erstellung von Skripten für wiederkehrende Netzwerkaufgaben

• Dokumentation der Konfigurationen und Bereitstellung nachvollziehbarer Lösungswege

• Konfigurations-Backups, Optimierung bestehender Setups und technisches Troubleshooting

Benötigen Sie Unterstützung bei Ihrem Netzwerkprojekt, Ihrer Simulation oder Ihrer Network-Automation-Lösung? Kontaktieren Sie mich jetzt – klicken Sie hier.