Esercizio - Creare la risorsa HorizontalPodAutoscaler

15 minuti

Esercizio - Ridimensionamento di un'applicazione

Creare un cluster del servizio Azure Kubernetes

Prima di iniziare a ridimensionare l'applicazione, è necessario creare un cluster del servizio Azure Kubernetes con le risorse necessarie.

Accedere ad Azure Cloud Shell con l'account in cui si vogliono distribuire le risorse e selezionare Bash come shell in esecuzione.
Creare un gruppo di risorse usando il comando az group create. Nell'esempio seguente viene creato un gruppo di risorse denominato myResourceGroup nella località eastus:
```
az group create --name myResourceGroup --location eastus
```
Creare un cluster del servizio Azure Kubernetes usando il comando az aks create. Nell'esempio seguente viene creato un cluster denominato myAKSCluster nel myResourceGroup gruppo di risorse. Il cluster ha un nodo e usa le dimensioni della Standard_DS2_v2 macchina virtuale.
```
az aks create --resource-group myResourceGroup --name myAKSCluster --node-count 1 --node-vm-size Standard_DS2_v2 --enable-app-routing --generate-ssh-keys
```
Il completamento del comando richiede alcuni minuti.
Ottenere le credenziali per il cluster usando il az aks get-credentials comando .
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Verificare che il cluster sia in esecuzione e che sia possibile connettersi usando il kubectl get nodes comando .
```
kubectl get nodes
```
Il comando deve restituire un nodo con stato Ready.

Distribuire le risorse dell'applicazione

Ora che si dispone di un cluster, è possibile distribuire l'applicazione.

Distribuire l'applicazione

Creare lo spazio dei nomi dell'applicazione usando il kubectl create namespace comando .
```
kubectl create namespace hpa-contoso
```

Creare un nuovo file denominato deployment.yml nell'editor di Cloud Shell e incollarvi il codice YAML seguente:

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

Salvare il file.
Distribuire l'applicazione nel cluster usando il kubectl apply comando .
```
kubectl apply -f deployment.yml
```
L'output dovrebbe essere simile all'output di esempio seguente:
```
deployment.apps/contoso-website created
```

Creare una zona DNS e distribuire la risorsa in ingresso

Creare una zona DNS di Azure usando il az network dns zone create comando . L'esempio seguente crea una zona DNS denominata contoso-website.com:
```
az network dns zone create --resource-group myResourceGroup --name contoso-website.com
```
Ottenere l'ID risorsa per la zona DNS usando il az network dns zone show comando e salvare l'output in una variabile denominata DNS_ZONE_ID.
```
DNS_ZONE_ID=$(az network dns zone show --resource-group myResourceGroup --name contoso-website.com --query id --output tsv)
```
Aggiornare il componente aggiuntivo cluster di routing dell'applicazione per abilitare l'integrazione dns di Azure usando il az aks approuting zone comando .
```
az aks approuting zone add --resource-group myResourceGroup --name myAKSCluster --ids=${DNS_ZONE_ID} --attach-zones
```

Creare un file denominato ingress.yml nell'editor di Cloud Shell e incollarvi il codice YAML seguente. Assicurarsi di sostituire il <dns-zone-name> segnaposto con il nome della zona 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

Salvare il file.
Distribuire la risorsa di ingresso nel cluster usando il kubectl apply comando .
```
kubectl apply -f ingress.yml
```
L'output dovrebbe essere simile all'output di esempio seguente:
```
ingress.networking.k8s.io/contoso-website created
```

Creare la risorsa del servizio

Creare un file denominato service.yml nell'editor di Cloud Shell e incollarvi il codice YAML seguente:

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

Salvare il file.
Distribuire la risorsa del servizio nel cluster usando il kubectl apply comando .
```
kubectl apply -f service.yml
```
L'output dovrebbe essere simile all'output di esempio seguente:
```
service/contoso-website created
```

Creare un oggetto HorizontalPodAutoscaler

Creare un file denominato hpa.yml nell'editor di Cloud Shell e incollarvi il codice YAML seguente:
```
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
```
È importante sottolineare che le chiavi scaleTargetRef devono essere uguali a quelle della risorsa di distribuzione creata. In questo caso, la distribuzione creata ha apiVersion come apps/v1 e viene chiamata contoso-website. Questa risorsa HPA è configurata per eseguire query sulla metrica della CPU nativa. Se questa metrica supera la media del 20% per un periodo di tempo specificato, ridimensiona la distribuzione in un'unità. L'algoritmo usato per calcolare questa metrica si basa su questa equazione matematica:
```
desiredReplicas = ceil[currentReplicas * ( currentMetricValue / desiredMetricValue )]
```
Le minReplicas chiavi e maxReplicas definiscono il numero minimo e massimo di repliche che la distribuzione può avere. La metrics chiave definisce le metriche delle query HPA per ridimensionare la distribuzione. In questo caso, HPA esegue una query sulle metriche della CPU e della memoria. Se la metrica della CPU supera il 20% o la metrica di memoria supera il 50%, l'HPA ridimensiona la distribuzione.
Salvare il file.
Creare l'HPA usando il kubectl apply comando .
```
kubectl apply -f hpa.yml
```
L'output dovrebbe essere simile all'output di esempio seguente:
```
horizontalpodautoscaler.autoscaling/contoso-website created
```

Controllare i risultati

Eseguire query sulle metriche e sull'utilizzo di HPA usando il kubectl get hpa comando .
```
kubectl get hpa --namespace hpa-contoso
```
L'output dovrebbe essere simile all'output di esempio seguente:
```
NAME              REFERENCE                    TARGETS          MINPODS   MAXPODS   REPLICAS   AGE
contoso-website   Deployment/contoso-website   0%/20%, 0%/50%   1         10        1          83s
```
Si noti la TARGETS colonna . Mostra l'utilizzo corrente delle metriche definite nell'HPA. In questo caso, l'utilizzo della CPU è 0% e l'utilizzo della memoria è 0%. Ciò è dovuto al fatto che l'applicazione non riceve traffico.

Nota

È possibile che la risorsa HPA visualizzi le metriche come unknown per alcuni secondi mentre prova a raggiungere l'API Metriche per recuperarle dal server.