Démarrage rapide : Déployer un cluster Azure Kubernetes Service (AKS) avec Azure Container Linux (ACL) à l’aide d’un modèle ARM

Dans ce guide de démarrage rapide, vous utilisez un modèle de Azure Resource Manager (ARM) pour créer un cluster Azure Kubernetes Service (AKS) qui s’exécute Azure Container Linux (ACL) comme système d’exploitation de nœud. Après avoir installé les prérequis, vous créez une paire de clés SSH, passez en revue le modèle, déployez le modèle et connectez-vous au cluster.

considérations et limitations relatives aux Azure Container Linux (ACL)

Avant de commencer, passez en revue les considérations et limites suivantes concernant l'ACL :

Prerequisites

Note

Vous pouvez utiliser Azure Cloud Shell ou une installation locale du Azure CLI pour exécuter les commandes dans ce guide de démarrage rapide.

  • Si vous exécutez le Azure CLI localement, installez le Azure CLI. Si vous exécutez sur Windows ou macOS, envisagez d’exécuter Azure CLI dans un conteneur Docker. Pour plus d’informations, consultez Comment exécuter Azure CLI dans un conteneur Docker.
  • Si vous utilisez une installation locale, connectez-vous au Azure CLI à l'aide de la commande az login. Pour terminer le processus d’authentification, suivez les étapes affichées dans votre terminal. Pour connaître les autres options de connexion, consultez Se connecter avec Azure CLI.
  • Si vous y êtes invité, installez l’extension Azure CLI à la première utilisation. Pour plus d’informations sur les extensions, consultez Utiliser des extensions avec Azure CLI.
  • Azure Container Linux nécessite Azure CLI version 2.86.0 ou ultérieure. Utilisez la commande az version pour rechercher la version Azure CLI et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, utilisez la az upgrade commande.
  • Si vous n'avez pas encore installé kubectl, installez-le via Azure CLI à l'aide de la commande az aks install-cli ou suivez les instructions upstream.
  • Pour créer un cluster AKS à l’aide d’un modèle ARM, vous devez fournir une clé publique SSH. Si vous avez besoin de cette ressource, accédez à la section Créer une paire de clés SSH pour en générer une avant de déployer le modèle. Si vous disposez déjà d’une paire de clés SSH, vous pouvez passer à la section Vérifier le modèle .
  • L’identité que vous utilisez pour créer votre cluster doit disposer des autorisations minimales appropriées. Pour plus d’informations sur l’accès et l’identité pour AKS, consultez Options d’accès et d’identité pour Kubernetes Azure Service (AKS).
  • Pour déployer un modèle ARM, vous devez disposer d’un accès en écriture sur les ressources que vous déployez, ainsi que d’un accès à toutes les opérations du type de ressource Microsoft.Resources/deployments. Par exemple, pour déployer une machine virtuelle (VM), vous devez disposer des autorisations Microsoft.Compute/virtualMachines/write et Microsoft.Resources/deployments/*. Pour obtenir la liste des rôles et autorisations, consultez Rôles intégrés Azure.

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

Pour accéder aux nœuds AKS, vous vous connectez à l’aide d’une paire de clés SSH (publique et privée), que vous générez à l’aide de la commande ssh-keygen. Par défaut, ces fichiers sont créés dans le répertoire ~/.ssh. L’exécution de la commande ssh-keygen remplace toute paire de clés SSH portant le même nom qui existe déjà dans l’emplacement donné.

  1. Accédez à https://shell.azure.com pour ouvrir Cloud Shell dans votre navigateur.

  2. Exécutez la commande ssh-keygen. L’exemple suivant crée une paire de clés SSH à l’aide du chiffrement RSA avec une longueur de 4096 bits :

    ssh-keygen -t rsa -b 4096

Pour plus d’informations sur la création de clés SSH, consultez Créer et gérer les clés SSH pour l’authentification dans Azure.

Vérifier le modèle

Le déploiement suivant utilise un modèle ARM à partir de Azure modèles de démarrage rapide :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "clusterName": {
      "type": "string",
      "defaultValue": "aclakscluster",
      "metadata": {
        "description": "The name of the Managed Cluster resource."
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "The location of the Managed Cluster resource."
      }
    },
    "dnsPrefix": {
      "type": "string",
      "metadata": {
        "description": "Optional DNS prefix to use with hosted Kubernetes API server FQDN."
      }
    },
    "osDiskSizeGB": {
      "type": "int",
      "defaultValue": 0,
      "minValue": 0,
      "maxValue": 1023,
      "metadata": {
        "description": "Disk size (in GB) to provision for each of the agent pool nodes. Specifying 0 applies the default disk size for that agentVMSize."
      }
    },
    "agentCount": {
      "type": "int",
      "defaultValue": 3,
      "minValue": 1,
      "maxValue": 50,
      "metadata": {
        "description": "The number of nodes for the cluster."
      }
    },
    "agentVMSize": {
      "type": "string",
      "defaultValue": "standard_d2s_v3",
      "metadata": {
        "description": "The size of the Virtual Machine."
      }
    },
    "linuxAdminUsername": {
      "type": "string",
      "metadata": {
        "description": "User name for the Linux Virtual Machines."
      }
    },
    "sshRSAPublicKey": {
      "type": "string",
      "metadata": {
        "description": "Configure all linux machines with the SSH RSA public key string."
      }
    }
  },
  "resources": [
    {
      "type": "Microsoft.ContainerService/managedClusters",
      "apiVersion": "2026-03-01",
      "name": "[parameters('clusterName')]",
      "location": "[parameters('location')]",
      "identity": {
        "type": "SystemAssigned"
      },
      "properties": {
        "dnsPrefix": "[parameters('dnsPrefix')]",
        "agentPoolProfiles": [
          {
            "name": "agentpool",
            "osDiskSizeGB": "[parameters('osDiskSizeGB')]",
            "count": "[parameters('agentCount')]",
            "vmSize": "[parameters('agentVMSize')]",
            "osType": "Linux",
            "osSKU": "AzureContainerLinux",
            "mode": "System"
          }
        ],
        "linuxProfile": {
          "adminUsername": "[parameters('linuxAdminUsername')]",
          "ssh": {
            "publicKeys": [
              {
                "keyData": "[parameters('sshRSAPublicKey')]"
              }
            ]
          }
        }
      }
    }
  ],
  "outputs": {
    "controlPlaneFQDN": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.ContainerService/managedClusters', parameters('clusterName')), '2024-02-01').fqdn]"
    }
  }
}

Le type de ressource définie dans le modèle ARM est Microsoft.ContainerService/managedClusters.

Déployer le modèle

  1. Sélectionnez Déployer sur Azure pour vous connecter et ouvrir un modèle.

    Bouton pour déployer le modèle Resource Manager sur Azure.

  2. Dans la page Informations de base, conservez les valeurs par défaut pour Taille du disque du système d’exploitation en Go, Nombre d’agents, Taille de machine virtuelle de l’agent, Type de système d’exploitation, puis configurez les paramètres de modèle suivants :

    • Abonnement: Sélectionnez un abonnement Azure.
    • Groupe de ressources : Sélectionnez Créer nouveau. Entrez un nom unique pour le groupe de ressources, tel que myACLResourceGroup, puis sélectionnez OK.
    • Référence SKU du système d’exploitation : spécifiez AzureContainerLinux.
    • Emplacement : sélectionnez un emplacement, tel que USA Ouest.
    • Nom du cluster : entrez un nom unique pour le cluster AKS, tel que myACLCluster.
    • Préfixe DNS : entrez un préfixe DNS unique pour votre cluster, tel que myaclcluster.
    • Nom d’utilisateur administrateur Linux : entrez un nom d’utilisateur pour vous connecter à l’aide de SSH, par exemple azureuser.
    • Source de clé publique SSH : sélectionnez Utiliser la clé publique existante.
    • Nom de la paire de clés : copiez et collez la partie publique de votre paire de clés SSH (par défaut, le contenu de ~/.ssh/id_rsa.pub).

  3. Sélectionnez Vérifier + Créer>Créer.

    La création du cluster AKS ne prend que quelques minutes. Attendez que le déploiement se termine avant de vous connecter au cluster.

Se connecter au cluster

Pour gérer un cluster Kubernetes, utilisez kubectl, le client de ligne de commande Kubernetes. kubectl est déjà installé si vous utilisez Azure Cloud Shell. Pour installer kubectl localement, utilisez la commande az aks install-cli .

  1. Configurez kubectl afin de vous connecter à votre cluster Kubernetes avec la commande az aks get-credentials. Cette commande télécharge les informations d’identification et configure l’interface CLI Kubernetes pour les utiliser.

    az aks get-credentials --resource-group myACLResourceGroup --name myACLCluster

  2. Pour vérifier la connexion à votre cluster, exécutez la commande kubectl get. Cette commande renvoie la liste des nœuds de cluster.

    kubectl get nodes

    L'exemple suivant présente les trois nœuds créés dans les étapes précédentes. Assurez-vous que l’état du nœud est Prêt :

    NAME                       STATUS   ROLES   AGE     VERSION
aks-agentpool-12345678-0   Ready    agent   6m44s   v1.34.0
aks-agentpool-12345678-1   Ready    agent   6m46s   v1.34.0
aks-agentpool-12345678-2   Ready    agent   6m45s   v1.34.0

Supprimer le cluster

Si vous n’avez plus besoin des ressources que vous avez créées dans ce guide de démarrage rapide, vous pouvez les supprimer pour éviter des frais Azure.

Supprimez le groupe de ressources Azure et toutes les ressources associées à l’aide de la commande az group delete :

az group delete --name myACLResourceGroup --yes --no-wait

Contenu connexe

Dans ce guide de démarrage rapide, vous avez déployé un cluster AKS Azure Container Linux (ACL) à l’aide d’un modèle ARM. Pour en savoir plus sur ACL, consultez les ressources suivantes :

  • Last updated on