# Docker lernen
docker run hello-world
docker build -t my-app .
docker-compose up -d

# Container-Konzepte verstehen
- Images vs. Container
- Layer-basierte Architektur
- Container-Lebenszyklus
- Ressourcenlimits

# Linux-Grundlagen
ls -la /proc/
netstat -tulpn
systemctl status docker

# Networking-Konzepte
- TCP/IP-Stack
- DNS-Auflösung
- Load Balancing
- Service Discovery

# Cloud-Konzepte verstehen
- Virtualisierung vs. Containerisierung
- IaaS, PaaS, SaaS
- Cloud-native Architekturen
- Microservices-Patterns

# Kubernetes-Komponenten verstehen
control-plane:
  - api-server: API-Gateway
  - etcd: Distributed Key-Value Store
  - scheduler: Pod-Platzierung
  - controller-manager: Zustandsverwaltung

worker-nodes:
  - kubelet: Node-Agent
  - kube-proxy: Netzwerk-Proxy
  - container-runtime: Docker/containerd

# Minikube Setup
minikube start
kubectl get nodes
kubectl get pods --all-namespaces

# Kind (Kubernetes in Docker)
kind create cluster
kubectl cluster-info

# Pods, Services, Deployments
apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
spec:
  containers:
    - name: nginx
      image: nginx:latest
      ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - port: 80
      targetPort: 80
  type: ClusterIP

# Persistent Volumes
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
spec:
  serviceName: mysql
  replicas: 3
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
        - name: mysql
          image: mysql:8.0
          volumeMounts:
            - name: mysql-storage
              mountPath: /var/lib/mysql
  volumeClaimTemplates:
    - metadata:
        name: mysql-storage
      spec:
        accessModes: ['ReadWriteOnce']
        resources:
          requests:
            storage: 10Gi

# Network Policies
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
spec:
  podSelector: {}
  policyTypes:
    - Ingress
    - Egress
---
# RBAC
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
  - apiGroups: ['']
    resources: ['pods']
    verbs: ['get', 'watch', 'list']

# Prometheus ServiceMonitor
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: app-monitor
spec:
  selector:
    matchLabels:
      app: my-app
  endpoints:
    - port: metrics
      interval: 30s

# Cluster API
apiVersion: cluster.x-k8s.io/v1beta1
kind: Cluster
metadata:
  name: production-cluster
spec:
  clusterNetwork:
    pods:
      cidrBlocks: ['10.244.0.0/16']
    services:
      cidrBlocks: ['10.96.0.0/12']
  controlPlaneRef:
    apiVersion: controlplane.cluster.x-k8s.io/v1beta1
    kind: KubeadmControlPlane
    name: production-control-plane

# ArgoCD Application
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/my-org/my-app
    targetRevision: HEAD
    path: k8s
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

# Praktische Übungen
# 1. Cluster Setup
kubeadm init --pod-network-cidr=10.244.0.0/16
kubeadm join --token <token> <master-ip>:6443

# 2. Troubleshooting
kubectl describe pod <pod-name>
kubectl logs <pod-name>
kubectl exec -it <pod-name> -- /bin/bash

# 3. Networking
kubectl get endpoints
kubectl get services
kubectl get networkpolicies

# Praktische Übungen
# 1. Multi-Container Pods
apiVersion: v1
kind: Pod
metadata:
  name: sidecar-pod
spec:
  containers:
  - name: app
    image: my-app:latest
  - name: sidecar
    image: nginx:latest
    volumeMounts:
    - name: shared-volume
      mountPath: /shared

# 2. ConfigMaps & Secrets
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  database_url: "postgresql://localhost:5432/mydb"
  log_level: "INFO"

# Kompletter Anwendungsstack
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
spec:
  replicas: 3
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
        - name: frontend
          image: nginx:latest
          ports:
            - containerPort: 80
          resources:
            requests:
              memory: '64Mi'
              cpu: '250m'
            limits:
              memory: '128Mi'
              cpu: '500m'
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
        - name: backend
          image: my-backend:latest
          env:
            - name: DATABASE_URL
              valueFrom:
                secretKeyRef:
                  name: db-secret
                  key: url
          resources:
            requests:
              memory: '128Mi'
              cpu: '500m'
            limits:
              memory: '256Mi'
              cpu: '1000m'

# Horizontal Pod Autoscaler
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 80

# Prometheus & Grafana Setup
apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
data:
  prometheus.yml: |
    global:
      scrape_interval: 15s
    scrape_configs:
    - job_name: 'kubernetes-pods'
      kubernetes_sd_configs:
      - role: pod
      relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: true

# Grundlegende Kompetenzen
- Beherrschung von kubectl
- Verständnis von Pod/Service/Deployment
- Grundlegendes Troubleshooting
- Monitoring-Tools (Grafana, Prometheus)

# Erweiterte Kompetenzen
- GitOps (ArgoCD, Flux)
- Sicherheit (RBAC, Network Policies)
- Strategien für Multi-Cloud-Umgebungen
- Fortgeschrittenes Troubleshooting

# Führungskompetenzen
- Plattform-Engineering
- Teammanagement
- Strategisches Denken
- Beziehungen zu Anbietern

# Katacoda (jetzt Play with Kubernetes)
# Kostenlose interaktive Übungen

# Killercoda
# Moderne Alternative zu Katacoda

# Minikube / Kind
# Lokale Entwicklungsumgebung

Kubestronaut = Grundlagen + Praxis + Zertifizierung + Community + Kontinuierliches Lernen