Démarrage rapide : Déployer un cluster Azure Kubernetes Service (AKS) en utilisant Terraform

Article
02/08/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 en tirant parti de Terraform.
Exécutez un exemple d’application multi-conteneur avec un groupe de micro-services et de serveurs web front-end simulant un scénario de vente au détail.

Notes

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).
Vous devez avoir un compte Azure avec un abonnement actif. Si vous n’en avez pas un, créez un compte gratuitement.
Suivez les instructions en fonction de votre interface de ligne de commande.

Pour en savoir plus sur la création d’un pool de nœuds Windows Server, consultez Créer un cluster AKS qui prend en charge les conteneurs Windows Server.

Notes

Le pool de nœuds Linux Azure est désormais en disponibilité générale. 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.

Installez et configurez Terraform.
Téléchargez kubectl.
Créez une valeur aléatoire pour le nom du groupe de ressources Azure à l’aide de random_pet.
Créez un groupe de ressources Azure à l’aide de azurerm_resource_group.
Accédez à la configuration du fournisseur AzureRM pour obtenir l’ID d’objet Azure en tirant parti de azurerm_client_config.
Créez un cluster Kubernetes en utilisant azurerm_kubernetes_cluster.
Créez une ressource AzAPI azapi_resource.
Créez une ressource AzAPI pour générer une paire de clés SSH en utilisant azapi_resource_action.

Tout d’abord, connectez-vous à votre compte Azure et authentifiez-vous en utilisant une des méthodes décrites dans la section suivante.

Terraform prend en charge seulement l’authentification auprès d’Azure avec Azure CLI. L’authentification à l’aide d’Azure PowerShell n’est pas prise en charge. Ainsi, même si vous pouvez utiliser le module Azure PowerShell avec Terraform, vous devez d’abord vous authentifier auprès d’Azure.

Implémenter le code Terraform

Notes

L’exemple de code de cet article se trouve dans le dépôt GitHub Azure Terraform. Vous pouvez afficher le fichier journal contenant les résultats des tests des versions actuelles et précédentes de Terraform.

Consultez d’autres articles et exemples de code montrant comment utiliser Terraform pour gérer les ressources Azure.

Créez un répertoire que vous pouvez utiliser pour tester l’exemple de code Terraform et définissez-le comme votre répertoire actuel.

Créez un fichier nommé providers.tf et insérez le code suivant :

Terraform

terraform {
  required_version = ">=1.0"

  required_providers {
    azapi = {
      source  = "azure/azapi"
      version = "~>1.5"
    }
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>3.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~>3.0"
    }
    time = {
      source  = "hashicorp/time"
      version = "0.9.1"
    }
  }
}

provider "azurerm" {
  features {}
}

Créez un fichier nommé ssh.tf et insérez le code suivant :

Terraform

resource "random_pet" "ssh_key_name" {
  prefix    = "ssh"
  separator = ""
}

resource "azapi_resource_action" "ssh_public_key_gen" {
  type        = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  resource_id = azapi_resource.ssh_public_key.id
  action      = "generateKeyPair"
  method      = "POST"

  response_export_values = ["publicKey", "privateKey"]
}

resource "azapi_resource" "ssh_public_key" {
  type      = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  name      = random_pet.ssh_key_name.id
  location  = azurerm_resource_group.rg.location
  parent_id = azurerm_resource_group.rg.id
}

output "key_data" {
  value = azapi_resource_action.ssh_public_key_gen.output.publicKey
}

Créez un fichier nommé main.tf et insérez le code suivant :

Terraform

# Generate random resource group name
resource "random_pet" "rg_name" {
  prefix = var.resource_group_name_prefix
}

resource "azurerm_resource_group" "rg" {
  location = var.resource_group_location
  name     = random_pet.rg_name.id
}

resource "random_pet" "azurerm_kubernetes_cluster_name" {
  prefix = "cluster"
}

resource "random_pet" "azurerm_kubernetes_cluster_dns_prefix" {
  prefix = "dns"
}

resource "azurerm_kubernetes_cluster" "k8s" {
  location            = azurerm_resource_group.rg.location
  name                = random_pet.azurerm_kubernetes_cluster_name.id
  resource_group_name = azurerm_resource_group.rg.name
  dns_prefix          = random_pet.azurerm_kubernetes_cluster_dns_prefix.id

  identity {
    type = "SystemAssigned"
  }

  default_node_pool {
    name       = "agentpool"
    vm_size    = "Standard_D2_v2"
    node_count = var.node_count
  }
  linux_profile {
    admin_username = var.username

    ssh_key {
      key_data = azapi_resource_action.ssh_public_key_gen.output.publicKey
    }
  }
  network_profile {
    network_plugin    = "kubenet"
    load_balancer_sku = "standard"
  }
}

