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

Article
08/12/2024

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 dans le portail Azure.
Exécutez un exemple d’application multiconteneur avec un groupe de microservices et de front-ends web simulant un scénario de vente au détail.

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

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 n’avez pas d’abonnement Azure, créez un compte gratuit Azure 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 sur l’accès et l’identité pour AKS, consultez Options d’accès et d’identité pour Kubernetes Azure Service (AKS).

Remarque

Le pool de nœuds Linux Azure est désormais en disponibilité générale (GA). Pour en savoir plus sur les avantages et les étapes de déploiement, consultez la Présentation de l’hôte de conteneur Linux Azure pour AKS.

Créer un cluster AKS

Connectez-vous au portail Azure.
Sur la page d’accueil du portail Azure, sélectionnez Créer une ressource.
Dans la section Catégories, sélectionnez Conteneurs>Azure Kubernetes Service (AKS).
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 nouveau, 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 Présélections de configuration de cluster dans le portail Azure.
    
    Remarque
    
    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.
  - Zones de disponibilité : sélectionnez Aucune.
  - Niveau tarifaire AKS : sélectionnez Gratuit.
  - Laissez les valeurs par défaut pour les autres paramètres, puis sélectionnez Suivant.
Sous l’onglet Pools de nœuds, configurez les paramètres suivants :
- Sélectionnez Ajouter un pool de nœuds et entrez un Nom de pool de nœuds, 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, sélectionnez D2s_v3, puis sélectionnez Sélectionner.
- Laissez les valeurs par défaut pour les autres paramètres, puis sélectionnez Ajouter.
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.

Azure CLI
Azure PowerShell

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
```
Vérifiez la connexion à votre cluster avec la commande kubectl get pour retourner une liste des nœuds du cluster.
```
kubectl get nodes
```
L’exemple de sortie suivant montre le nœud unique créé au cours des étapes précédentes. Assurez-vous que l’état du nœud est Prêt.
```
NAME                       STATUS   ROLES   AGE     VERSION
aks-nodepool1-31718369-0   Ready    agent   6m44s   v1.15.10
```

Configurez kubectl afin de vous connecter à votre cluster Kubernetes avec la cmdlet Import-AzAksCredential. Cette commande télécharge les informations d’identification et configure l’interface CLI Kubernetes pour les utiliser.
```
Import-AzAksCredential -ResourceGroupName myResourceGroup -Name myAKSCluster
```
Vérifiez la connexion à votre cluster avec la commande kubectl get pour retourner une liste des nœuds du cluster.
```
kubectl get nodes
```
L’exemple de sortie suivant montre le nœud unique créé au cours des étapes précédentes. Assurez-vous que l’état du nœud est Prêt.
```
NAME                       STATUS  ROLES   AGE     VERSION
aks-nodepool1-31718369-0   Ready   agent   6m44s   v1.15.10
```

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

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

Collez le manifeste suivant dans l’éditeur :

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

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 montre les déploiements et les 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.

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

Dans le Portail Azure, accédez à votre groupe de ressources de cluster AKS.
Sélectionnez Supprimer le groupe de ressources.
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.

Série de tutoriels AKS

Partager via

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

Avant de commencer

Créer un cluster AKS

Se connecter au cluster

Déployer l’application

Test de l’application

Supprimer le cluster

Étapes suivantes

Ressources supplémentaires