Démarrage rapide : déployer un cluster Azure Kubernetes Service (AKS) avec l’extension Bicep Kubernetes (préversion)

Article
08/09/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éployez un cluster AKS avec l’extension Bicep Kubernetes (préversion).
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.

Important

L’extension Bicep Kubernetes est actuellement en préversion. Vous pouvez activer la fonctionnalité à partir du fichier de configuration Bicep en ajoutant :

{
 "experimentalFeaturesEnabled": {
   "extensibility": true,
 }
}

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

Bicep est un langage spécifique à un domaine (DSL) qui utilise la syntaxe déclarative pour déployer des ressources Azure. Il fournit une syntaxe concise, une cohérence des types fiable et une prise en charge de la réutilisation du code. Bicep offre la meilleure expérience de création pour vos solutions d’infrastructure en tant que code dans Azure.

Pour configurer votre environnement pour le développement Bicep, consultez Installer les outils bicep. Au terme de cette procédure, vous disposez de Visual Studio Code et de l’extension Bicep. Vous disposez également de la dernière version d’Azure CLI ou du dernier module Azure PowerShell.
Pour créer un cluster AKS à l’aide d’un fichier Bicep, vous fournissez une clé publique SSH. Si vous avez besoin de cette ressource, reportez-vous à la section suivante. Dans le cas contraire, passez à Examiner le fichier du biceps.
Pour déployer un fichier Bicep, 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.

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

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

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

# Create an SSH key pair using Azure CLI
az sshkey create --name "mySSHKey" --resource-group "myResourceGroup"

# Create an SSH key pair using ssh-keygen
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.

Examiner le fichier Bicep

Le fichier Bicep utilisé pour créer un cluster AKS provient des modèles de démarrage rapide Azure. Pour plus d’exemples AKS, consultez Modèles de démarrage rapide AKS.

@description('The name of the Managed Cluster resource.')
param clusterName string = 'aks101cluster'

@description('The location of the Managed Cluster resource.')
param location string = resourceGroup().location

@description('Optional DNS prefix to use with hosted Kubernetes API server FQDN.')
param dnsPrefix string

@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.')
@minValue(0)
@maxValue(1023)
param osDiskSizeGB int = 0

@description('The number of nodes for the cluster.')
@minValue(1)
@maxValue(50)
param agentCount int = 3

@description('The size of the Virtual Machine.')
param agentVMSize string = 'standard_d2s_v3'

@description('User name for the Linux Virtual Machines.')
param linuxAdminUsername string

@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\'')
param sshRSAPublicKey string

resource aks 'Microsoft.ContainerService/managedClusters@2024-02-01' = {
  name: clusterName
  location: location
  identity: {
    type: 'SystemAssigned'
  }
  properties: {
    dnsPrefix: dnsPrefix
    agentPoolProfiles: [
      {
        name: 'agentpool'
        osDiskSizeGB: osDiskSizeGB
        count: agentCount
        vmSize: agentVMSize
        osType: 'Linux'
        mode: 'System'
      }
    ]
    linuxProfile: {
      adminUsername: linuxAdminUsername
      ssh: {
        publicKeys: [
          {
            keyData: sshRSAPublicKey
          }
        ]
      }
    }
  }
}

output controlPlaneFQDN string = aks.properties.fqdn

La ressource définie dans le fichier Bicep est Microsoft.ContainerService/managedClusters.

Enregistrez une copie du fichier sous main.bicep dans votre ordinateur local.

Ajouter la définition d’application

Pour déployer l’application, vous utilisez un fichier manifeste pour créer tous les objets requis pour exécuter l’application du magasin AKS. 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.

Créez un fichier nommé aks-store-quickstart.yaml dans le même dossier que main.bicep et copiez-le dans 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.

Ouvrez main.bicep dans Visual Studio Code.
Appuyez sur Ctrl+Maj+P pour ouvrir la palette de commandes.
Recherchez bicep, puis sélectionnez Bicep : Importer le manifeste Kubernetes.
Sélectionnez aks-store-quickstart.yaml dans l’invite. Ce processus crée un fichier aks-store-quickstart.bicep dans le même dossier.

Ouvrez main.bicep et ajoutez le Bicep suivant à la fin du fichier pour référencer le module nouvellement créé aks-store-quickstart.bicep :

module kubernetes './aks-store-quickstart.bicep' = {
  name: 'buildbicep-deploy'
  params: {
    kubeConfig: aks.listClusterAdminCredential().kubeconfigs[0].value
  }
}

Enregistrez à la fois main.bicep et aks-store-quickstart.bicep.

Créez un groupe de ressources Azure en utilisant la commande az group create.
```
az group create --name myResourceGroup --location eastus
```

Déployez le fichier Bicep en utilisant la commande az deployment group create.

az deployment group create --resource-group myResourceGroup --template-file main.bicep --parameters clusterName=<cluster-name> dnsPrefix=<dns-previs> linuxAdminUsername=<linux-admin-username> sshRSAPublicKey='<ssh-key>'

Créez un groupe de ressources Azure en utilisant la cmdlet New-AzResourceGroup.
```
New-AzResourceGroup -Name myResourceGroup -Location eastus
```

Déployez le fichier Bicep en utilisant la cmdlet New-AzResourceGroupDeployment.

New-AzResourceGroupDeployment -ResourceGroupName myResourceGroup -TemplateFile ./main.bicep -clusterName=<cluster-name> -dnsPrefix=<dns-prefix> -linuxAdminUsername=<linux-admin-username> -sshRSAPublicKey="<ssh-key>"

Spécifiez les valeurs suivantes dans les commandes :

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.
Clé publique RSA SSH : copiez et collez la partie publique de votre paire de clés SSH (par défaut, le contenu de ~/.ssh/id_rsa.pub).

La création du cluster AKS ne prend que quelques minutes. Attendez que le cluster soit correctement déployé pour passer à l’étape suivante.

Valider le déploiement Bicep

Connectez-vous au portail Azure.
Dans le menu du portail Microsoft Azure ou dans la page d’Accueil, accédez à votre cluster AKS.
Sous Ressources Kubernetes, sélectionnez Services et entrées.
Recherchez le service store-front et copiez la valeur de l’adresse IP externe.
Ouvrez un navigateur web à l'adresse IP externe de votre service pour voir l'application Azure Store en action.

Supprimer le cluster

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

Azure CLI
Azure PowerShell

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

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

Supprimez le groupe de ressources, le service conteneur et toutes les ressources associées en utilisant la cmdlet Remove-AzResourceGroup.

Remove-AzResourceGroup -Name myResourceGroup

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.

Didacticiel AKS

Partager via

Démarrage rapide : déployer un cluster Azure Kubernetes Service (AKS) avec l’extension Bicep Kubernetes (préversion)

Avant de commencer

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

Examiner le fichier Bicep

Ajouter la définition d’application

Déployer le fichier Bicep

Valider le déploiement Bicep

Supprimer le cluster

Étapes suivantes

Ressources supplémentaires