Azure Kubernetes Services Anfänger: Der komplette AKS Guide für Einsteiger

Azure Kubernetes Services (AKS) ist Microsofts verwalteter Kubernetes-Dienst und eine der beliebtesten Lösungen für Container-Orchestrierung in der Cloud. In diesem umfassenden Azure Kubernetes Services Anfänger Guide zeigen wir Ihnen alles, was Sie wissen müssen, um mit AKS zu starten - von den Grundlagen bis zur ersten Anwendung.

Der Azure Kubernetes Services Anfänger Markt wächst rasant in Deutschland, da immer mehr Unternehmen auf Container-Technologien setzen. Mit AKS können deutsche Unternehmen von der Cloud-Infrastruktur profitieren und gleichzeitig DSGVO-konforme Lösungen implementieren.

Was ist Azure Kubernetes Services (AKS)?

Azure Kubernetes Services Anfänger sollten zunächst verstehen, was AKS ist und warum es so beliebt ist. AKS ist ein vollständig verwalteter Kubernetes-Dienst von Microsoft, der es Ihnen ermöglicht, Container-Anwendungen in der Azure-Cloud zu betreiben, ohne die Komplexität der Kubernetes-Cluster-Verwaltung bewältigen zu müssen.

Warum AKS für Anfänger ideal ist

Vollständig verwaltet: Microsoft übernimmt die Verwaltung der Control Plane
Einfache Integration: Nahtlose Integration mit anderen Azure-Diensten
Kosteneffizient: Sie zahlen nur für die Worker Nodes
Skalierbar: Automatische Skalierung basierend auf Bedarf
Sicher: Integrierte Sicherheitsfeatures und Compliance

AKS vs. andere Kubernetes-Lösungen

Feature	AKS	Self-Managed Kubernetes	EKS (AWS)	GKE (Google)
Verwaltung	Vollständig verwaltet	Manuell	Teilweise verwaltet	Vollständig verwaltet
Kosten	Nur Worker Nodes	Control Plane + Worker Nodes	Nur Worker Nodes	Nur Worker Nodes
Azure-Integration	Nahtlos	Manuell	Begrenzt	Begrenzt
Lernkurve	Niedrig	Hoch	Mittel	Niedrig

Azure Kubernetes Services Anfänger: Erste Schritte

Voraussetzungen für AKS

Bevor Sie mit Azure Kubernetes Services Anfänger beginnen, benötigen Sie:

Azure-Account: Ein aktives Azure-Abonnement
Azure CLI: Installierte Azure Command Line Interface
kubectl: Kubernetes Command Line Tool
Docker: Für Container-Images (optional, da AKS Container Registry unterstützt)

Azure CLI Installation und Konfiguration

# Azure CLI installieren (Windows)
winget install Microsoft.AzureCLI

# Azure CLI installieren (macOS)
brew install azure-cli

# Azure CLI installieren (Linux)
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

# Bei Azure anmelden
az login

# Abonnement auswählen
az account set --subscription "Ihr-Abonnement-Name"

kubectl Installation

# kubectl installieren (Windows)
az aks install-cli

# kubectl installieren (macOS/Linux)
az aks install-cli

# Installation testen
kubectl version --client

AKS-Cluster erstellen: Schritt-für-Schritt Anleitung

1. Resource Group erstellen

# Resource Group für AKS erstellen
az group create --name aks-anfaenger-rg --location westeurope

# Resource Group überprüfen
az group show --name aks-anfaenger-rg

2. AKS-Cluster erstellen

# AKS-Cluster erstellen
az aks create \
  --resource-group aks-anfaenger-rg \
  --name aks-anfaenger-cluster \
  --node-count 2 \
  --node-vm-size Standard_B2s \
  --enable-addons monitoring \
  --generate-ssh-keys

# Cluster-Status überprüfen
az aks show --resource-group aks-anfaenger-rg --name aks-anfaenger-cluster

