Übung: Erstellen des HorizontalPodAutoscaler

15 Minuten

Übung: Skalieren einer Anwendung

Erstellen eines AKS-Clusters

Bevor Sie mit der Skalierung Ihrer Anwendung beginnen können, müssen Sie einen AKS-Cluster mit den erforderlichen Ressourcen erstellen.

Melden Sie sich bei Azure Cloud Shell mit dem Konto an, unter dem Sie Ressourcen bereitstellen möchten, und wählen Sie Bash als auszuführende Shell aus.
Erstellen Sie mit dem Befehl az group create eine Ressourcengruppe. Das folgende Beispiel erstellt eine Ressourcengruppe mit dem Namen myResourceGroup am Standort eastus:
```
az group create --name myResourceGroup --location eastus
```
Erstellen Sie mit dem Befehl az aks create einen AKS-Cluster. Im folgenden Beispiel wird ein Cluster mit dem Namen myAKSCluster in einer Ressourcengruppe namens myResourceGroup erstellt. Der Cluster verfügt über einen Knoten und verwendet die VM-Größe Standard_DS2_v2.
```
az aks create --resource-group myResourceGroup --name myAKSCluster --node-count 1 --node-vm-size Standard_DS2_v2 --enable-app-routing --generate-ssh-keys
```
Die Ausführung dieses Befehls dauert einige Minuten.
Rufen Sie die Anmeldeinformationen für den Cluster mithilfe des Befehls az aks get-credentials ab.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Vergewissern Sie sich mithilfe des Befehls kubectl get nodes, dass der Cluster ausgeführt wird und Sie eine Verbindung damit herstellen können.
```
kubectl get nodes
```
Der Befehl sollte einen Knoten mit dem Status Ready zurückgeben.

Bereitstellen der Anwendungsressourcen

Nachdem Sie nun über einen Cluster verfügen, können Sie die Anwendung darin bereitstellen.

Bereitstellen der Anwendung

Erstellen Sie den Anwendungsnamespace mithilfe des Befehls kubectl create namespace.
```
kubectl create namespace hpa-contoso
```

Erstellen Sie im Cloud Shell-Editor eine neue Datei namens deployment.yml, und fügen Sie darin den folgenden YAML-Code ein:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: contoso-website
  namespace: hpa-contoso
spec:
  replicas: 1
  selector:
    matchLabels:
      app: contoso-website
  template:
    metadata:
      labels:
        app: contoso-website
    spec:
      containers:
        - name: contoso-website
          image: mcr.microsoft.com/mslearn/samples/contoso-website
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
            limits:
              cpu: 250m
              memory: 256Mi
          ports:
            - containerPort: 80

Speichern Sie die Datei .
Stellen Sie die Anwendung mithilfe des Befehls kubectl apply im Cluster bereit.
```
kubectl apply -f deployment.yml
```
Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:
```
deployment.apps/contoso-website created
```

Erstellen einer DNS-Zone und Bereitstellen der Eingangsressource

Erstellen Sie eine Azure DNS-Zone mithilfe des az network dns zone create-Befehls. Im folgenden Beispiel wird eine DNS-Zone namens contoso-website.com erstellt:
```
az network dns zone create --resource-group myResourceGroup --name contoso-website.com
```
Rufen Sie die Ressourcen-ID für Ihre DNS-Zone mithilfe des Befehls az network dns zone show ab, und speichern Sie die Ausgabe in einer Variable namens DNS_ZONE_ID.
```
DNS_ZONE_ID=$(az network dns zone show --resource-group myResourceGroup --name contoso-website.com --query id --output tsv)
```
Aktualisieren Sie mithilfe des Befehls az aks approuting zone das Cluster-Add-On für das Anwendungsrouting, um die Azure DNS-Integration zu aktivieren.
```
az aks approuting zone add --resource-group myResourceGroup --name myAKSCluster --ids=${DNS_ZONE_ID} --attach-zones
```

Erstellen Sie Im Cloud Shell-Editor eine Datei namens ingress.yml, und fügen Sie darin den folgenden YAML-Code ein. Ersetzen Sie unbedingt den Platzhalter <dns-zone-name> durch den Namen Ihrer DNS-Zone.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: contoso-website
  namespace: hpa-contoso
  annotations:
spec:
  ingressClassName: webapprouting.kubernetes.azure.com
  rules:
  - host: <dns-zone-name>
    http:
      paths:
      - backend:
          service:
            name: contoso-website
            port:
              number: 80
        path: /
        pathType: Prefix

Speichern Sie die Datei .
Stellen Sie die Eingangsressource mithilfe des Befehls kubectl apply im Cluster bereit.
```
kubectl apply -f ingress.yml
```
Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:
```
ingress.networking.k8s.io/contoso-website created
```

Erstellen der Dienstressource

Erstellen Sie Im Cloud Shell-Editor eine Datei namens service.yml, und fügen Sie darin den folgenden YAML-Code ein:

apiVersion: v1
kind: Service
metadata:
  name: contoso-website
  namespace: hpa-contoso
spec:
  type: ClusterIP
  ports:
    - port: 80
      targetPort: 80
  selector:
    app: contoso-website

Speichern Sie die Datei .
Stellen Sie die Dienstressource mithilfe des Befehls kubectl apply im Cluster bereit.
```
kubectl apply -f service.yml
```
Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:
```
service/contoso-website created
```

Erstellen eines HorizontalPodAutoscaler

Erstellen Sie Im Cloud Shell-Editor eine Datei namens hpa.yml, und fügen Sie darin den folgenden YAML-Code ein:
```
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: contoso-website
  namespace: hpa-contoso
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: contoso-website
  minReplicas: 1
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 20
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 50
```
Beachten Sie, dass die scaleTargetRef-Schlüssel mit denen der erstellten Bereitstellungsressource identisch sein müssen. In Ihrem Fall hat die von Ihnen erstellte Bereitstellung die apiVersion apps/v1 und den Namen contoso-website. Dieser HPA ist so konfiguriert, dass die native CPU-Metrik abgefragt wird. Wenn diese Metrik für einen bestimmten Zeitraum über dem Durchschnitt von 20 % liegt, wird die Bereitstellung in einer Einheit aufskaliert. Der Algorithmus, der zum Berechnen dieser Metrik verwendet wird, basiert auf dieser mathematischen Gleichung:
```
desiredReplicas = ceil[currentReplicas * ( currentMetricValue / desiredMetricValue )]
```
Die Schlüssel minReplicas und maxReplicas definieren die minimale und maximale Anzahl von Replikaten, die diese Bereitstellung haben kann. Der Schlüssel metrics definiert die Metriken der HPA-Abfragen für das Skalieren der Bereitstellung. In diesem Fall fragt der HPA die CPU- und Arbeitsspeichermetriken ab. Wenn die CPU-Metrik über 20 % oder die Arbeitsspeichermetrik über 50 % steigt, skaliert der HPA die Bereitstellung auf.
Speichern Sie die Datei .
Erstellen Sie den HPA mit dem Befehl kubectl apply.
```
kubectl apply -f hpa.yml
```
Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:
```
horizontalpodautoscaler.autoscaling/contoso-website created
```

Prüfen der Ergebnisse

Fragen Sie die Metriken und die Verwendung des HPA mithilfe des Befehls kubectl get hpa ab.
```
kubectl get hpa --namespace hpa-contoso
```
Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:
```
NAME              REFERENCE                    TARGETS          MINPODS   MAXPODS   REPLICAS   AGE
contoso-website   Deployment/contoso-website   0%/20%, 0%/50%   1         10        1          83s
```
Beachten Sie die Spalte TARGETS. Sie enthält die aktuelle Verwendung der Metriken, die im HPA definiert sind. In diesem Fall beträgt die CPU-Auslastung 0 % und die Arbeitsspeicherauslastung 0 %. Dies liegt daran, dass die Anwendung keinen Datenverkehr empfängt.

Hinweis

Möglicherweise zeigt der HPA als Metriken für die ersten Sekunden unknown an, während er versucht, die Metrik-API zu erreichen, um die Metriken vom Server abzurufen.