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

Commencez à utiliser Azure cluster Container Linux (ACL) pour AKS en déployant un cluster AKS à l’aide d’un modèle Azure Resource Manager (ARM).

Dans ce guide de démarrage rapide, vous allez apprendre à :

Prerequisites

• Cet article suppose une compréhension élémentaire des concepts liés à Kubernetes. Pour plus d’informations, consultez Concepts de base de Kubernetes pour AKS (Azure Kubernetes Service).
• Si vous n’avez pas de compte Azure, créez un compte gratuit avant de commencer.
• Vérifiez que l’identité que vous utilisez pour créer votre cluster dispose des autorisations minimales appropriées. Pour plus d’informations sur l’accès et l’identité pour AKS, consultez les options d’accès et d’identité pour Azure Kubernetes Service (AKS).
• Pour déployer un modèle ARM, vous avez besoin d'avoir un accès en écriture sur les ressources que vous déployez et d'avoir accès à toutes les opérations sur le type de ressource Microsoft.Resources/deployments. Par exemple, pour déployer une machine virtuelle, vous avez besoin 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.

Après votre déploiement du cluster à partir du modèle, vous pouvez utiliser Azure CLI ou Azure PowerShell pour vous connecter au cluster et déployer l’exemple d’application.

Inscrire les fournisseurs de ressources requis

Vous devrez peut-être inscrire les fournisseurs de ressources requis, tels que Microsoft.ContainerService dans votre abonnement Azure.

Vérifier l’état de l’inscription

Vérifiez l’état de l’inscription à l’aide de la az provider show commande.

az provider show --namespace Microsoft.ContainerService --query registrationState

Inscrire le fournisseur de ressources

Si nécessaire, inscrivez le fournisseur de ressources Microsoft.ContainerService à l’aide de la commande az provider register.

az provider register --namespace Microsoft.ContainerService

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

Pour créer un cluster AKS à l’aide d’un modèle ARM, vous fournissez une clé publique SSH. Si vous avez besoin de cette ressource, suivez les étapes dans cette section. Sinon, passez à la section Vérifier le modèle.

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é. 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.

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

2. Créez un groupe de ressources à l’aide de la commande az group create. L’exemple suivant crée un groupe de ressources nommé myResourceGroup dans la région USA Est :

   az group create \
     --name myResourceGroup \
     --location eastus
   

3. Créez une paire de clés SSH à l’aide de la az sshkey create commande ou de la ssh-keygen commande.

   az sshkey create --name mySSHKey --resource-group myResourceGroup
   

   Ou créez une paire de clés SSH à l’aide ssh-keygende :

   ssh-keygen -t rsa -b 4096
   

4. Pour déployer le modèle, vous devez fournir la clé publique de la paire SSH. Récupérez la clé publique à l’aide de la az sshkey show commande.

   az sshkey show --name mySSHKey --resource-group myResourceGroup --query publicKey
   

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",
  "metadata": {
    "_generator": {
      "name": "bicep",
      "version": "0.26.170.59819",
      "templateHash": "14823542069333410776"
    }
  },
  "parameters": {
    "clusterName": {
      "type": "string",
      "defaultValue": "aks101cluster",
      "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. This value ranges from 0 to 1023. Specifying 0 will apply 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. Your key should include three parts, for example 'ssh-rsa AAAAB...snip...UcyupgH azureuser@linuxvm'"
      }
    }
  },
  "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')), '2026-03-01').fqdn]"
    }
  }
}

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

Pour plus d’exemples AKS, consultez le site Modèles de démarrage rapide AKS.

Déployer le modèle

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

   

