Exercice – Création d’un HorizontalPodAutoscaler

15 minutes

Exercice : mise à l’échelle d’une application

Créer un cluster AKS

Avant de démarrer une mise à l’échelle de votre application, vous devez créer un cluster AKS avec les ressources requises.

Connectez-vous à Azure Cloud Shell avec le compte dans lequel vous voulez déployer des ressources, puis sélectionner Bash comme interpréteur de commandes d’exécution.
Créez un groupe de ressources avec la commande az group create. L’exemple suivant crée un groupe de ressources nommé myResourceGroup à l’emplacement eastus :
```
az group create --name myResourceGroup --location eastus
```
Créez un cluster AKS avec la commande az aks create. L’exemple suivant crée un cluster nommé myAKSCluster dans le groupe de ressources myResourceGroup. Le cluster a un nœud et utilise la taille de machine virtuelle 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
```
L’exécution de cette commande prend quelques minutes.
Obtenez les informations d’identification du cluster en utilisant la commande az aks get-credentials.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Vérifiez que le cluster est en cours d’exécution et que vous pouvez vous y connecter en tirant parti de la commande kubectl get nodes.
```
kubectl get nodes
```
La commande doit retourner un nœud ayant l’état Ready.

Déployer les ressources d’application

Maintenant que vous disposez d’un cluster, vous pouvez y déployer l’application.

Déployer l’application

Créez l’espace de noms d’application en utilisant la commande kubectl create namespace.
```
kubectl create namespace hpa-contoso
```

Créez un fichier nommé deployment.yml dans l’éditeur Cloud Shell et collez-y le code YAML suivant :

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

Enregistrez le fichier.
Déployez l’application sur le cluster en tirant parti de la commande kubectl apply.
```
kubectl apply -f deployment.yml
```
Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :
```
deployment.apps/contoso-website created
```

Créer une zone DNS et déployer la ressource d’entrée

Création d’une zone Azure DNS à l’aide de la commande az network dns zone create. L’exemple suivant crée une zone DNS nommée contoso-website.com :
```
az network dns zone create --resource-group myResourceGroup --name contoso-website.com
```
Obtenez l’ID de la ressource pour votre zone DNS en tirant parti de la commande az network dns zone show, puis enregistrez la sortie dans une variable nommée DNS_ZONE_ID.
```
DNS_ZONE_ID=$(az network dns zone show --resource-group myResourceGroup --name contoso-website.com --query id --output tsv)
```
Mettez à jour le module complémentaire de cluster de routage d’applications pour activer l’intégration d’Azure DNS en utilisant la commande az aks approuting zone.
```
az aks approuting zone add --resource-group myResourceGroup --name myAKSCluster --ids=${DNS_ZONE_ID} --attach-zones
```

Créez un fichier nommé ingress.yml dans l’éditeur Cloud Shell et collez-y le code YAML suivant. Veillez à remplacer l’espace réservé <dns-zone-name> par le nom de votre zone 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

Enregistrez le fichier.
Déployez la ressource d’entrée sur le cluster en tirant parti de la commande kubectl apply.
```
kubectl apply -f ingress.yml
```
Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :
```
ingress.networking.k8s.io/contoso-website created
```

Créer la ressource de service

Créez un fichier nommé service.yml dans l’éditeur Cloud Shell et collez-y le code YAML suivant :

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

Enregistrez le fichier.
Déployez la ressource de service sur le cluster en tirant parti de la commande kubectl apply.
```
kubectl apply -f service.yml
```
Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :
```
service/contoso-website created
```

Créer un HorizontalPodAutoscaler

Créez un fichier nommé hpa.yml dans l’éditeur Cloud Shell et collez-y le code YAML suivant :
```
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
```
Il est important de souligner que les clés scaleTargetRef doivent être les mêmes que pour la ressource de déploiement créée. Dans votre cas, le déploiement créé a la valeur apiVersion comme apps/v1 et est nommé contoso-website. Ce HPA est configuré pour interroger la métrique de processeur native. Si cette mesure dépasse sa moyenne de 20 % pendant un laps de temps spécifié, il effectue un scale-out du déploiement dans une unité. L’algorithme utilisé pour calculer cette mesure est basé sur cette équation mathématique :
```
desiredReplicas = ceil[currentReplicas * ( currentMetricValue / desiredMetricValue )]
```
Les clés minReplicas et maxReplicas définissent le nombre minimal et maximal de réplicas que le déploiement peut avoir. La clé metrics définit les mesures interrogées par la ressource HPA pour mettre à l'échelle le déploiement. Dans ce cas, la ressource HPA interroge les mesures du processeur et de la mémoire. Si la mesure du processeur dépasse 20 % ou que la mesure de la mémoire dépasse 50 %, la ressource HPA effectue un scale-out du déploiement.
Enregistrez le fichier.
Créez la ressource HPA en utilisant la commande kubectl apply.
```
kubectl apply -f hpa.yml
```
Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :
```
horizontalpodautoscaler.autoscaling/contoso-website created
```

Vérification des résultats

Interrogez les mesures et l’utilisation de la ressource HPA en utilisant la commande kubectl get hpa.
```
kubectl get hpa --namespace hpa-contoso
```
Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :
```
NAME              REFERENCE                    TARGETS          MINPODS   MAXPODS   REPLICAS   AGE
contoso-website   Deployment/contoso-website   0%/20%, 0%/50%   1         10        1          83s
```
Observez la colonne TARGETS. Elle montre l’utilisation actuelle des mesures définies dans la ressource HPA. Dans ce cas, l’utilisation du processeur est de 0 % et l’utilisation de la mémoire est de 0 %. Cela est dû au fait que l’application ne reçoit aucun trafic.

Remarque

Il est possible que le HPA affiche des métriques unknown pendant quelques secondes, car il tente d’accéder à l’API des métriques pour les récupérer à partir du serveur.