Partage via


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

AKS (Azure Kubernetes Service) est un service Kubernetes managé qui vous permet de déployer et de gérer rapidement des clusters. Dans ce guide de démarrage rapide, vous :

  • Déployer un cluster AKS à l’aide d’un modèle Azure Resource Manager.
  • Exécutez un exemple d’application multiconteneur avec un groupe de microservices et de serveurs web frontaux simulant un scénario de vente au détail.

Un modèle Azure Resource Manager est un fichier JSON (JavaScript Object Notation) qui définit l’infrastructure et la configuration de votre projet. Le modèle utilise la syntaxe déclarative. Vous décrivez votre déploiement prévu sans écrire la séquence de commandes de programmation pour créer le déploiement.

Remarque

Dans cet article, vous trouverez les étapes à suivre pour déployer rapidement un cluster AKS. Les paramètres par défaut sont utilisés à des fins d'évaluation uniquement. Avant de déployer un cluster prêt pour la production, nous vous recommandons de vous familiariser avec notre architecture de référence de base pour prendre en compte la façon dont elle s’aligne sur vos besoins métier.

Avant de commencer

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 d’abonnement Azure, créez un compte gratuit Azure 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 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 aux ressources que vous déployez et d’un 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.

Cet article nécessite la version 2.0.64 ou ultérieure d’Azure CLI. Si vous utilisez Azure Cloud Shell, sachez que la dernière version y est déjà installée.

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 en tirant parti d’une paire de clés SSH (publique et privée). Pour créer une paire de clés SSH :

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

  2. Créez une paire de clés SSH en utilisant la commande az-sshkey create ou la commande ssh-keygen.

    # Create an SSH key pair using Azure CLI
    az sshkey create --name "mySSHKey" --resource-group "myResourceGroup"
    
    # or
    
    # Create an SSH key pair using ssh-keygen
    ssh-keygen -t rsa -b 4096
    
  3. Pour déployer le modèle, vous devez fournir la clé publique de la paire SSH. Pour récupérer la clé publique, appelez az sshkey show :

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

Par défaut, les fichiers de la clé SSH sont créés dans le répertoire ~/.ssh. L’exécution de la commande az sshkey create ou ssh-keygen remplace toutes les paires de clés SSH existantes portant le même nom.

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 modèle utilisé dans ce démarrage rapide est tiré des modèles de démarrage rapide Azure.

{
  "$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": "2024-02-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",
            "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.

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.

    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 myResourceGroup, puis sélectionnez OK.
    • Emplacement : sélectionnez un emplacement, comme USA Est.
    • Nom de 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 de l’utilisateur administrateur Linux : entrez un nom d’utilisateur pour se connecter à l’aide de SSH, tel qu’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 correctement déployé pour 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é. Pour installer et exécuter kubectl en local, appelez 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 myResourceGroup --name myAKSCluster
    
  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-27442051-vmss000000   Ready    agent   10m   v1.27.7
    aks-agentpool-27442051-vmss000001   Ready    agent   10m   v1.27.7
    aks-agentpool-27442051-vmss000002   Ready    agent   11m   v1.27.7
    

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 :

Capture d’écran de l’architecture d’exemple Azure Store.

  • 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 : passe des commandes.
  • Rabbit MQ : file d’attente de messages pour une file d’attente de commandes.

Remarque

Nous ne recommandons pas l'exécution de conteneurs avec état, comme Rabbit MQ, sans stockage persistant pour la production. Ils sont utilisés ici par souci de simplicité, mais nous vous recommandons d’utiliser des services gérés, tels qu’Azure CosmosDB ou Azure Service Bus.

  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 décomposition des fichiers manifeste YAML, consultez Déploiements et manifestes YAML.

    Si vous créez et que vous 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, puis en sélectionnant le fichier dans votre système de fichiers local.

  2. Déployez l’application en tirant parti 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
    

Test de 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 à l'adresse IP externe de votre service pour voir l'application Azure Store en action.

    Capture d’écran de l’exemple d’application AKS Store.

Supprimer le cluster

Pour éviter les frais Azure, si vous ne prévoyez pas de suivre le Tutoriel AKS, nettoyez vos ressources inutiles.

Supprimez le groupe de ressources, le service conteneur ainsi que toutes les ressources associées en appelant la commande az group delete.

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

Remarque

Le cluster AKS a été créé avec une identité managée affectée par le système, qui est l’option d’identité par défaut utilisée dans ce guide de démarrage rapide. La plateforme gère cette identité afin que vous n’ayez pas besoin de la supprimer manuellement.

Étapes suivantes

Dans ce Démarrage rapide, vous avez déployé un cluster Kubernetes dans lequel vous avez ensuite déployé une application de plusieurs conteneurs. Cet exemple d’application est fourni à des fins de version de démonstration uniquement et ne représente pas toutes les meilleures pratiques pour les applications Kubernetes. Pour obtenir des conseils sur la création de solutions complètes avec AKS pour la production, consultez Conseils pour les solutions AKS.

Pour en savoir plus sur AKS et parcourir l’exemple complet allant du code au déploiement, passez au tutoriel sur le cluster Kubernetes.