Démarrage rapide : Déployer un cluster Azure Kubernetes Service (AKS) en utilisant Terraform
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.
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).
- 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.
Remarque
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.
Connexion à votre compte Azure
Tout d’abord, connectez-vous à votre compte Azure et authentifiez-vous en utilisant une des méthodes décrites dans la section suivante.
Scénarios d’authentification Terraform et Azure
Terraform prend uniquement en charge l’authentification sur Azure par le biais d’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 en utilisant Azure CLI.
Cet article explique comment authentifier Terraform auprès d’Azure pour les scénarios suivants. Pour plus d’informations sur les options d’authentification de Terraform auprès d’Azure, consultez Authentification à l’aide d’Azure CLI.
- S’authentifier par le biais d’un compte Microsoft à l’aide de Cloud Shell (avec Bash ou PowerShell)
- S’authentifier par le biais d’un compte Microsoft à l’aide de Windows (avec Bash ou PowerShell)
- S’authentifier par le biais d’un principal de service :
- Si vous n’avez pas de principal de service, créez-en un.
- Authentifiez-vous auprès d’Azure en utilisant des variables d’environnement ou en utilisant le bloc provider Terraform.
S’authentifier auprès d’Azure par le biais d’un compte Microsoft
Un compte Microsoft est un nom d’utilisateur (associé à une adresse e-mail et ses informations d’identification) utilisé pour se connecter aux services Microsoft, comme Azure. Un compte Microsoft peut être associé à un ou plusieurs abonnements Azure, l’un d’entre eux étant celui par défaut.
Pour cela, procédez comme suit :
- Se connecter à Azure de manière interactive avec un compte Microsoft
- Répertorier les abonnements Azure associés au compte (y compris la valeur par défaut)
- Définissez l'abonnement actif.
Ouvrez une ligne de commande qui a accès à Azure CLI.
Exécutez az login sans aucun paramètre et suivez les instructions pour vous connecter à Azure.
az login
Points essentiels :
- Une fois la connexion établie,
az login
affiche la liste des abonnements Azure associés au compte Microsoft connecté, y compris l’abonnement par défaut.
- Une fois la connexion établie,
Pour confirmer l’abonnement Azure actuel, exécutez az account show.
az account show
Pour voir tous les noms et ID d’abonnement Azure d’un compte Microsoft spécifique, exécutez az account list.
az account list --query "[?user.name=='<microsoft_account_email>'].{Name:name, ID:id, Default:isDefault}" --output Table
Points essentiels :
- Remplacez l’espace réservé
<microsoft_account_email>
par l’adresse e-mail du compte Microsoft dont vous voulez lister les abonnements Azure. - Avec un compte Live (comme Hotmail ou Outlook), vous aurez peut-être besoin de spécifier l’adresse e-mail complète. Par exemple, si votre adresse e-mail est
admin@hotmail.com
, vous aurez peut-être besoin de remplacer l’espace réservé parlive.com#admin@hotmail.com
.
- Remplacez l’espace réservé
Pour utiliser un abonnement Azure spécifique, exécutez az account set.
az account set --subscription "<subscription_id_or_subscription_name>"
Points essentiels :
- Remplacez l’espace réservé
<subscription_id_or_subscription_name>
par l’ID (ou le nom) de l’abonnement que vous voulez utiliser. - L’appel de
az account set
n’affiche pas les résultats du basculement vers l’abonnement Azure spécifié. Toutefois, vous pouvez utiliseraz account show
pour confirmer que l’abonnement Azure actuel a changé. - Si vous exécutez la commande
az account list
de l’étape précédente, vous pouvez voir que l’abonnement Azure par défaut a été remplacé par l’abonnement que vous avez spécifié avecaz account set
.
- Remplacez l’espace réservé
Créer un principal du service
Les outils automatisés qui déploient ou utilisent des services Azure, tels que Terraform, doivent toujours avoir des autorisations restreintes. Au lieu que les applications se connectent en tant qu’utilisateur entièrement privilégié, Azure propose des principaux de service.
La procédure la plus courante consiste à se connecter de manière interactive à Azure, à créer un principal de service, à tester ce principal de service, puis à l’utiliser à des fins d’authentification ultérieure (soit de manière interactive, soit à partir de vos scripts).
Pour créer un principal de service, connectez-vous à Azure. Après vous être authentifié auprès d’Azure par le biais d’un compte Microsoft, revenez ici.
Si vous créez un principal de service à partir de Git Bash, définissez la variable d’environnement
MSYS_NO_PATHCONV
. (Cette étape n’est pas nécessaire si vous utilisez Cloud Shell.)export MSYS_NO_PATHCONV=1
Points essentiels :
- Vous pouvez définir la variable d’environnement
MSYS_NO_PATHCONV
globalement (pour toutes les sessions de terminal) ou localement (uniquement pour la session active). Puisque la création d’un principal de service n’est pas une opération fréquente, l’exemple définit la valeur pour la session active. Pour définir cette variable d’environnement globalement, ajoutez le paramètre au fichier~/.bashrc
.
- Vous pouvez définir la variable d’environnement
Pour créer un principal de service, exécutez az ad sp create-for-rbac.
az ad sp create-for-rbac --name <service_principal_name> --role Contributor --scopes /subscriptions/<subscription_id>
Points essentiels :
- Vous pouvez remplacer
<service-principal-name>
par un nom personnalisé pour votre environnement ou omettre complètement le paramètre. Si vous omettez le paramètre, le nom du principal de service est généré en fonction de la date et de l’heure actuelles. - À la fin de l’opération,
az ad sp create-for-rbac
affiche plusieurs valeurs. Les valeursappId
,password
ettenant
sont utilisées à l’étape suivante. - Le mot de passe ne peut pas être récupéré en cas de perte. Par conséquent, vous devez conserver votre mot de passe en lieu sûr. Si vous oubliez votre mot de passe, vous pouvez réinitialiser les informations d’identification du principal de service.
- Pour cet article, un principal de service doté d’un rôle Contributeur est utilisé. Pour plus d’informations sur les rôles de contrôle d’accès en fonction du rôle, consultez RBAC : rôles intégrés.
- La sortie de la création du principal de service comprend des informations d’identification sensibles. Veillez à ne pas inclure ces informations d’identification dans votre code ou vérifiez les informations d’identification dans votre contrôle de code source.
- Pour plus d’informations sur les options lors de la création d’un principal de service avec Azure CLI, consultez l’article Créer un principal de service Azure avec Azure CLI.
- Vous pouvez remplacer
Spécifier les informations d’identification du principal de service dans des variables d’environnement
Une fois que vous avez créé un principal de service, vous pouvez spécifier ses informations d’identification pour Terraform par le biais de variables d’environnement.
Modifiez le fichier
~/.bashrc
en ajoutant les variables d’environnement suivantes.export ARM_SUBSCRIPTION_ID="<azure_subscription_id>" export ARM_TENANT_ID="<azure_subscription_tenant_id>" export ARM_CLIENT_ID="<service_principal_appid>" export ARM_CLIENT_SECRET="<service_principal_password>"
Pour exécuter le script
~/.bashrc
, exécutezsource ~/.bashrc
(ou son équivalent abrégé. ~/.bashrc
). Vous pouvez aussi quitter et rouvrir Cloud Shell pour que le script s’exécute automatiquement.. ~/.bashrc
Une fois les variables d’environnement définies, vous pouvez vérifier leurs valeurs comme suit :
printenv | grep ^ARM*
Points essentiels :
- Comme pour toute variable d’environnement, pour accéder à une valeur d’abonnement Azure à partir d’un script Terraform, utilisez la syntaxe suivante :
${env.<environment_variable>}
. Par exemple, pour accéder à la valeurARM_SUBSCRIPTION_ID
, spécifiez${env.ARM_SUBSCRIPTION_ID}
. - La création et l’application de plans d’exécution Terraform apportent des modifications à l’abonnement Azure associé au principal de service. Cela peut parfois prêter à confusion si vous êtes connecté à un abonnement Azure et que les variables d’environnement pointent vers un autre abonnement Azure. Examinons l’exemple suivant pour mieux comprendre. Supposons que vous avez deux abonnements Azure : AboA et AboB. Si l’abonnement Azure actif est AboA (déterminé par le biais de la commande
az account show
) alors que les variables d’environnement pointent vers AboB, toutes les modifications apportées par Terraform le sont sur AboB. Vous avez donc besoin de vous connecter à votre abonnement AboB pour exécuter des commandes Azure CLI ou Azure PowerShell afin de voir vos modifications.
Spécifier les informations d’identification du principal de service dans un bloc provider Terraform
Le bloc provider Azure définit la syntaxe qui vous permet de spécifier les informations d’authentification de votre abonnement Azure.
terraform {
required_providers {
azurerm = {
source = "hashicorp/azurerm"
version = "~>2.0"
}
}
}
provider "azurerm" {
features {}
subscription_id = "<azure_subscription_id>"
tenant_id = "<azure_subscription_tenant_id>"
client_id = "<service_principal_appid>"
client_secret = "<service_principal_password>"
}
# Your code goes here
Attention
La possibilité de spécifier les informations d’identification de votre abonnement Azure dans un fichier de configuration Terraform peut s’avérer pratique, notamment dans le cadre de tests. Toutefois, il n’est pas recommandé de stocker des informations d’identification dans un fichier en texte clair, celui-ci pouvant être lu par des personnes non approuvées.
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 { 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 :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 = jsondecode(azapi_resource_action.ssh_public_key_gen.output).publicKey }
Créez un fichier nommé
main.tf
et insérez le code suivant :# 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 = jsondecode(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 :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 :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.
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.
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.
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
, appelezterraform apply
sans aucun paramètre.
Vérifier les résultats
Obtenez le nom du groupe de ressources Azure à l’aide de la commande suivante.
resource_group_name=$(terraform output -raw resource_group_name)
Affichez le nom de votre nouveau cluster Kubernetes en utilisant la commande az aks list.
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.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.
cat ./azurek8s
Points essentiels :
- Si vous voyez
<< EOT
au début etEOT
à 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
- Si vous voyez
Définissez une variable d’environnement de sorte que
kubectl
choisisse la configuration appropriée en utilisant la commande suivante.export KUBECONFIG=./azurek8s
Vérifiez l’intégrité du cluster à l’aide de la commande
kubectl get nodes
.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.
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
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.
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.
Vérifiez l'état des pods déployés à l'aide de la commande
kubectl get pods
. Assurez-vous que tous les pods sontRunning
avant de continuer.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
.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 surveillancekubectl
.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.
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
.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é.
- La commande
Exécutez terraform apply pour appliquer le plan d’exécution.
terraform apply main.destroy.tfplan
Suppression de principal de service
Obtenez l’identifiant du principal de service en utilisant la commande suivante.
sp=$(terraform output -raw sp)
Supprimez le principal de service en utilisant la commande az ad sp delete.
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
.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.
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
.azd auth login
Copiez le code d’appareil qui s’affiche dans la sortie, puis appuyez sur entrée pour vous connecter.
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êtecurl
à l’URL localhost vers laquelle vous avez été redirigé après l’exécution deazd 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.
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 surhttps://graph.microsoft.com/.default
.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 :
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.curl <localhost>
Une connexion réussie sort une page web HTML comme illustré dans l’exemple suivant :
<!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
.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.
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 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
.azd up
azd up
exécute tous les hooks dans le dossierazd-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 hooksazd
.Sélectionnez un abonnement Azure pour votre utilisation de la facturation.
? 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.
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 :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 :
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 commandekubectl set-context
.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 sontRunning
avant de continuer.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
.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 surveillancekubectl
.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
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
.azd down
Confirmez votre décision de supprimer toutes les ressources utilisées à partir de votre abonnement en tapant
y
et en appuyant surEnter
.? 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 surEnter
.[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.