2. Configurez les paramètres du modèle dans la page Déploiement personnalisé . Pour ce guide de démarrage rapide, conservez les valeurs par défaut pour la taille du disque du système d’exploitation, le nombre d’agents, la taille de machine virtuelle de l’agent et le type de système d’exploitation. Fournissez vos propres valeurs pour les paramètres 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 myResourceGroup, puis sélectionnez OK.
   • Référence SKU du système d’exploitation : spécifiez AzureContainerLinux. Si vous ne mettez pas à jour la référence SKU du système d’exploitation, la valeur par défaut est Ubuntu.
   • Emplacement : sélectionnez un emplacement, comme USA Est.
   • Nom du cluster : entrez un nom unique pour le cluster AKS, tel que myAKSCluster.
   • Préfixe DNS : entrez un préfixe DNS unique pour votre cluster, tel que myakscluster.
   • 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 cluster soit déployé avec succès avant de passer à l’étape suivante.

Se connecter au cluster

Pour gérer un cluster Kubernetes, utilisez kubectl, le client de ligne de commande Kubernetes. Si vous utilisez Azure Cloud Shell, kubectl est déjà installé.

Déployer l’application

Pour déployer l'application, vous utilisez un fichier manifeste pour créer tous les objets nécessaires à l'exécution de l'application AKS Store. Un fichier manifeste Kubernetes définit un état souhaité d’un cluster, notamment les images conteneur à exécuter. Le manifeste inclut les déploiements et services Kubernetes suivants :

• Vitrine : application web permettant aux clients d’afficher les produits et de passer des commandes.
• Service de produit : affiche les informations sur le produit.
• Service de commande : passer des commandes.
• Rabbit MQ : file d’attente de messages pour une file d’attente de commandes.

1. Créez un fichier nommé aks-store-quickstart.yaml et copiez-y le manifeste suivant :

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: rabbitmq
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: rabbitmq
     template:
       metadata:
         labels:
           app: rabbitmq
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: rabbitmq
           image: mcr.microsoft.com/mirror/docker/library/rabbitmq:3.10-management-alpine
           ports:
           - containerPort: 5672
             name: rabbitmq-amqp
           - containerPort: 15672
             name: rabbitmq-http
           env:
           - name: RABBITMQ_DEFAULT_USER
             value: "username"
           - name: RABBITMQ_DEFAULT_PASS
             value: "password"
           resources:
             requests:
               cpu: 10m
               memory: 128Mi
             limits:
               cpu: 250m
               memory: 256Mi
           volumeMounts:
           - name: rabbitmq-enabled-plugins
             mountPath: /etc/rabbitmq/enabled_plugins
             subPath: enabled_plugins
         volumes:
         - name: rabbitmq-enabled-plugins
           configMap:
             name: rabbitmq-enabled-plugins
             items:
             - key: rabbitmq_enabled_plugins
               path: enabled_plugins
   ---
   apiVersion: v1
   data:
     rabbitmq_enabled_plugins: |
       [rabbitmq_management,rabbitmq_prometheus,rabbitmq_amqp1_0].
   kind: ConfigMap
   metadata:
     name: rabbitmq-enabled-plugins
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: rabbitmq
   spec:
     selector:
       app: rabbitmq
     ports:
       - name: rabbitmq-amqp
         port: 5672
         targetPort: 5672
       - name: rabbitmq-http
         port: 15672
         targetPort: 15672
     type: ClusterIP
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: order-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: order-service
     template:
       metadata:
         labels:
           app: order-service
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: order-service
           image: ghcr.io/azure-samples/aks-store-demo/order-service:latest
           ports:
           - containerPort: 3000
           env:
           - name: ORDER_QUEUE_HOSTNAME
             value: "rabbitmq"
           - name: ORDER_QUEUE_PORT
             value: "5672"
           - name: ORDER_QUEUE_USERNAME
             value: "username"
           - name: ORDER_QUEUE_PASSWORD
             value: "password"
           - name: ORDER_QUEUE_NAME
             value: "orders"
           - name: FASTIFY_ADDRESS
             value: "0.0.0.0"
           resources:
             requests:
               cpu: 1m
               memory: 50Mi
             limits:
               cpu: 75m
               memory: 128Mi
         initContainers:
         - name: wait-for-rabbitmq
           image: busybox
           command: ['sh', '-c', 'until nc -zv rabbitmq 5672; do echo waiting for rabbitmq; sleep 2; done;']
           resources:
             requests:
               cpu: 1m
               memory: 50Mi
             limits:
               cpu: 75m
               memory: 128Mi
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: order-service
   spec:
     type: ClusterIP
     ports:
     - name: http
       port: 3000
       targetPort: 3000
     selector:
       app: order-service
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: product-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: product-service
     template:
       metadata:
         labels:
           app: product-service
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: product-service
           image: ghcr.io/azure-samples/aks-store-demo/product-service:latest
           ports:
           - containerPort: 3002
           resources:
             requests:
               cpu: 1m
               memory: 1Mi
             limits:
               cpu: 1m
               memory: 7Mi
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: product-service
   spec:
     type: ClusterIP
     ports:
     - name: http
       port: 3002
       targetPort: 3002
     selector:
       app: product-service
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: store-front
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: store-front
     template:
       metadata:
         labels:
           app: store-front
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: store-front
           image: ghcr.io/azure-samples/aks-store-demo/store-front:latest
           ports:
           - containerPort: 8080
             name: store-front
           env:
           - name: VUE_APP_ORDER_SERVICE_URL
             value: "http://order-service:3000/"
           - name: VUE_APP_PRODUCT_SERVICE_URL
             value: "http://product-service:3002/"
           resources:
             requests:
               cpu: 1m
               memory: 200Mi
             limits:
               cpu: 1000m
               memory: 512Mi
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: store-front
   spec:
     ports:
     - port: 80
       targetPort: 8080
     selector:
       app: store-front
     type: LoadBalancer
   

   Pour obtenir une répartition des fichiers manifeste YAML, consultez Déploiements et manifestes YAML.

   Si vous créez et enregistrez le fichier YAML localement, vous pouvez charger le fichier manifeste dans votre répertoire par défaut dans CloudShell en sélectionnant le bouton Charger/Télécharger des fichiers et en sélectionnant le fichier à partir de votre système de fichiers local.