3. Cluster-Zugriff konfigurieren

# kubeconfig-Datei herunterladen
az aks get-credentials --resource-group aks-anfaenger-rg --name aks-anfaenger-cluster

# Cluster-Verbindung testen
kubectl get nodes
kubectl get pods --all-namespaces

Azure Kubernetes Services Anfänger: Erste Anwendung deployen

1. Einfache Web-Anwendung erstellen

Erstellen Sie eine einfache Node.js-Anwendung:

// app.js
const express = require('express')
const app = express()
const port = process.env.PORT || 3000

app.get('/', (req, res) => {
  res.send('Hallo von Azure Kubernetes Services!')
})

app.get('/health', (req, res) => {
  res.json({ status: 'healthy', timestamp: new Date().toISOString() })
})

app.listen(port, () => {
  console.log(`Server läuft auf Port ${port}`)
})

2. Dockerfile erstellen

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "app.js"]

3. Container-Image erstellen und pushen

# Azure Container Registry erstellen
az acr create --resource-group aks-anfaenger-rg \
  --name aksanfaengeracr --sku Basic

# AKS mit ACR verbinden
az aks update -n aks-anfaenger-cluster -g aks-anfaenger-rg \
  --attach-acr aksanfaengeracr

# Image erstellen und pushen
az acr build --registry aksanfaengeracr --image aks-anfaenger-app:latest .

4. Kubernetes-Manifest erstellen

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: aks-anfaenger-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: aks-anfaenger-app
  template:
    metadata:
      labels:
        app: aks-anfaenger-app
    spec:
      containers:
        - name: aks-anfaenger-app
          image: aksanfaengeracr.azurecr.io/aks-anfaenger-app:latest
          ports:
            - containerPort: 3000
          resources:
            requests:
              memory: '64Mi'
              cpu: '250m'
            limits:
              memory: '128Mi'
              cpu: '500m'
          livenessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 30
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /
              port: 3000
            initialDelaySeconds: 5
            periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: aks-anfaenger-service
spec:
  type: LoadBalancer
  ports:
    - port: 80
      targetPort: 3000
  selector:
    app: aks-anfaenger-app

5. Anwendung deployen

# Deployment anwenden
kubectl apply -f deployment.yaml

# Status überprüfen
kubectl get pods
kubectl get services

# Externe IP-Adresse abrufen
kubectl get service aks-anfaenger-service

Azure Kubernetes Services Anfänger: Monitoring und Logging

Azure Monitor für Container

AKS bietet integriertes Monitoring über Azure Monitor:

# Monitoring aktivieren (falls noch nicht geschehen)
az aks enable-addons --addons monitoring \
  --resource-group aks-anfaenger-rg \
  --name aks-anfaenger-cluster

Logs abrufen

# Pod-Logs anzeigen
kubectl logs <pod-name>

# Logs mit Follow-Modus
kubectl logs -f <pod-name>

# Logs für alle Pods eines Deployments
kubectl logs -l app=aks-anfaenger-app

Metriken überwachen

# Pod-Metriken anzeigen
kubectl top pods

# Node-Metriken anzeigen
kubectl top nodes

# Resource-Usage überwachen
kubectl describe pod <pod-name>

Azure Kubernetes Services Anfänger: Skalierung und Autoscaling

Manuelle Skalierung

# Deployment auf 5 Replicas skalieren
kubectl scale deployment aks-anfaenger-app --replicas=5

# Skalierung überprüfen
kubectl get deployment aks-anfaenger-app

Horizontales Pod Autoscaling (HPA)

# hpa.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: aks-anfaenger-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: aks-anfaenger-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

# HPA anwenden
kubectl apply -f hpa.yaml

# HPA-Status überprüfen
kubectl get hpa

Cluster Autoscaler

# Cluster Autoscaler aktivieren
az aks update \
  --resource-group aks-anfaenger-rg \
  --name aks-anfaenger-cluster \
  --enable-cluster-autoscaler \
  --min-count 1 \
  --max-count 5

