Didacticiel : mettre à l’échelle des applications dans Azure Kubernetes Service (AKS)

Article
08/02/2024

Si vous avez suivi les didacticiels précédents, vous disposez d’un cluster Kubernetes opérationnel et d’une application Azure Store Front.

Dans ce tutoriel, la partie six sur sept, vous effectuez un scale-out des pods dans l’application, essayez la mise à l’échelle automatique des pods et mettez à l’échelle le nombre de nœuds de machine virtuelle Azure pour modifier la capacité du cluster pour héberger des charges de travail. Vous allez apprendre à effectuer les actions suivantes :

Mettez à l’échelle les nœuds Kubernetes.
Mettez à l’échelle manuellement des pods Kubernetes qui exécutent votre application.
Configurez la mise à l’échelle automatique des pods qui exécutent le front-end d’applications.

Avant de commencer

Dans les didacticiels précédents, vous avez empaqueté une application dans une image conteneur, chargé l’image dans Azure Container Registry, créé un cluster AKS, déployé une application et utilisé Azure Service Bus pour redéployer une application mise à jour. Si vous n’avez pas effectué ces étapes et voulez suivre cette procédure, commencez par Tutoriel 1 : préparer une application pour AKS.

Azure CLI
Azure PowerShell

Ce didacticiel nécessite Azure CLI version 2.34.1 ou ultérieure. Exécutez az --version pour trouver la version. Si vous devez installer ou mettre à niveau, voir Installer Azure CLI.

Mettre à l’échelle des pods manuellement

Affichez les pods dans votre cluster à l’aide de la commande kubectl get.

kubectl get pods

L’exemple de sortie suivant montre les pods exécutant l’application Azure Store Front :

NAME                               READY     STATUS     RESTARTS   AGE
order-service-848767080-tf34m      1/1       Running    0          31m
product-service-4019737227-2q2qz   1/1       Running    0          31m
store-front-2606967446-2q2qz       1/1       Running    0          31m

Changez manuellement le nombre de pods dans le déploiement store-front à l’aide de la commande kubectl scale.
```
kubectl scale --replicas=5 deployment.apps/store-front
```

Vérifiez que les pods supplémentaires ont été créés à l’aide de la commande kubectl get pods.

kubectl get pods

L’exemple de sortie suivant montre les pods supplémentaires exécutant l’application Azure Store Front :

                                  READY     STATUS    RESTARTS   AGE
store-front-2606967446-2q2qzc     1/1       Running   0          15m
store-front-3309479140-2hfh0      1/1       Running   0          3m
store-front-3309479140-bzt05      1/1       Running   0          3m
store-front-3309479140-fvcvm      1/1       Running   0          3m
store-front-3309479140-hrbf2      1/1       Running   0          15m
store-front-3309479140-qphz8      1/1       Running   0          3m

Mettre à l’échelle les pods automatiquement

Pour utiliser la mise à l’échelle automatique des pods horizontaux, tous les conteneurs doivent avoir des requêtes et limites de processeur définies et les pods doivent avoir des requêtes définies. Dans le déploiement aks-store-quickstart, le conteneur frontal demande 1 m processeur, avec une limite de 1000 m processeur.

Ces limites et requêtes de ressources sont définies pour chaque conteneur, comme indiqué dans l’exemple de YAML condensé suivant :

...
  containers:
  - name: store-front
    image: ghcr.io/azure-samples/aks-store-demo/store-front:latest
    ports:
    - containerPort: 8080
      name: store-front
...
    resources:
      requests:
        cpu: 1m
...
      limits:
        cpu: 1000m
...

Mise à l’échelle automatique des pods à l’aide d’un fichier manifeste

Créez un fichier manifeste pour définir le comportement de l’outil de mise à l’échelle automatique et les limites de ressources, comme indiqué dans l’exemple condensé de fichier manifeste aks-store-quickstart-hpa.yaml suivant :

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: store-front-hpa
spec:
  maxReplicas: 10 # define max replica count
  minReplicas: 3  # define min replica count
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: store-front
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50