Créez un fichier nommé variables.tf et insérez le code suivant :

Terraform

variable "resource_group_location" {
  type        = string
  default     = "eastus"
  description = "Location of the resource group."
}

variable "resource_group_name_prefix" {
  type        = string
  default     = "rg"
  description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
}

variable "node_count" {
  type        = number
  description = "The initial quantity of nodes for the node pool."
  default     = 3
}

variable "msi_id" {
  type        = string
  description = "The Managed Service Identity ID. Set this value if you're running this example using Managed Identity as the authentication method."
  default     = null
}

variable "username" {
  type        = string
  description = "The admin username for the new cluster."
  default     = "azureadmin"
}

Créez un fichier nommé outputs.tf et insérez le code suivant :

Terraform

output "resource_group_name" {
  value = azurerm_resource_group.rg.name
}

output "kubernetes_cluster_name" {
  value = azurerm_kubernetes_cluster.k8s.name
}

output "client_certificate" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].client_certificate
  sensitive = true
}

output "client_key" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].client_key
  sensitive = true
}

output "cluster_ca_certificate" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].cluster_ca_certificate
  sensitive = true
}

output "cluster_password" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].password
  sensitive = true
}

output "cluster_username" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].username
  sensitive = true
}

output "host" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].host
  sensitive = true
}

output "kube_config" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config_raw
  sensitive = true
}

Initialiser Terraform

Exécutez terraform init pour initialiser le déploiement Terraform. Cette commande télécharge le fournisseur Azure à utiliser pour la gestion de vos ressources Azure.

Console

terraform init -upgrade

Points essentiels :

Le paramètre -upgrade met à niveau les plug-ins de fournisseur nécessaires vers la version la plus récente qui est conforme aux contraintes de version de la configuration.

Créer un plan d’exécution Terraform

Exécutez terraform plan pour créer un plan d’exécution.

Console

terraform plan -out main.tfplan

Points essentiels :

La commande terraform plan crée un plan d’exécution, mais ne l’exécute pas. Au lieu de cela, elle détermine les actions nécessaires pour créer la configuration spécifiée dans vos fichiers de configuration. Ce modèle vous permet de vérifier si le plan d’exécution répond à vos attentes avant d’apporter des modifications aux ressources réelles.
Le paramètre facultatif -out vous permet de spécifier un fichier de sortie pour le plan. L’utilisation du paramètre -out garantit que le plan que vous avez examiné correspond exactement à ce qui est appliqué.

Appliquer un plan d’exécution Terraform

Exécutez terraform apply pour appliquer le plan d’exécution à votre infrastructure cloud.

Console

terraform apply main.tfplan

Points essentiels :

La commande exemple terraform apply part du principe que vous avez préalablement exécuté terraform plan -out main.tfplan.
Si vous avez spécifié un autre nom de fichier pour le paramètre -out, utilisez ce même nom dans l’appel à terraform apply.
Si vous n’avez pas utilisé le paramètre -out, appelez terraform apply sans aucun paramètre.

Vérifier les résultats

Obtenez le nom du groupe de ressources Azure à l’aide de la commande suivante.

Console
```
resource_group_name=$(terraform output -raw resource_group_name)
```

Affichez le nom de votre nouveau cluster Kubernetes en utilisant la commande az aks list.

Azure CLI

az aks list \
  --resource-group $resource_group_name \
  --query "[].{\"K8s cluster name\":name}" \
  --output table

Obtenez la configuration Kubernetes à partir de l’état Terraform et stockez-la dans un fichier que kubectl peut lire en utilisant la commande.

Console
```
echo "$(terraform output kube_config)" > ./azurek8s
```
Vérifiez que la commande précédente n’a pas ajouté de caractère ASCII EOT (End of transmission) en utilisant la commande suivante.

Console
```
cat ./azurek8s
```
Points essentiels :
- Si vous voyez << EOT au début et EOT à la fin, supprimez ces caractères du fichier. Sinon, le message d’erreur suivant peut s'afficher : error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context
Définissez une variable d’environnement de sorte que kubectl choisisse la configuration appropriée en utilisant la commande suivante.

