Démarrage rapide : déployer un cluster Azure Kubernetes Service (AKS) à l’aide du Portail Azure

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 allez :

• Déployer un cluster AKS dans le portail Azure.
• Exécutez un exemple d'application multi-conteneurs avec un groupe de microservices et de front-end web simulant un scénario de vente au détail.

Avant de commencer

Ce guide de démarrage rapide 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 ne disposez pas d’un compte Azure, créez-en un gratuitement avant de commencer.
• Si vous ne connaissez pas Azure Cloud Shell, consultez Vue d’ensemble d’Azure Cloud Shell.
• Vérifiez que l’identité que vous utilisez pour créer votre cluster dispose des autorisations minimales appropriées. Pour plus d’informations concernant l’accès et l’identité pour AKS, consultez Options d’accès et d’identité pour Kubernetes Azure Service (AKS).

Créer un cluster AKS

1. Connectez-vous au portail Azure.

2. Sur la page d’accueil du portail Azure, sélectionnez Créer une ressource.

3. Dans la section Catégories, sélectionnez Infrastructure Services>Azure Kubernetes Service (AKS).

4. Sous l’onglet Informations de base, configurez les paramètres suivants :

   • Sous Détails du projet :

     • Abonnement : sélectionnez l’abonnement Azure à utiliser pour ce cluster AKS.
     • Groupe de ressources : sélectionnez Créer, entrez un nom de groupe de ressources, tel que myResourceGroup, puis sélectionnez Ok. Bien que vous puissiez sélectionner un groupe de ressources existant, à des fins de test ou d’évaluation, nous vous recommandons de créer un groupe de ressources pour héberger temporairement ces ressources et éviter d’avoir un impact sur vos charges de travail de production ou de développement.

   • Sous Détails du cluster :

     • Configuration prédéfinie de cluster : sélectionnez Dev/Test. Pour plus d’informations sur les configurations prédéfinies, consultez les présélections de configuration de cluster dans le portail Azure. Vous pouvez modifier la configuration prédéfinie lors de la création de votre cluster en sélectionnant Comparer les présélections et en choisissant une autre option.

     

     • Nom du cluster Kubernetes : entrez un nom de cluster, tel que myAKSCluster.

     • Région : sélectionnez une région, par exemple USA Est 2.

     • Gestionnaire de flotte : Aucun

     • Zones de disponibilité : Aucun. Désélectionnez toutes les zones sélectionnées.

     • Niveau tarifaire AKS : sélectionnez Gratuit.

     • Laissez les valeurs par défaut pour les autres paramètres, puis sélectionnez Suivant.

       

5. Sous l’onglet Pools de nœuds, configurez les paramètres suivants :

   • Sélectionnez Ajouter un pool de nœuds et sélectionnez Ajouter un pool de nœuds de jeu d'échelles de machines virtuelles

   • Nom : entrez un nom tel que nplinux.

   • Mode : sélectionnez Utilisateur.

   • Référence SKU du système d’exploitation : sélectionnez Ubuntu Linux.

   • Zones de disponibilité : sélectionnez Aucune.

   • Laissez la case Activer les instances Azure Spot décochée.

   • Taille de nœud : sélectionnez Choisir une taille. Dans la page Sélectionner une taille de machine virtuelle , recherchez D2s_v5, sélectionnez cette taille de machine virtuelle, puis sélectionnez.

   • Utilisez les valeurs par défaut pour les paramètres restants, puis sélectionnez Ajouter.

     

6. Sélectionnez Vérifier + créer pour effectuer la validation de la configuration du cluster. Une fois la validation terminée, sélectionnez Créer.

   La création du cluster AKS ne prend que quelques minutes. Une fois votre déploiement terminé, accédez à votre ressource en sélectionnant Aller à la ressource, ou en accédant au groupe de ressources de cluster AKS et en sélectionnant la ressource AKS.

Se connecter au cluster

Vous utilisez le client de ligne de commande Kubernetes, kubectl, pour gérer les clusters Kubernetes. Si vous utilisez Azure Cloud Shell, kubectl est déjà installé. Si vous ne connaissez pas Cloud Shell, consultez Vue d’ensemble d’Azure Cloud Shell.

Si vous utilisez Cloud Shell, ouvrez-le avec le bouton >_ en haut du portail Azure. Si vous utilisez PowerShell localement, connectez-vous à Azure via la commande Connect-AzAccount. Si vous utilisez Azure CLI localement, connectez-vous à Azure via la commande az login.

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 l’état souhaité d’un cluster, comme 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 : passe des commandes.
• Rabbit MQ : file d’attente de messages pour une file d’attente de commandes.

1. Dans le Cloud Shell, ouvrez un éditeur et créez un fichier nommé aks-store-quickstart.yaml.

2. Collez le manifeste suivant dans l’éditeur :

   apiVersion: apps/v1
   kind: StatefulSet
   metadata:
     name: rabbitmq
   spec:
     serviceName: rabbitmq
     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
           startupProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 5
             initialDelaySeconds: 20
             periodSeconds: 10
           readinessProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 5
           livenessProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
         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
           env:
           - name: AI_SERVICE_URL
             value: "http://ai-service:5001/"
           resources:
             requests:
               cpu: 1m
               memory: 1Mi
             limits:
               cpu: 2m
               memory: 20Mi
           readinessProbe:
             httpGet:
               path: /health
               port: 3002
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 5
           livenessProbe:
             httpGet:
               path: /health
               port: 3002
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
   ---
   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
           startupProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 3
             initialDelaySeconds: 5
             periodSeconds: 5
           readinessProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 3
           livenessProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
   ---
   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 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.

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

Test de l’application

Quand l’application s’exécute, un service Kubernetes expose le front-end de l’application sur Internet. L’exécution de ce processus peut prendre plusieurs minutes.

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

   kubectl get pods
   

2. Recherchez une adresse IP publique pour l’application store-front. 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
   

   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
   

3. Ouvrez un navigateur web à l'adresse IP externe de votre service pour voir l'application Azure Store en action.

   

Supprimer le cluster

Si vous ne prévoyez pas de passer par la série de tutoriels AKS, nettoyez les ressources inutiles pour éviter des frais Azure.

1. Dans le Portail Azure, accédez à votre groupe de ressources de cluster AKS.

2. Sélectionnez Supprimer le groupe de ressources.

3. Entrez le nom du groupe de ressources que vous souhaitez supprimer, puis sélectionnez Supprimer>Supprimer.

   Remarque

   Le cluster AKS a été créé avec une identité managée affectée par le système. Cette identité est managée par la plateforme et ne nécessite pas de suppression.

Étapes suivantes

Dans ce Démarrage rapide, vous avez déployé un cluster Kubernetes, dans lequel vous avez ensuite déployé une application multi-conteneur. 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 découvrir un exemple complet code à déploiement, passez à la série de tutoriels sur le cluster Kubernetes.