Appliquez le fichier manifeste de l’outil de mise à l’échelle automatique à l’aide de la commande kubectl apply.
```
kubectl apply -f aks-store-quickstart-hpa.yaml
```
Vérifiez l’état de l’outil de mise à l’échelle automatique à l’aide de la commande kubectl get hpa.
```
kubectl get hpa
```
Au bout de quelques minutes, avec une charge minimale sur l’application Azure Store Front, le nombre de réplicas de pods descend à trois. Vous pouvez utiliser à nouveau kubectl get pods pour voir les pods inutiles en cours de suppression.

Remarque

Vous pouvez activer le module complémentaire AKS KEDA (Kubernetes Event-Driven Autoscaler) sur votre cluster afin d’assurer la mise à l’échelle en fonction du nombre d’événements à traiter. Pour plus d’informations, consultez Activer la mise à l’échelle automatique d’application simplifiée avec le module complémentaire KEDA (Kubernetes Event-Driven Autoscaling) (préversion).

Mettre manuellement à l’échelle les nœuds AKS

Si vous avez créé votre cluster Kubernetes à l’aide des commandes dans les didacticiels précédents, votre cluster comporte deux nœuds. Si vous souhaitez augmenter ou diminuer cette quantité, vous pouvez ajuster manuellement le nombre de nœuds.

L’exemple suivant permet d’augmenter le nombre de nœuds à trois dans le cluster Kubernetes nommé myAKSCluster. Quelques minutes sont nécessaires pour exécuter la commande.

Azure CLI
Azure PowerShell

Mettez à l’échelle les nœuds de cluster avec la commande az aks scale.

az aks scale --resource-group myResourceGroup --name myAKSCluster --node-count 3

Une fois le cluster mis à l’échelle, votre sortie est similaire à l’exemple de sortie suivant :

"aadProfile": null,
"addonProfiles": null,
"agentPoolProfiles": [
  {
    ...
    "count": 3,
    "mode": "System",
    "name": "nodepool1",
    "osDiskSizeGb": 128,
    "osDiskType": "Managed",
    "osType": "Linux",
    "ports": null,
    "vmSize": "Standard_DS2_v2",
    "vnetSubnetId": null
    ...
  }
  ...
]

Mettez à l’échelle les nœuds de votre cluster avec les cmdlets Get-AzAksCluster et Set-AzAksCluster.

Get-AzAksCluster -ResourceGroupName myResourceGroup -Name myAKSCluster | Set-AzAksCluster -NodeCount 3

Une fois le cluster mis à l’échelle, votre sortie est similaire à l’exemple de sortie suivant :

...
ProvisioningState        : Succeeded
MaxAgentPools            : 100
KubernetesVersion        : 1.28
CurrentKubernetesVersion : 1.28.9
DnsPrefix                : myAKSCluster
Fqdn                     : myakscluster-000a0aa0.hcp.eastus.azmk8s.io
PrivateFQDN              :
AzurePortalFQDN          : myakscluster-000a0aa0.portal.hcp.eastus.azmk8s.io
AgentPoolProfiles        : {default}
...
ResourceGroupName        : myResourceGroup
Id                       : /subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/myResourceGroup/providers/Mic
                           rosoft.ContainerService/managedClusters/myAKSCluster
Name                     : myAKSCluster
Type                     : Microsoft.ContainerService/ManagedClusters
Location                 : eastus
Tags                     :

Vous pouvez également mettre à l’échelle automatiquement les nœuds de votre cluster. Pour plus d’informations, consultez Utiliser la mise à l’échelle automatique de cluster avec des pools de nœuds.

Étapes suivantes

Dans ce didacticiel, vous avez utilisé différentes fonctionnalités de mise à l’échelle dans votre cluster Kubernetes. Vous avez appris à :

Mettez à l’échelle manuellement des pods Kubernetes qui exécutent votre application.
Configurez la mise à l’échelle automatique des pods qui exécutent le front-end d’applications.
Mettez à l’échelle manuellement les nœuds Kubernetes.

Dans le tutoriel suivant, vous allez apprendre à mettre à niveau Kubernetes dans votre cluster AKS.

Mettre à niveau Kubernetes dans Azure Kubernetes Service

Partager via