Console
```
export KUBECONFIG=./azurek8s
```
Vérifiez l’intégrité du cluster à l’aide de la commande kubectl get nodes.

Console
```
kubectl get nodes
```

Points essentiels :

Lorsque vous avez créé le cluster AKS, la supervision a été activée pour capturer les métriques d’intégrité pour les nœuds de cluster et les pods. Ces mesures sont disponibles dans le portail Azure. Pour plus d’informations sur la supervision de l’intégrité des conteneurs, consultez Superviser l’intégrité d’Azure Kubernetes Service.
Plusieurs valeurs de clé ont été classées comme sorties lorsque vous avez appliqué le plan d’exécution Terraform. Par exemple, l’adresse de l’hôte, le nom d’utilisateur du cluster AKS et le mot de passe du cluster AKS sont générés.

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

Notes

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 et copiez-y le manifeste suivant :

YAML

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.

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

Console

kubectl apply -f aks-store-quickstart.yaml

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

Output

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. Assurez-vous que tous les pods sont Running avant de continuer.

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

Azure CLI
```
kubectl get service store-front --watch
```
La sortie EXTERNAL-IP pour le service store-front indique initialement qu'il est en attente :

Output
```
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 :

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

Nettoyer les ressources

Supprimer des ressources AKS

Quand vous n’avez plus besoin des ressources créées par le biais de Terraform, effectuez les étapes suivantes :

Exécutez le plan Terraform et spécifiez l’indicateur destroy.

Console
```
terraform plan -destroy -out main.destroy.tfplan
```
Points essentiels :
- La commande terraform plan crée un plan d’exécution, mais ne l’exécute pas. Au lieu de cela, elle détermine les actions nécessaires pour créer la configuration spécifiée dans vos fichiers de configuration. Ce modèle vous permet de vérifier si le plan d’exécution répond à vos attentes avant d’apporter des modifications aux ressources réelles.
- Le paramètre facultatif -out vous permet de spécifier un fichier de sortie pour le plan. L’utilisation du paramètre -out garantit que le plan que vous avez examiné correspond exactement à ce qui est appliqué.
Exécutez terraform apply pour appliquer le plan d’exécution.

Console
```
terraform apply main.destroy.tfplan
```

Suppression de principal de service

Obtenez l’identifiant du principal de service en utilisant la commande suivante.

Azure CLI
```
sp=$(terraform output -raw sp)
```
Supprimez le principal de service en utilisant la commande az ad sp delete.

Azure CLI
```
az ad sp delete --id $sp
```

Installer Azure Developer CLI (AZD)
Installez et configurez Terraform.
Vous pouvez passer en revue le code de l’application dans le dépôt Azure-Samples/aks-store-demo.

Cloner le modèle Azure Developer CLI

Azure Developer CLI vous permet de télécharger rapidement des exemples depuis le dépôt Azure-Samples. Dans notre guide de démarrage rapide, vous téléchargez l’application aks-store-demo. Pour plus d’informations sur les cas d’usage généraux, consultez la Vue d’ensemble de azd.

Clonez le modèle de version de démonstration d’AKS Store du référentiel Azure-Samples en utilisant la commande azd init avec le paramètre --template.

Azure Developer CLI
```
azd init --template Azure-Samples/aks-store-demo
```
Entrez un nom d’environnement pour votre projet en utilisant seulement des caractères alphanumériques et des traits d’union, comme aks-terraform-1.

Output
```
Enter a new environment name: aks-terraform-1
```

Connectez-vous à votre compte Azure Cloud

Le modèle azd contient tout le code nécessaire pour créer les services, mais vous devez vous connecter à votre compte Azure pour héberger l’application sur AKS.

Connectez-vous à votre compte en tirant parti de la commande azd auth login.

Azure Developer CLI
```
azd auth login
```
Copiez le code d’appareil qui s’affiche dans la sortie, puis appuyez sur entrée pour vous connecter.

Output
```
Start by copying the next code: XXXXXXXXX
Then press enter and continue to log in from your browser...
```
Important

Si vous utilisez une machine virtuelle en dehors du réseau ou GitHub Codespace, certaines stratégies de sécurité Azure provoquent des conflits quand vous les utilisez pour vous connecter avec azd auth login. Si vous rencontrez un problème ici, vous pouvez suivre la solution de contournement azd auth fournie ci-dessous, qui implique l’utilisation d’une requête curl à l’URL localhost vers laquelle vous avez été redirigé après l’exécution de azd auth login.
Authentifiez-vous avec vos informations d’identification sur la page de connexion de votre organisation.
Confirmez que vous tentez de vous connecter à partir d’Azure CLI.
Vérifiez le message « Authentification du code de l’appareil terminée. Connecté à Azure. » s’affiche dans votre terminal d’origine.

Output
```
Waiting for you to complete authentication in the browser...
Device code authentication completed.
Logged in to Azure.
```

solution de contournement azd auth

Cette solution de contournement nécessite votre installation de l’interface Azure CLI.

Ouvrez une fenêtre de terminal et connectez-vous avec l’interface Azure CLI en utilisant la commande az login avec le paramètre --scope défini sur https://graph.microsoft.com/.default.

Azure CLI
```
az login --scope https://graph.microsoft.com/.default
```
Vous devriez être redirigé vers une page d’authentification dans un nouvel onglet pour créer un jeton d’accès de navigateur, tel qu’illustré dans l’exemple suivant :

Output
```
https://login.microsoftonline.com/organizations/oauth2/v2.0/authorize?clientid=<your_client_id>.
```
Copiez l’URL localhost de la page web reçue après la tentative de connexion avec azd auth login.

Dans une nouvelle fenêtre de terminal, utilisez la requête curl suivante pour vous connecter. Veillez à remplacer l’espace réservé <localhost> par l’URL localhost copiée à l’étape précédente.

Console

curl <localhost>

Une connexion réussie sort une page web HTML comme illustré dans l’exemple suivant :

Output

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <meta http-equiv="refresh" content="60;url=https://docs.microsoft.com/cli/azure/">
    <title>Login successfully</title>
    <style>
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }

        code {
            font-family: Consolas, 'Liberation Mono', Menlo, Courier, monospace;
            display: inline-block;
            background-color: rgb(242, 242, 242);
            padding: 12px 16px;
            margin: 8px 0px;
        }
    </style>
</head>
<body>
    <h3>You have logged into Microsoft Azure!</h3>
    <p>You can close this window, or we will redirect you to the <a href="https://docs.microsoft.com/cli/azure/">Azure CLI documentation</a> in 1 minute.</p>
    <h3>Announcements</h3>
    <p>[Windows only] Azure CLI is collecting feedback on using the <a href="https://learn.microsoft.com/windows/uwp/security/web-account-manager">Web Account Manager</a> (WAM) broker for the login experience.</p>
    <p>You may opt-in to use WAM by running the following commands:</p>
    <code>
        az config set core.allow_broker=true<br>
        az account clear<br>
        az login
    </code>
</body>
</html>

Fermez le terminal actuel et ouvrez le terminal d’origine. Une liste JSON de vos abonnements doit s’afficher.
Copiez le champ id de l’abonnement que vous souhaitez utiliser.
Définissez votre abonnement à l’aide de la commande az account set.

Azure CLI
```
az account set --subscription <subscription_id>
```

Créer et déployer des ressources pour votre cluster

Pour déployer l’application, vous utilisez la commande azd up pour créer tous les objets requis pour exécuter l’application AKS Store.

Un fichier azure.yaml définit l’état souhaité d’un cluster, comme les images conteneur à extraire, et il 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.

Notes

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 pour des raisons de simplicité, mais nous vous recommandons d’utiliser des services managés, comme Azure CosmosDB ou Azure Service Bus.

Déployer des ressources d’application

Le modèle azd pour ce guide de démarrage rapide crée un groupe de ressources avec un cluster AKS et un coffre de clés Azure. Le coffre de clés stocke les clés secrètes client et exécute les services dans l’espace de noms pets.

Créez toutes les ressources d’application en tirant parti de la commande azd up.

Azure Developer CLI
```
azd up
```
azd up exécute tous les hooks dans le dossier azd-hooks pour préinscrire, approvisionner et déployer les services d’application.

Personnalisez les hooks en y ajoutant du code personnalisé dans les étapes du workflow azd. Pour plus d’informations, consultez les informations de référence sur les hooks azd.

Sélectionnez un abonnement Azure pour votre utilisation de la facturation.

Output

? Select an Azure Subscription to use:  [Use arrows to move, type to filter]
> 1. My Azure Subscription (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)

Sélectionnez une région vers laquelle déployer votre application.

Output

Select an Azure location to use:  [Use arrows to move, type to filter]
  1.  (South America) Brazil Southeast (brazilsoutheast)
  2.  (US) Central US (centralus)
  3.  (US) East US (eastus)
> 43. (US) East US 2 (eastus2)
  4.  (US) East US STG (eastusstg)
  5.  (US) North Central US (northcentralus)
  6.  (US) South Central US (southcentralus)

azd exécute automatiquement les hooks de préprovisionnement et de postprovisionnement pour créer les ressources de votre application. L’exécution de ce processus peut prendre plusieurs minutes. Une fois terminé, vous devez voir un résultat similaire à l’exemple suivant :

Output

SUCCESS: Your workflow to provision and deploy to Azure completed in 9 minutes 40 seconds.

Générer des plans Terraform

Dans votre modèle Azure Developer, le dossier /infra/terraform contient tout le code utilisé pour générer le plan Terraform.

Terraform déploie et exécute des commandes en utilisant terraform apply dans le cadre de l’étape d’approvisionnement de azd. Une fois terminé, vous devez voir un résultat similaire à l’exemple suivant :

Output

Plan: 5 to add, 0 to change, 0 to destroy.
...
Saved the plan to: /workspaces/aks-store-demo/.azure/aks-terraform-azd/infra/terraform/main.tfplan

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.

Définissez votre espace de noms comme espace de noms de version de démonstration pets en utilisant la commande kubectl set-context.

Console
```
kubectl config set-context --current --namespace=pets
```
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.

Console
```
kubectl get pods
```
Recherchez une adresse IP publique dans l’application store-front (vitrine) et monitorez la progression en tirant parti de la commande kubectl get service avec l’argument --watch.

Console
```
kubectl get service store-front --watch
```
La sortie EXTERNAL-IP pour le service store-front indique initialement qu'il est en attente :

Output
```
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 :

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

