Oefening: Uw HorizontalPodAutoscaler maken

15 minuten

Oefening: een toepassing schalen

Een AKS-cluster maken

Voordat u uw toepassing kunt schalen, moet u een AKS-cluster maken met de vereiste middelen.

Meld u aan bij de Azure Cloud Shell- met het account waarin u resources wilt implementeren en selecteer Bash- als de actieve shell.
Maak een resourcegroep met behulp van de opdracht az group create. In het volgende voorbeeld wordt een resourcegroep met de naam myResourceGroup gemaakt op de eastus locatie:
```
az group create --name myResourceGroup --location eastus
```
Maak een AKS-cluster met behulp van de opdracht az aks create. In het volgende voorbeeld wordt een cluster met de naam myAKSCluster gemaakt in de myResourceGroup resourcegroep. Het cluster heeft één knooppunt en gebruikt de Standard_DS2_v2 VM-grootte.
```
az aks create --resource-group myResourceGroup --name myAKSCluster --node-count 1 --node-vm-size Standard_DS2_v2 --enable-app-routing --generate-ssh-keys
```
Het uitvoeren van de opdracht duurt enkele minuten.
Haal de referenties voor het cluster op met behulp van de opdracht az aks get-credentials.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Controleer of het cluster wordt uitgevoerd en of u er verbinding mee kunt maken met behulp van de opdracht kubectl get nodes.
```
kubectl get nodes
```
De opdracht moet één knooppunt retourneren met de status van Ready.

De toepassingsbronnen implementeren

Nu u een cluster hebt, kunt u de toepassing hierin implementeren.

De toepassing implementeren

Maak de naamruimte van de toepassing met behulp van de opdracht kubectl create namespace.
```
kubectl create namespace hpa-contoso
```

Maak een nieuw bestand met de naam deployment.yml in de Cloud Shell-editor en plak de volgende YAML-code erin:

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

Sla het bestand op.
Implementeer de toepassing in het cluster met behulp van de opdracht kubectl apply.
```
kubectl apply -f deployment.yml
```
De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:
```
deployment.apps/contoso-website created
```

Een DNS-zone maken en de ingress-resource implementeren

Maak een Azure DNS-zone met behulp van de opdracht az network dns zone create. In het volgende voorbeeld wordt een DNS-zone met de naam contoso-website.comgemaakt:
```
az network dns zone create --resource-group myResourceGroup --name contoso-website.com
```
Haal de resource-id voor uw DNS-zone op met behulp van de opdracht az network dns zone show en sla de uitvoer op in een variabele met de naam DNS_ZONE_ID.
```
DNS_ZONE_ID=$(az network dns zone show --resource-group myResourceGroup --name contoso-website.com --query id --output tsv)
```
Werk de invoegtoepassing voor toepassingsrouteringsclusters bij om Azure DNS-integratie in te schakelen met behulp van de opdracht az aks approuting zone.
```
az aks approuting zone add --resource-group myResourceGroup --name myAKSCluster --ids=${DNS_ZONE_ID} --attach-zones
```

Maak een bestand met de naam ingress.yml in de Cloud Shell-editor en plak de volgende YAML-code erin. Zorg ervoor dat u de tijdelijke aanduiding <dns-zone-name> vervangt door de naam van uw 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

Sla het bestand op.
Implementeer de ingress-resource in het cluster met behulp van de opdracht kubectl apply.
```
kubectl apply -f ingress.yml
```
De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:
```
ingress.networking.k8s.io/contoso-website created
```

De serviceresource maken

Maak een bestand met de naam service.yml in de Cloud Shell-editor en plak de volgende YAML-code erin:

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

Sla het bestand op.
Implementeer de serviceresource in het cluster met behulp van de opdracht kubectl apply.
```
kubectl apply -f service.yml
```
De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:
```
service/contoso-website created
```

Een HorizontalPodAutoscaler maken

Maak een bestand met de naam hpa.yml in de Cloud Shell-editor en plak de volgende YAML-code erin:
```
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
```
Het is belangrijk om aan te geven dat de scaleTargetRef sleutels hetzelfde moeten zijn als de gemaakte implementatieresource. In uw geval heeft de implementatie die u hebt gemaakt de apiVersion als apps/v1 en wordt deze contoso-websitegenoemd. Deze HPA is geconfigureerd om een query uit te voeren op de systeemeigen CPU-metrische gegevens. Als deze metrische waarde hoger is dan het gemiddelde van 20% gedurende een opgegeven hoeveelheid tijd, wordt de implementatie in een eenheid geschaald. Het algoritme dat wordt gebruikt om deze metrische waarde te berekenen, is gebaseerd op deze wiskundige vergelijking:
```
desiredReplicas = ceil[currentReplicas * ( currentMetricValue / desiredMetricValue )]
```
De minReplicas- en maxReplicas sleutels definiëren het minimum- en maximumaantal replica's dat de implementatie kan hebben. De metrics sleutel definieert de metrische gegevens van de HPA-query's om de implementatie te schalen. In dit geval voert de HPA query's uit op de metrische cpu- en geheugengegevens. Als de metrische CPU-waarde hoger is dan 20% of als de metrische geheugengegevens hoger zijn dan 50%, schaalt de HPA de implementatie uit.
Sla het bestand op.
Maak de HPA met behulp van de opdracht kubectl apply.
```
kubectl apply -f hpa.yml
```
De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:
```
horizontalpodautoscaler.autoscaling/contoso-website created
```

De resultaten controleren

Voer een query uit op de metrische gegevens en het gebruik van de HPA met behulp van de opdracht kubectl get hpa.
```
kubectl get hpa --namespace hpa-contoso
```
De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:
```
NAME              REFERENCE                    TARGETS          MINPODS   MAXPODS   REPLICAS   AGE
contoso-website   Deployment/contoso-website   0%/20%, 0%/50%   1         10        1          83s
```
Let op de kolom TARGETS. Het toont het huidige gebruik van de metrische gegevens die zijn gedefinieerd in de HPA. In dit geval is het CPU-gebruik 0% en is het geheugengebruik 0%. Dit komt doordat de toepassing geen verkeer ontvangt.

Notitie

Het is mogelijk dat de HPA de metriekgegevens unknown voor de eerste seconden weergeeft, omdat het probeert de API voor metriekgegevens te bereiken om deze van de server op te halen.