Installer le module complémentaire KEDA (Kubernetes Event-driven Autoscaling) à l’aide d’un modèle ARM

Article
11/21/2023

Cet article explique comment déployer le module complémentaire KEDA (Kubernetes Event-driven Autoscaling) sur AKS (Azure Kubernetes Service) à l’aide d’un modèle ARM.

Important

La version Kubernetes de votre cluster détermine la version KEDA installée sur votre cluster AKS. Pour voir la version KEDA mappée à chaque version AKS, consultez la colonne Modules complémentaires gérés par AKS du tableau des versions de composant Kubernetes.

Pour les versions Kubernetes GA, AKS offre une prise en charge complète de la version mineure KEDA correspondante dans le tableau. Les préversions de Kubernetes et le dernier patch KEDA sont partiellement couverts par le service client, dans la mesure du possible. Telles quelles, ces fonctionnalités ne sont pas destinées à une utilisation en production. Pour plus d’informations, consultez les articles de support suivants :

Avant de commencer

Vous avez besoin d’un abonnement Azure. Si vous n’avez pas d’abonnement Azure, vous pouvez créer un compte gratuit.
Vous devez avoir installé Azure CLI.
Cet article suppose que vous disposez d’un groupe de ressources Azure existant. Si vous n’avez pas de groupe de ressources existant, vous pouvez en créer un à l’aide de la commande az group create.
Assurez-vous que les règles de pare-feu sont configurées pour autoriser l’accès au serveur d’API Kubernetes. Pour plus d'informations, voir Règles de réseau sortant et de FQDN pour les clusters Azure Kubernetes Service (AKS).
Créez une paire de clés SSH.

Remarque

Si vous utilisez l’ID de charge de travail Microsoft Entra et que vous activez KEDA avant l’ID de charge de travail, vous devez redémarrer les pods d’opérateur KEDA afin que les variables d’environnement appropriées puissent être injectées :

Redémarrez les pods en exécutant kubectl rollout restart deployment keda-operator -n kube-system.
Obtenez des pods d’opérateur KEDA en utilisant kubectl get pod -n kube-system et en recherchant les pods commençant par keda-operator.
Vérifiez que l’injection des variables d’environnement a réussi en exécutant kubectl describe pod <keda-operator-pod> -n kube-system. Sous Environment, vous devez voir les valeurs de AZURE_TENANT_ID, AZURE_FEDERATED_TOKEN_FILE et AZURE_AUTHORITY_HOST.

Création d’une paire de clés SSH

Accédez à Azure Cloud Shell.

Créez une paire de clés SSH à l’aide de la commande az sshkey create.

az sshkey create --name <sshkey-name> --resource-group <resource-group-name>

Activer le module complémentaire KEDA avec un modèle ARM

Déployez le modèle ARM pour un cluster AKS.
Sélectionnez Modifier un modèle.
Activez le module complémentaire KEDA en spécifiant le champ workloadAutoScalerProfile dans le modèle ARM, comme illustré dans l’exemple suivant :
```
    "workloadAutoScalerProfile": {
        "keda": {
            "enabled": true
        }
    }
```
Cliquez sur Enregistrer.
Mettez à jour les valeurs requises pour le modèle ARM :
- Abonnement : Sélectionnez l’abonnement Azure à utiliser pour le déploiement de la zone d’atterrissage des données.
- Groupe de ressources : sélectionnez le groupe de ressources à utiliser pour le déploiement.
- Région : sélectionnez la région à utiliser pour le déploiement.
- Préfixe DNS : entrez un nom DNS unique à utiliser pour le cluster.
- Nom d’utilisateur administrateur Linux : entrez un nom d’utilisateur pour le cluster.
- Source de clé publique SSH : sélectionnez Utiliser une clé existante stockée dans Azure.
- Stocker les clés : sélectionnez la paire de clés que vous avez créée précédemment dans l’article.
Sélectionnez Vérifier + créer>Créer.

Se connecter à votre cluster AKS

Pour vous connecter au cluster Kubernetes à partir de votre ordinateur local, utilisez kubectl, le client de ligne de commande Kubernetes.

Si vous utilisez Azure Cloud Shell, kubectl est déjà installé. Vous pouvez également l’installer localement avec la commande az aks install-cli.

Configurez kubectl pour vous connecter à votre cluster Kubernetes via la commande az aks get-credentials. L’exemple suivant obtient les informations d’identification du cluster AKS nommé MyAKSCluster dans le groupe de ressources MyResourceGroup :

az aks get-credentials --resource-group MyResourceGroup --name MyAKSCluster

Exemple de déploiement

L’extrait de code suivant est un exemple de déploiement qui crée un cluster avec KEDA activé avec un pool de nœuds unique composé de trois nœuds DS2_v5.

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "resources": [
        {
            "apiVersion": "2023-03-01",
            "dependsOn": [],
            "type": "Microsoft.ContainerService/managedClusters",
            "location": "westcentralus",
            "name": "myAKSCluster",
            "properties": {
                "kubernetesVersion": "1.27",
                "enableRBAC": true,
                "dnsPrefix": "myAKSCluster",
                "agentPoolProfiles": [
                    {
                        "name": "agentpool",
                        "osDiskSizeGB": 200,
                        "count": 3,
                        "enableAutoScaling": false,
                        "vmSize": "Standard_D2S_v5",
                        "osType": "Linux",
                        "type": "VirtualMachineScaleSets",
                        "mode": "System",
                        "maxPods": 110,
                        "availabilityZones": [],
                        "nodeTaints": [],
                        "enableNodePublicIP": false
                    }
                ],
                "networkProfile": {
                    "loadBalancerSku": "standard",
                    "networkPlugin": "kubenet"
                },
                "workloadAutoScalerProfile": {
                    "keda": {
                        "enabled": true
                    }
                }
            },
            "identity": {
                "type": "SystemAssigned"
            }
        }
    ]
}

Commencer à mettre à l’échelle des applications avec KEDA

Vous pouvez mettre à l’échelle automatiquement vos applications avec KEDA à l’aide de définitions de ressources personnalisées (CRD). Pour plus d’informations, consultez la documentation KEDA.

Supprimer des ressources

Utilisez la commande az group delete pour supprimer le groupe de ressources et toutes les ressources associées.
```
az group delete --name <resource-group-name>
```

Étapes suivantes

Cet article vous a montré comment installer le module complémentaire KEDA sur un cluster AKS, puis comment vérifier qu’il est installé et en cours d’exécution. Avec le module complémentaire KEDA installé sur votre cluster, vous pouvez déployer un exemple d’application pour commencer la mise à l’échelle des applications.

Pour plus d’informations sur la résolution des problèmes KEDA, consultez Résoudre les problèmes du module complémentaire Kubernetes Event-driven Autoscaling (KEDA).

Pour plus d’informations, consultez la documentation KEDA en amont.