Övning – Skapa din HorizontalPodAutoscaler

15 minuter

Övning – Skala ett program

Skapa ett AKS-kluster

Innan du kan börja skala ditt program måste du skapa ett AKS-kluster med de resurser som krävs.

Logga in på Azure Cloud Shell- med det konto som du vill distribuera resurser till och välj Bash- som gränssnittet som körs.
Skapa en resursgrupp med hjälp av kommandot az group create. I följande exempel skapas en resursgrupp med namnet myResourceGroup på platsen eastus:
```
az group create --name myResourceGroup --location eastus
```
Skapa ett AKS-kluster med hjälp av kommandot az aks create. I följande exempel skapas ett kluster med namnet myAKSCluster i resursgruppen myResourceGroup. Klustret har en nod och använder Standard_DS2_v2 VM-storlek.
```
az aks create --resource-group myResourceGroup --name myAKSCluster --node-count 1 --node-vm-size Standard_DS2_v2 --enable-app-routing --generate-ssh-keys
```
Det tar några minuter att slutföra kommandot.
Hämta autentiseringsuppgifterna för klustret med hjälp av kommandot az aks get-credentials.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Kontrollera att klustret körs och att du kan ansluta till det med hjälp av kommandot kubectl get nodes.
```
kubectl get nodes
```
Kommandot ska returnera en nod med statusen Ready.

Distribuera programresurserna

Nu när du har ett kluster kan du distribuera programmet till det.

Distribuera programmet

Skapa programnamnområdet med hjälp av kommandot kubectl create namespace.
```
kubectl create namespace hpa-contoso
```

Skapa en ny fil med namnet deployment.yml i Cloud Shell-redigeraren och klistra in följande YAML-kod i den:

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

Spara filen.
Distribuera programmet till klustret med hjälp av kommandot kubectl apply.
```
kubectl apply -f deployment.yml
```
Dina utdata bör se ut ungefär som följande exempelutdata:
```
deployment.apps/contoso-website created
```

Skapa en DNS-zon och distribuera ingressresursen

Skapa en Azure DNS-zon med hjälp av kommandot az network dns zone create. I följande exempel skapas en DNS-zon med namnet contoso-website.com:
```
az network dns zone create --resource-group myResourceGroup --name contoso-website.com
```
Hämta resurs-ID:t för DNS-zonen med hjälp av kommandot az network dns zone show och spara utdata till en variabel med namnet DNS_ZONE_ID.
```
DNS_ZONE_ID=$(az network dns zone show --resource-group myResourceGroup --name contoso-website.com --query id --output tsv)
```
Uppdatera tillägget för programroutningskluster för att aktivera Azure DNS-integrering med hjälp av kommandot az aks approuting zone.
```
az aks approuting zone add --resource-group myResourceGroup --name myAKSCluster --ids=${DNS_ZONE_ID} --attach-zones
```

Skapa en fil med namnet ingress.yml i Cloud Shell-redigeraren och klistra in följande YAML-kod i den. Se till att du ersätter platshållaren <dns-zone-name> med namnet på DNS-zonen.

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

Spara filen.
Distribuera ingressresursen till klustret med hjälp av kommandot kubectl apply.
```
kubectl apply -f ingress.yml
```
Dina utdata bör se ut ungefär som följande exempelutdata:
```
ingress.networking.k8s.io/contoso-website created
```

Skapa tjänstresursen

Skapa en fil med namnet service.yml i Cloud Shell-redigeraren och klistra in följande YAML-kod i den:

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

Spara filen.
Distribuera tjänstresursen till klustret med hjälp av kommandot kubectl apply.
```
kubectl apply -f service.yml
```
Dina utdata bör se ut ungefär som följande exempelutdata:
```
service/contoso-website created
```

Skapa en HorizontalPodAutoscaler

Skapa en fil med namnet hpa.yml i Cloud Shell-redigeraren och klistra in följande YAML-kod i den:
```
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
```
Det är viktigt att påpeka att scaleTargetRef nycklarna måste vara samma som den skapade distributionsresursen. I ditt fall har distributionen du skapade apiVersion som apps/v1 och den kallas contoso-website. Denna HPA är konfigurerad för att fråga efter den inbyggda CPU-metriken. Om det här måttet överskrider genomsnittet på 20% under en angiven tid skalar det ut distributionen i en enhet. Algoritmen som används för att beräkna det här måttet baseras på den här matematiska ekvationen:
```
desiredReplicas = ceil[currentReplicas * ( currentMetricValue / desiredMetricValue )]
```
Nycklarna minReplicas och maxReplicas definierar det lägsta och högsta antalet repliker som distributionen kan ha. Nyckeln metrics definierar de mätningar som HPA använder för att skala utrullningen. I det här fallet frågar HPA cpu- och minnesmåtten. Om CPU-måttet överskrider 20% eller om minnesmåttet överskrider 50%skalar HPA ut distributionen.
Spara filen.
Skapa HPA med hjälp av kommandot kubectl apply.
```
kubectl apply -f hpa.yml
```
Dina utdata bör se ut ungefär som följande exempelutdata:
```
horizontalpodautoscaler.autoscaling/contoso-website created
```

Kontrollera resultatet

Fråga efter mått och användning av HPA med hjälp av kommandot kubectl get hpa.
```
kubectl get hpa --namespace hpa-contoso
```
Dina utdata bör se ut ungefär som följande exempelutdata:
```
NAME              REFERENCE                    TARGETS          MINPODS   MAXPODS   REPLICAS   AGE
contoso-website   Deployment/contoso-website   0%/20%, 0%/50%   1         10        1          83s
```
Observera kolumnen TARGETS. Den visar den aktuella användningen av måtten som definierats i HPA. I det här fallet är processoranvändningen 0% och minnesanvändningen är 0%. Det beror på att programmet inte tar emot någon trafik.

Notera

Det är möjligt att HPA visar unknown mått under de första sekunderna när den försöker nå mått-API:et för att hämta dem från servern.