2. Déployez l’application à l’aide de la commande kubectl apply et spécifiez le nom de votre manifeste YAML.

   kubectl apply -f aks-store-quickstart.yaml
   

   L'exemple de sortie suivant présente les déploiements et services :

   deployment.apps/rabbitmq created
   service/rabbitmq created
   deployment.apps/order-service created
   service/order-service created
   deployment.apps/product-service created
   service/product-service created
   deployment.apps/store-front created
   service/store-front created
   

Tester l’application

1. Vérifiez l'état des pods déployés à l'aide de la commande kubectl get pods. Assurez-vous que tous les pods sont Running avant de continuer.

   kubectl get pods
   

2. Recherchez une adresse IP publique pour l'application de vitrine. Surveillez la progression avec la commande kubectl get service et l’argument --watch.

   kubectl get service store-front --watch
   

   La sortie EXTERNAL-IP pour le service store-front indique initialement qu'il est en attente :

   NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
   store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m
   

3. Quand l’adresse EXTERNAL-IP passe de l’état pending à une adresse IP publique réelle, utilisez CTRL-C pour arrêter le processus de surveillance kubectl.

   L’exemple de sortie suivant montre une adresse IP publique valide affectée au service :

   NAME          TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)        AGE
   store-front   LoadBalancer   10.0.100.10   20.62.159.19   80:30025/TCP   4h5m
   

4. Ouvrez un navigateur web sur l’adresse IP externe de votre service pour afficher l’application Azure Store en action :

   

Supprimer le cluster

Si vous ne prévoyez pas de passer par le didacticiel AKS, supprimez les ressources inutiles pour éviter les frais Azure.

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

Remove-AzResourceGroup -Name myResourceGroup -Force

Contenu connexe

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