Une fois le démarrage rapide terminé, supprimez les ressources inutiles pour éviter les frais Azure.

Supprimez toutes les ressources créées dans le guide de démarrage rapide en utilisant la commande azd down.

Azure Developer CLI
```
azd down
```
Confirmez votre décision de supprimer toutes les ressources utilisées à partir de votre abonnement en tapant y et en appuyant sur Enter.

Output
```
? Total resources to delete: 14, are you sure you want to continue? (y/N)
```

Permettez à la suppression définitive de réutiliser les variables du démarrage rapide, le cas échéant, en tapant y et en appuyant sur Enter.

Output

[Warning]: These resources have soft delete enabled allowing them to be recovered for a period or time after deletion. During this period, their names can't be reused. In the future, you can use the argument --purge to skip this confirmation.

Résoudre les problèmes liés à Terraform sur Azure

Résoudre les problèmes courants liés à l’utilisation de Terraform sur Azure.

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

En savoir plus sur l’utilisation de AKS.

Remarque : L’auteur a créé cet article avec l’aide de l’IA. En savoir plus

Partager via

Démarrage rapide : Déployer un cluster Azure Kubernetes Service (AKS) en utilisant Terraform

Avant de commencer

Implémenter le code Terraform

Initialiser Terraform

Créer un plan d’exécution Terraform