Azure Kubernetes Services Anfänger: Sicherheit und Networking

Azure Active Directory Integration

# AAD-Integration aktivieren
az aks update \
  --resource-group aks-anfaenger-rg \
  --name aks-anfaenger-cluster \
  --enable-aad \
  --aad-admin-group-object-ids <group-object-id>

Network Policies

# network-policy.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: aks-anfaenger-network-policy
spec:
  podSelector:
    matchLabels:
      app: aks-anfaenger-app
  policyTypes:
    - Ingress
    - Egress
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: frontend
      ports:
        - protocol: TCP
          port: 3000
  egress:
    - to:
        - podSelector:
            matchLabels:
              app: database
      ports:
        - protocol: TCP
          port: 5432

RBAC (Role-Based Access Control)

# rbac.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: aks-anfaenger-role
rules:
  - apiGroups: ['']
    resources: ['pods', 'services']
    verbs: ['get', 'list', 'watch']
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: aks-anfaenger-rolebinding
  namespace: default
subjects:
  - kind: User
    name: anfaenger@example.com
    apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: aks-anfaenger-role
  apiGroup: rbac.authorization.k8s.io

Azure Kubernetes Services Anfänger: Best Practices

1. Resource Limits definieren

resources:
  requests:
    memory: '64Mi'
    cpu: '250m'
  limits:
    memory: '128Mi'
    cpu: '500m'

2. Health Checks implementieren

livenessProbe:
  httpGet:
    path: /health
    port: 3000
  initialDelaySeconds: 30
  periodSeconds: 10
readinessProbe:
  httpGet:
    path: /
    port: 3000
  initialDelaySeconds: 5
  periodSeconds: 5

3. Secrets Management

# Secret erstellen
kubectl create secret generic aks-anfaenger-secret \
  --from-literal=username=admin \
  --from-literal=password=geheim123

# Secret in Deployment verwenden
env:
- name: DB_USERNAME
  valueFrom:
    secretKeyRef:
      name: aks-anfaenger-secret
      key: username

4. ConfigMaps für Konfiguration

# ConfigMap erstellen
kubectl create configmap aks-anfaenger-config \
  --from-literal=environment=production \
  --from-literal=log-level=info

# ConfigMap in Deployment verwenden
env:
- name: ENVIRONMENT
  valueFrom:
    configMapKeyRef:
      name: aks-anfaenger-config
      key: environment

Azure Kubernetes Services Anfänger: Troubleshooting

Häufige Probleme und Lösungen

1. Pod startet nicht

# Pod-Status überprüfen
kubectl describe pod <pod-name>

# Pod-Logs anzeigen
kubectl logs <pod-name>

# Events anzeigen
kubectl get events --sort-by='.lastTimestamp'

2. Service nicht erreichbar

# Service-Status überprüfen
kubectl describe service <service-name>

# Endpoints überprüfen
kubectl get endpoints <service-name>

# Port-Forwarding testen
kubectl port-forward service/<service-name> 8080:80

3. Image Pull Error

# Image-Pull-Secret erstellen
kubectl create secret docker-registry acr-secret \
  --docker-server=<acr-name>.azurecr.io \
  --docker-username=<service-principal-id> \
  --docker-password=<service-principal-password>

# Secret in Deployment referenzieren
imagePullSecrets:
- name: acr-secret

Azure Kubernetes Services Anfänger: Kostenoptimierung

1. Node Pool Management

# Spot-Instances für Development verwenden
az aks nodepool add \
  --resource-group aks-anfaenger-rg \
  --cluster-name aks-anfaenger-cluster \
  --name spotpool \
  --node-count 1 \
  --node-vm-size Standard_B2s \
  --priority Spot \
  --eviction-policy Delete \
  --spot-max-price -1

2. Resource Quotas

# resource-quota.yaml
apiVersion: v1
kind: ResourceQuota
metadata:
  name: aks-anfaenger-quota
