Cvičení – Vytvořte svůj HorizontalPodAutoscaler

15 min

Cvičení – škálování aplikace

Vytvoření clusteru AKS

Než budete moct začít škálovat aplikaci, musíte vytvořit cluster AKS s požadovanými prostředky.

Přihlaste se k Azure Cloud Shellu pomocí účtu, do kterého chcete nasadit prostředky, a vyberte Bash jako spuštěné prostředí.
Pomocí příkazu az group create vytvořte skupinu prostředků. Následující příklad vytvoří skupinu prostředků s názvem myResourceGroup v umístění eastus:
```
az group create --name myResourceGroup --location eastus
```
Vytvořte cluster AKS pomocí příkazu az aks create. Následující příklad vytvoří cluster s názvem myAKSCluster ve skupině prostředků myResourceGroup. Cluster má jeden uzel a používá velikost virtuálního počítač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
```
Dokončení příkazu trvá několik minut.
Pomocí příkazu az aks get-credentials získejte přihlašovací údaje pro cluster.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Pomocí příkazu kubectl get nodes ověřte, že je cluster spuštěný a že se k němu můžete připojit.
```
kubectl get nodes
```
Příkaz by měl vrátit jeden uzel se stavem Ready.

Nasazení prostředků aplikace

Teď, když máte cluster, můžete do něj nasadit aplikaci.

Nasazení aplikace

Pomocí příkazu kubectl create namespace vytvořte obor názvů aplikace.
```
kubectl create namespace hpa-contoso
```

V editoru Cloud Shell vytvořte nový soubor s názvem deployment.yml a vložte do něj následující kód YAML:

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

Uložte soubor.
Nasaďte aplikaci do clusteru pomocí příkazu kubectl apply.
```
kubectl apply -f deployment.yml
```
Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:
```
deployment.apps/contoso-website created
```

Vytvoření zóny DNS a nasazení prostředku příchozího přenosu dat

Pomocí příkazu az network dns zone create vytvořte zónu Azure DNS. Následující příklad vytvoří zónu DNS s názvem contoso-website.com:
```
az network dns zone create --resource-group myResourceGroup --name contoso-website.com
```
Získejte ID prostředku pro vaši zónu DNS pomocí příkazu az network dns zone show a uložte výstup do proměnné pojmenované DNS_ZONE_ID.
```
DNS_ZONE_ID=$(az network dns zone show --resource-group myResourceGroup --name contoso-website.com --query id --output tsv)
```
Aktualizujte doplněk clusteru směrování aplikací a povolte integraci Azure DNS pomocí příkazu az aks approuting zone.
```
az aks approuting zone add --resource-group myResourceGroup --name myAKSCluster --ids=${DNS_ZONE_ID} --attach-zones
```

V editoru Cloud Shell vytvořte soubor s názvem ingress.yml a vložte do něj následující kód YAML. Nezapomeňte nahradit zástupný symbol <dns-zone-name> názvem zóny DNS.

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

Uložte soubor.
Nasaďte ingress prostředek do clusteru pomocí příkazu kubectl apply.
```
kubectl apply -f ingress.yml
```
Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:
```
ingress.networking.k8s.io/contoso-website created
```

Vytvořte prostředek služby

V editoru Cloud Shellu vytvořte soubor s názvem service.yml a vložte do něj následující kód YAML:

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

Uložte soubor.
Pomocí příkazu kubectl apply nasazujte zdroj služby do clusteru.
```
kubectl apply -f service.yml
```
Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:
```
service/contoso-website created
```

Vytvořte HorizontalPodAutoscaler

V editoru Cloud Shellu vytvořte soubor s názvem hpa.yml a vložte do něj následující kód YAML:
```
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
```
Je důležité zdůraznit, že klíče scaleTargetRef musí být stejné jako vytvořený prostředek nasazení. Ve vašem případě má vytvořené nasazení apiVersion jako apps/v1 a nazývá se contoso-website. Tato platforma HPA je nakonfigurovaná tak, aby dotazovala nativní metriku procesoru. Pokud tato metrika po určitou dobu překročí průměr 20%, škáluje nasazení v jednotce. Algoritmus použitý k výpočtu této metriky vychází z této matematické rovnice:
```
desiredReplicas = ceil[currentReplicas * ( currentMetricValue / desiredMetricValue )]
```
Klíče minReplicas a maxReplicas definují minimální a maximální počet replik, které může nasazení mít. Klíč metrics definuje metriky dotazů HPA pro škálování nasazení. V tomto případě HPA dotazuje metriky procesoru a paměti. Pokud metrika procesoru překročí 20% nebo metrika paměti překročí 50%, HPA škáluje nasazení.
Uložte soubor.
Vytvořte HPA pomocí příkazu kubectl apply.
```
kubectl apply -f hpa.yml
```
Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:
```
horizontalpodautoscaler.autoscaling/contoso-website created
```

Kontrola výsledků

Pomocí příkazu kubectl get hpa zadejte dotaz na metriky a využití HPA.
```
kubectl get hpa --namespace hpa-contoso
```
Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:
```
NAME              REFERENCE                    TARGETS          MINPODS   MAXPODS   REPLICAS   AGE
contoso-website   Deployment/contoso-website   0%/20%, 0%/50%   1         10        1          83s
```
Všimněte si sloupce TARGETS. Zobrazuje aktuální využití metrik definovaných v prostředí HPA. V tomto případě je využití procesoru 0% a využití paměti je 0%. Důvodem je to, že aplikace nepřijímá žádný provoz.

Poznámka

Je možné, že HPA zobrazuje metriky unknown během prvních několika sekund, protože se pokouší spojit s rozhraním API pro metriky a načíst je ze serveru.