Appliquer un plan d’exécution Terraform

Vérifier les résultats

Déployer l’application

Test de l’application

Nettoyer les ressources

Supprimer des ressources AKS

Suppression de principal de service

Cloner le modèle Azure Developer CLI

Connectez-vous à votre compte Azure Cloud

solution de contournement azd auth

Créer et déployer des ressources pour votre cluster

Déployer des ressources d’application

Générer des plans Terraform

Test de l’application

Supprimer le cluster

Résoudre les problèmes liés à Terraform sur Azure

Étapes suivantes

Ressources supplémentaires

Partager via

Démarrage rapide : Déployer un cluster Azure Kubernetes Service (AKS) en utilisant Terraform

Avant de commencer

Connexion à votre compte Azure

Implémenter le code Terraform

Initialiser Terraform

Créer un plan d’exécution Terraform

Appliquer un plan d’exécution Terraform

Vérifier les résultats

Déployer l’application

Test de l’application

Nettoyer les ressources

Supprimer des ressources AKS

Suppression de principal de service

Cloner le modèle Azure Developer CLI

Connectez-vous à votre compte Azure Cloud

solution de contournement azd auth

Créer et déployer des ressources pour votre cluster

Déployer des ressources d’application

Générer des plans Terraform

Test de l’application

Supprimer le cluster

Résoudre les problèmes liés à Terraform sur Azure

Étapes suivantes

Ressources supplémentaires