spec:
  hard:
    requests.cpu: '4'
    requests.memory: 8Gi
    limits.cpu: '8'
    limits.memory: 16Gi
    pods: '10'

3. Monitoring und Alerting

# Azure Monitor Alerts erstellen
az monitor metrics alert create \
  --name "aks-anfaenger-cpu-alert" \
  --resource-group aks-anfaenger-rg \
  --scopes "/subscriptions/<subscription-id>/resourceGroups/aks-anfaenger-rg/providers/Microsoft.ContainerService/managedClusters/aks-anfaenger-cluster" \
  --condition "avg Percentage CPU > 80" \
  --description "CPU usage is high"

Azure Kubernetes Services Anfänger: Nächste Schritte

1. CI/CD-Pipeline einrichten

# azure-pipelines.yml
trigger:
  - main

pool:
  vmImage: 'ubuntu-latest'

steps:
  - task: Docker@2
    inputs:
      containerRegistry: 'Azure Container Registry'
      repository: 'aks-anfaenger-app'
      command: 'buildAndPush'
      Dockerfile: '**/Dockerfile'
      tags: '$(Build.BuildId)'

  - task: KubernetesManifest@0
    inputs:
      action: 'deploy'
      kubernetesServiceConnection: 'aks-service-connection'
      manifests: '**/deployment.yaml'
      containers: '$(ContainerRegistry)/aks-anfaenger-app:$(Build.BuildId)'

2. Helm Charts verwenden

# Helm installieren
az aks command invoke \
  --resource-group aks-anfaenger-rg \
  --name aks-anfaenger-cluster \
  --command "helm repo add stable https://charts.helm.sh/stable"

# Beispiel: Nginx Ingress Controller installieren
helm install nginx-ingress stable/nginx-ingress \
  --namespace ingress-basic \
  --set controller.replicaCount=2

3. Service Mesh (Istio) implementieren

# Istio installieren
az aks command invoke \
  --resource-group aks-anfaenger-rg \
  --name aks-anfaenger-cluster \
  --command "istioctl install --set profile=demo -y"

Häufig gestellte Fragen (FAQ)

Wie viel kostet AKS?

AKS selbst ist kostenlos - Sie zahlen nur für die Worker Nodes. Die Kosten hängen von der Anzahl und Größe der Nodes ab. Ein 2-Node-Cluster mit Standard_B2s kostet etwa 50-100€ pro Monat.

Kann ich AKS auch on-premise betreiben?

Nein, AKS ist ein Cloud-Service. Für On-Premise-Lösungen können Sie Azure Stack HCI mit AKS-HCI verwenden oder selbst verwaltete Kubernetes-Cluster betreiben.

Wie sicher ist AKS?

AKS bietet umfassende Sicherheitsfeatures: automatische Updates, integrierte RBAC, Network Policies, Azure Security Center Integration und Compliance-Zertifizierungen.

Kann ich AKS mit anderen Cloud-Providern verwenden?

AKS ist spezifisch für Azure. Für Multi-Cloud-Strategien können Sie Kubernetes-Cluster bei verschiedenen Providern betreiben oder Azure Arc für Kubernetes verwenden.

Wie lange dauert die AKS-Einrichtung?

Ein einfacher AKS-Cluster kann in 10-15 Minuten erstellt werden. Die vollständige Einrichtung mit Monitoring, CI/CD und Sicherheitskonfiguration dauert 1-2 Stunden.

Welche Programmiersprachen unterstützt AKS?

AKS unterstützt alle Programmiersprachen, die in Docker-Containern laufen können: Node.js, Python, Java, .NET, Go, PHP, Ruby und viele mehr.

Dieser Azure Kubernetes Services Anfänger Guide bietet Ihnen eine solide Grundlage für den Einstieg in AKS. Für weitere Unterstützung und individuelle Beratung kontaktieren Sie unsere Experten.