Créer un contrôleur d’entrée Application Gateway dans Azure Kubernetes Service à l’aide de Terraform

  • Article
  • 17 minutes pour lire

Article testé avec les versions de fournisseur Terraform et Terraform suivantes :

Terraform permet la définition, l’aperçu et le déploiement d’une infrastructure cloud. Terraform vous permet de créer des fichiers de configuration à l’aide de la syntaxe HCL. La syntaxe HCL vous permet de spécifier un fournisseur de services cloud, tel qu’Azure, et les éléments qui composent votre infrastructure cloud. Après avoir créé vos fichiers de configuration, vous créez un plan d’exécution qui vous permet d’afficher un aperçu de vos modifications d’infrastructure avant leur déploiement. Une fois que vous avez vérifié les modifications, vous appliquez le plan d’exécution pour déployer l’infrastructure.

Azure Kubernetes Service (AKS) gère votre environnement Kubernetes hébergé. AKS permet de déployer et de gérer rapidement et facilement des applications conteneurisées sans expertise d’orchestration de conteneurs. De même, AKS vous évite la contrainte de mettre les applications hors connexion pour les tâches opérationnelles et de maintenance. À l’aide d’AKS, vous pouvez effectuer des tâches telles que l’approvisionnement, la mise à niveau et la mise à l’échelle des ressources à la demande.

Un contrôleur d’entrée Application Gateway (AGIC) fournit différentes fonctionnalités pour les services Kubernetes. le proxy inversé, le routage configurable du trafic et l’arrêt TLS. Les ressources d’entrée Kubernetes sont utilisées pour configurer les règles d’entrée pour des services Kubernetes individuels. Un contrôleur d’entrée permet à une seule adresse IP d’acheminer le trafic vers plusieurs services dans un cluster Kubernetes. Toutes ces fonctionnalités sont fournies par Azure Application Gateway, ce qui en fait un contrôleur d’entrée idéal pour Kubernetes sur Azure.

Dans cet article, vous apprendrez à :

  • Créer un cluster Kubernetes à l’aide d’AKS avec Application Gateway comme contrôleur d’entrée
  • Définir un cluster Kubernetes
  • Créer une ressource Application Gateway
  • Créer un cluster Kubernetes
  • Tester la disponibilité d’un cluster Kubernetes

Notes

L’exemple de code de cet article se trouve dans le GitHub Microsoft Terraform.

1. Configurer votre environnement

  • Abonnement Azure : Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

  • Principal de service Azure : la démonstration nécessite un principal de service qui peut attribuer des rôles. Si vous disposez déjà d’un principal de service qui peut attribuer des rôles, vous pouvez utiliser ce principal de service. Si vous devez créer un principal de service, vous avez deux options :

    • Spécifiez le rôle « Propriétaire » lorsque vous créez un principal de service. Comme pratique recommandée, vous devez accorder le moindre privilège nécessaire pour effectuer un travail donné. Par conséquent, utilisez uniquement le rôle « Propriétaire » si le principal de service est destiné à être utilisé dans cette capacité.
    • Créez un rôle personnalisé et spécifiez ce rôle lorsque vous créez un principal de service.

    Vous aurez besoin des valeurs de principal de service suivantes pour le code de démonstration : appId, displayName, , passwordtenant.

  • ID d’objet du principal du service : Exécutez la commande az ad sp list --display-name "<display_name>" --query "[].{\"Object ID\":objectId}" --output table pour obtenir l’ID d’objet du principal de service.

  • Paire de clés SSH : utilisez l’un des articles suivants :

  • Installer Helm : Helm est le gestionnaire de package Kubernetes.

  • Installez GNU wget : vérifiez que vous avez accès à wget en exécutant wget n’importe quelle ligne de commande sans aucun paramètre. Vous pouvez installer wget à partir du site web wget de GNU officiel.

2. Configurer le stockage Azure pour stocker l’état de Terraform

Terraform suit l’état en local via le fichier terraform.tfstate. Ce modèle fonctionne bien dans un environnement comptant une seule personne. Cependant, dans un environnement à plusieurs personnes plus pratique, vous devez suivre l’état sur le serveur en utilisant le stockage Azure. Dans cette section, vous allez apprendre à récupérer les informations de compte de stockage nécessaires et à créer un conteneur de stockage. Les informations d’état de Terraform sont ensuite stockées dans ce conteneur.

  1. Utilisez l’une des options suivantes pour créer un compte de stockage Azure :

  2. Accédez au portail Azure.

  3. Sous Services Azure, sélectionnez Comptes de stockage. (Si l’option Comptes de stockage n’est pas visible dans la page principale, sélectionnez Plus de services pour la localiser.)

  4. Dans la page Comptes de stockage , dans la page Comptes de stockage, sélectionnez le compte de stockage dans lequel Terraform stockera les informations d’état.

  5. Dans la page Compte de stockage , dans le menu de gauche, dans la section Sécurité + mise en réseau , sélectionnez Clés d’accès.

    La page Compte de stockage dispose d’une option de menu pour obtenir les clés d’accès.

  6. Dans la page Clés d’accès , sélectionnez Afficher les clés pour afficher les valeurs de clé.

    La page Clés d’accès dispose d’une option permettant d’afficher les valeurs de clé.

  7. Recherchez la touchekey1 sur la page et sélectionnez l’icône à droite pour copier la valeur de la clé dans le Presse-papiers.

    Un bouton d’icône pratique vous permet de copier les valeurs de clé dans le Presse-papiers.

  8. À partir d’une invite de ligne de commande, exécutez az storage container create. Cette commande crée un conteneur dans votre compte de stockage Azure. Remplacez les espaces réservés par les valeurs appropriées pour votre compte de stockage Azure.

    az storage container create -n tfstate \
   --account-name <storage_account_name> \
   --account-key <storage_account_key>

  9. Une fois la commande terminée, elle affiche un bloc JSON avec la clé « created » et la valeur true. Vous pouvez également exécuter az storage container list pour vérifier que le conteneur a bien été créé.

    az storage container list \
   --account-name <storage_account_name> \
   --account-key <storage_account_key>

3. Implémenter le code Terraform

  1. Créez un répertoire dans lequel tester l’exemple de code Terraform et définissez-le comme répertoire actuel.

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

    terraform {

  required_version = ">=0.12"

  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>2.0"
    }
  }
  backend "azurerm" {
    resource_group_name  = "<storage_account_resource_group>"
    storage_account_name = "<storage_account_name>"
    container_name       = "tfstate"
    key                  = "codelab.microsoft.tfstate"
  }
}

provider "azurerm" {
  features {}
}

    Points essentiels :

    • Définissez resource_group_name sur le groupe de ressources du compte de stockage.
    • Définissez storage_account_name sur le nom du compte de stockage.

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

    resource "random_pet" "rg-name" {
  prefix = var.resource_group_name_prefix
}

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

# Locals block for hardcoded names
locals {
  backend_address_pool_name      = "${azurerm_virtual_network.test.name}-beap"
  frontend_port_name             = "${azurerm_virtual_network.test.name}-feport"
  frontend_ip_configuration_name = "${azurerm_virtual_network.test.name}-feip"
  http_setting_name              = "${azurerm_virtual_network.test.name}-be-htst"
  listener_name                  = "${azurerm_virtual_network.test.name}-httplstn"
  request_routing_rule_name      = "${azurerm_virtual_network.test.name}-rqrt"
  app_gateway_subnet_name        = "appgwsubnet"
}

# User Assigned Identities 
resource "azurerm_user_assigned_identity" "testIdentity" {
  resource_group_name = azurerm_resource_group.rg.name
  location            = azurerm_resource_group.rg.location

  name = "identity1"

  tags = var.tags
}

resource "azurerm_virtual_network" "test" {
  name                = var.virtual_network_name
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  address_space       = [var.virtual_network_address_prefix]

  subnet {
    name           = var.aks_subnet_name
    address_prefix = var.aks_subnet_address_prefix
  }

  subnet {
    name           = "appgwsubnet"
    address_prefix = var.app_gateway_subnet_address_prefix
  }

  tags = var.tags
}

data "azurerm_subnet" "kubesubnet" {
  name                 = var.aks_subnet_name
  virtual_network_name = azurerm_virtual_network.test.name
  resource_group_name  = azurerm_resource_group.rg.name
  depends_on           = [azurerm_virtual_network.test]
}

data "azurerm_subnet" "appgwsubnet" {
  name                 = "appgwsubnet"
  virtual_network_name = azurerm_virtual_network.test.name
  resource_group_name  = azurerm_resource_group.rg.name
  depends_on           = [azurerm_virtual_network.test]
}

# Public Ip 
resource "azurerm_public_ip" "test" {
  name                = "publicIp1"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  allocation_method   = "Static"
  sku                 = "Standard"

  tags = var.tags
}

resource "azurerm_application_gateway" "network" {
  name                = var.app_gateway_name
  resource_group_name = azurerm_resource_group.rg.name
  location            = azurerm_resource_group.rg.location

  sku {
    name     = var.app_gateway_sku
    tier     = "Standard_v2"
    capacity = 2
  }

  gateway_ip_configuration {
    name      = "appGatewayIpConfig"
    subnet_id = data.azurerm_subnet.appgwsubnet.id
  }

  frontend_port {
    name = local.frontend_port_name
    port = 80
  }

  frontend_port {
    name = "httpsPort"
    port = 443
  }

  frontend_ip_configuration {
    name                 = local.frontend_ip_configuration_name
    public_ip_address_id = azurerm_public_ip.test.id
  }

  backend_address_pool {
    name = local.backend_address_pool_name
  }

  backend_http_settings {
    name                  = local.http_setting_name
    cookie_based_affinity = "Disabled"
    port                  = 80
    protocol              = "Http"
    request_timeout       = 1
  }

  http_listener {
    name                           = local.listener_name
    frontend_ip_configuration_name = local.frontend_ip_configuration_name
    frontend_port_name             = local.frontend_port_name
    protocol                       = "Http"
  }

  request_routing_rule {
    name                       = local.request_routing_rule_name
    rule_type                  = "Basic"
    http_listener_name         = local.listener_name
    backend_address_pool_name  = local.backend_address_pool_name
    backend_http_settings_name = local.http_setting_name
  }

  tags = var.tags

  depends_on = [azurerm_virtual_network.test, azurerm_public_ip.test]
}

resource "azurerm_role_assignment" "ra1" {
  scope                = data.azurerm_subnet.kubesubnet.id
  role_definition_name = "Network Contributor"
  principal_id         = var.aks_service_principal_object_id

  depends_on = [azurerm_virtual_network.test]
}

resource "azurerm_role_assignment" "ra2" {
  scope                = azurerm_user_assigned_identity.testIdentity.id
  role_definition_name = "Managed Identity Operator"
  principal_id         = var.aks_service_principal_object_id
  depends_on           = [azurerm_user_assigned_identity.testIdentity]
}

resource "azurerm_role_assignment" "ra3" {
  scope                = azurerm_application_gateway.network.id
  role_definition_name = "Contributor"
  principal_id         = azurerm_user_assigned_identity.testIdentity.principal_id
  depends_on           = [azurerm_user_assigned_identity.testIdentity, azurerm_application_gateway.network]
}

resource "azurerm_role_assignment" "ra4" {
  scope                = azurerm_resource_group.rg.id
  role_definition_name = "Reader"
  principal_id         = azurerm_user_assigned_identity.testIdentity.principal_id
  depends_on           = [azurerm_user_assigned_identity.testIdentity, azurerm_application_gateway.network]
}

resource "azurerm_kubernetes_cluster" "k8s" {
  name       = var.aks_name
  location   = azurerm_resource_group.rg.location
  dns_prefix = var.aks_dns_prefix

  resource_group_name = azurerm_resource_group.rg.name

  http_application_routing_enabled = false

  linux_profile {
    admin_username = var.vm_user_name

    ssh_key {
      key_data = file(var.public_ssh_key_path)
    }
  }

  default_node_pool {
    name            = "agentpool"
    node_count      = var.aks_agent_count
    vm_size         = var.aks_agent_vm_size
    os_disk_size_gb = var.aks_agent_os_disk_size
    vnet_subnet_id  = data.azurerm_subnet.kubesubnet.id
  }

  service_principal {
    client_id     = var.aks_service_principal_app_id
    client_secret = var.aks_service_principal_client_secret
  }

  network_profile {
    network_plugin     = "azure"
    dns_service_ip     = var.aks_dns_service_ip
    docker_bridge_cidr = var.aks_docker_bridge_cidr
    service_cidr       = var.aks_service_cidr
  }

  role_based_access_control {
    enabled = var.aks_enable_rbac
  }

  depends_on = [azurerm_virtual_network.test, azurerm_application_gateway.network]
  tags       = var.tags
}

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

    variable "resource_group_name_prefix" {
  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 "resource_group_location" {
  default     = "eastus"
  description = "Location of the resource group."
}

variable "aks_service_principal_app_id" {
  description = "Application ID/Client ID  of the service principal. Used by AKS to manage AKS related resources on Azure like vms, subnets."
}

variable "aks_service_principal_client_secret" {
  description = "Secret of the service principal. Used by AKS to manage Azure."
}

variable "aks_service_principal_object_id" {
  description = "Object ID of the service principal."
}

variable "virtual_network_name" {
  description = "Virtual network name"
  default     = "aksVirtualNetwork"
}

variable "virtual_network_address_prefix" {
  description = "VNET address prefix"
  default     = "192.168.0.0/16"
}

variable "aks_subnet_name" {
  description = "Subnet Name."
  default     = "kubesubnet"
}

variable "aks_subnet_address_prefix" {
  description = "Subnet address prefix."
  default     = "192.168.0.0/24"
}

variable "app_gateway_subnet_address_prefix" {
  description = "Subnet server IP address."
  default     = "192.168.1.0/24"
}

variable "app_gateway_name" {
  description = "Name of the Application Gateway"
  default     = "ApplicationGateway1"
}

variable "app_gateway_sku" {
  description = "Name of the Application Gateway SKU"
  default     = "Standard_v2"
}

variable "app_gateway_tier" {
  description = "Tier of the Application Gateway tier"
  default     = "Standard_v2"
}

variable "aks_name" {
  description = "AKS cluster name"
  default     = "aks-cluster1"
}
variable "aks_dns_prefix" {
  description = "Optional DNS prefix to use with hosted Kubernetes API server FQDN."
  default     = "aks"
}

variable "aks_agent_os_disk_size" {
  description = "Disk size (in GB) to provision for each of the agent pool nodes. This value ranges from 0 to 1023. Specifying 0 applies the default disk size for that agentVMSize."
  default     = 40
}

variable "aks_agent_count" {
  description = "The number of agent nodes for the cluster."
  default     = 3
}

variable "aks_agent_vm_size" {
  description = "VM size"
  default     = "Standard_D3_v2"
}

variable "kubernetes_version" {
  description = "Kubernetes version"
  default     = "1.11.5"
}

variable "aks_service_cidr" {
  description = "CIDR notation IP range from which to assign service cluster IPs"
  default     = "10.0.0.0/16"
}

variable "aks_dns_service_ip" {
  description = "DNS server IP address"
  default     = "10.0.0.10"
}

variable "aks_docker_bridge_cidr" {
  description = "CIDR notation IP for Docker bridge."
  default     = "172.17.0.1/16"
}

variable "aks_enable_rbac" {
  description = "Enable RBAC on the AKS cluster. Defaults to false."
  default     = "false"
}

variable "vm_user_name" {
  description = "User name for the VM"
  default     = "vmuser1"
}

variable "public_ssh_key_path" {
  description = "Public key path for SSH."
  default     = "~/.ssh/id_rsa.pub"
}

variable "tags" {
  type = map(string)

  default = {
    source = "terraform"
  }
}

  5. Créez un fichier nommé output.tf et insérez le code suivant.

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

output "client_key" {
  value = azurerm_kubernetes_cluster.k8s.kube_config.0.client_key
}

output "client_certificate" {
  value = azurerm_kubernetes_cluster.k8s.kube_config.0.client_certificate
}

output "cluster_ca_certificate" {
  value = azurerm_kubernetes_cluster.k8s.kube_config.0.cluster_ca_certificate
}

output "cluster_username" {
  value = azurerm_kubernetes_cluster.k8s.kube_config.0.username
}

output "cluster_password" {
  value = azurerm_kubernetes_cluster.k8s.kube_config.0.password
}

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

output "host" {
  value = azurerm_kubernetes_cluster.k8s.kube_config.0.host
}

output "identity_resource_id" {
  value = azurerm_user_assigned_identity.testIdentity.id
}

output "identity_client_id" {
  value = azurerm_user_assigned_identity.testIdentity.client_id
}

output "application_ip_address" {
  value = azurerm_public_ip.test.ip_address
}

  6. Créez un fichier nommé terraform.tfvars et insérez le code suivant.

    aks_service_principal_app_id = "<service_principal_app_id>"

aks_service_principal_client_secret = "<service_principal_password>"

aks_service_principal_object_id = "<service_principal_object_id>"

    Points essentiels :

    • Définissez aks_service_principal_app_id sur la valeur du principal appId de service.
    • Définissez aks_service_principal_client_secret sur la valeur du principal password de service.
    • Définissez aks_service_principal_object_id sur l’ID d’objet du principal de service. (La commande Azure CLI permettant d’obtenir cette valeur se trouve dans la section Configurer votre environnement .)

4. 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 -upgrade paramètre 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.

5. 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é.
  • Pour en savoir plus sur la persistance des plans d’exécution et de la sécurité, consultez la section d’avertissement de sécurité.

6. 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 terraform apply ci-dessus 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.

7. Vérifier les résultats : Tester le cluster Kubernetes

Les outils Kubernetes peuvent être utilisés pour vérifier le cluster nouvellement créé.

  1. Exécutez az aks get-credentials pour obtenir la configuration Kubernetes et accéder aux informations d’identification à partir d’Azure.

    az aks get-credentials --name <aks_cluster_name>  \
   --resource-group <resource_group_name> \
   --overwrite-existing

    Points essentiels :

    • Remplacez l’espace <aks_cluster_name> réservé par la aks_name valeur du default bloc (à partir du variables.tf fichier).
    • Remplacez l’espace <resource_group_name> réservé par le nom du groupe de ressources généré de manière aléatoire. Obtenez le nom du groupe de ressources en exécutant echo "$(terraform output resource_group_name)".

  2. Vérifiez l’intégrité du cluster.

    kubectl get nodes

    Points essentiels :

    • Les détails de vos nœuds Worker sont affichés avec l’état Prêt.

    L’outil kubectl vous permet de vérifier l’intégrité de votre cluster Kubernetes

8. Installer Azure AD Pod Identity

Azure Active Directory Pod Identity offre un accès à base de jeton à Azure Resource Manager.

Azure AD Pod Identity ajoute les composants suivants à votre cluster Kubernetes :

Pour installer Azure AD Pod Identity sur votre cluster, vous devez savoir si RBAC est activé ou désactivé. RBAC est désactivé par défaut pour cette démonstration. L’activation ou la désactivation du RBAC s’effectue dans le variables.tf fichier via la aks_enable_rbac valeur du default bloc.

  • Si RBAC est activé, exécutez la commande suivante :

    kubectl create -f https://raw.githubusercontent.com/Azure/aad-pod-identity/master/deploy/infra/deployment-rbac.yaml

  • Si RBAC est désactivé, exécutez la commande suivante :

    kubectl create -f https://raw.githubusercontent.com/Azure/aad-pod-identity/master/deploy/infra/deployment.yaml

9. Installer Helm

Utilisez Helm pour installer le application-gateway-kubernetes-ingress package :

  1. Exécutez les commandes helm suivantes pour ajouter le dépôt Helm AGIC.

    helm repo add application-gateway-kubernetes-ingress https://appgwingress.blob.core.windows.net/ingress-azure-helm-package/

  2. Mettez à jour le dépôt Helm AGIC.

    helm repo update

10. Installer AGIC Helm Chart

  1. Téléchargez helm-config.yaml pour configurer AGIC. (Si vous n’avez pas accès à wget, consultez la section Configurer votre environnement .)

    wget https://raw.githubusercontent.com/Azure/application-gateway-kubernetes-ingress/master/docs/examples/sample-helm-config.yaml -O helm-config.yaml

  2. Ouvrez le fichier helm-config.yaml dans un éditeur de texte.

  3. Entrez des valeurs pour les clés de niveau supérieur.

  4. Entrez les valeurs du appgw bloc.

    • appgw.subscriptionId: spécifiez l’ID d’abonnement Azure utilisé pour créer la passerelle App Gateway.
    • appgw.resourceGroup: spécifiez le nom du groupe de ressources généré de manière aléatoire. Obtenir le nom du groupe de ressources en exécutant echo "$(terraform output resource_group_name)"
    • appgw.name: spécifiez le nom du Application Gateway. Cette valeur est définie dans le variables.tf fichier via la app_gateway_name valeur du default bloc.
    • appgw.shared: cet indicateur booléen est défini par défaut sur false. Définissez-la sur true si vous avez besoin d’une passerelle d’application partagée.

  5. Entrez les valeurs du kubernetes bloc.

    • kubernetes.watchNamespace: spécifiez l’espace de noms que doit observer AGIC. L’espace de noms peut être une valeur de chaîne unique ou une liste d’espaces de noms séparés par des virgules. Si vous laissez cette variable commentée ou si vous la définissez sur une chaîne vide ou vide, le contrôleur d’entrée observe tous les espaces de noms accessibles.

  6. Entrez les valeurs du armAuth bloc.

    • Si vous spécifiez armAuth.type comme aadPodIdentity:

      • armAuth.identityResourceID: obtenez l’ID de ressource d’identité en exécutant echo "$(terraform output identity_resource_id)".
      • armAuth.identityClientId: obtenez l’ID client d’identité en exécutant echo "$(terraform output identity_client_id)".

    • Si vous spécifiez armAuth.type comme servicePrincipal, consultez Utilisation d’un principal de service.

  7. Installez le package de contrôleur d’entrée Application Gateway :

    helm install -f helm-config.yaml application-gateway-kubernetes-ingress/ingress-azure --generate-name

  8. Pour obtenir les valeurs de clé de votre identité, vous pouvez exécuter az identity show .

    az identity show -g <resource_group_name> -n <identity_name>

    Points essentiels :

    • Remplacez l’espace <resource_group_name> réservé par le nom du groupe de ressources généré de manière aléatoire. Obtenez le nom du groupe de ressources en exécutant echo "$(terraform output resource_group_name)".
    • Remplacez l’espace <identity_name> réservé par le nom d’identité de cette démonstration. Le nom d’identité identity1 est défini par défaut dans le main.tf fichier.
    • Toutes les identités d’un abonnement donné peuvent être en exécutant az identity list.

11. Installer un exemple d’application

Une fois que vous avez installé App Gateway, AKS et AGIC, vous pouvez installer un exemple d’application.

  1. Utilisez la commande curl pour télécharger le fichier YAML :

    curl https://raw.githubusercontent.com/Azure/application-gateway-kubernetes-ingress/master/docs/examples/aspnetapp.yaml -o aspnetapp.yaml

  2. Appliquez le fichier YAML :

    kubectl apply -f aspnetapp.yaml

12. Vérifier les résultats : Tester l’exemple d’application

  1. Exécutez la commande Terraform suivante pour obtenir l’adresse IP de l’application.

    echo "$(terraform output application_ip_address)"

  2. À l’aide d’un navigateur, accédez à l’adresse IP indiquée à l’étape précédente.

    Exécution de l’exemple d’application.

13. Nettoyer les ressources

Supprimer des ressources App Gateway, AKS et AGIC

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

  1. 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é.
    • Pour en savoir plus sur la persistance des plans d’exécution et de la sécurité, consultez la section d’avertissement de sécurité.

  2. Exécutez terraform apply pour appliquer le plan d’exécution.

    terraform apply main.destroy.tfplan

Supprimer un compte de stockage

Attention

Supprimez uniquement le groupe de ressources contenant le compte de stockage que vous avez utilisé dans cette démonstration si vous n’utilisez pas l’un ou l’autre pour autre chose.

Exécutez az group delete pour supprimer le groupe de ressources (et son compte de stockage que vous avez utilisé dans cette démonstration).

az group delete --name <storage_resource_group_name> --yes

Points essentiels :

  • Remplacez l’espace storage_resource_group_name réservé par la resource_group_name valeur dans le providers.tf fichier.

Suppression de principal de service

Attention

Supprimez uniquement le principal de service que vous avez utilisé dans cette démonstration si vous ne l’utilisez pas pour autre chose.

az ad sp delete --id <service_principal_object_id>

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

Si vous recevez une « erreur 403 » lors de l’application du plan d’exécution Terraform pendant l’attribution de rôle, cela signifie généralement que votre rôle de principal de service n’inclut pas l’autorisation d’attribuer des rôles dans Azure RBAC. Pour plus d’informations sur les rôles intégrés, consultez Rôles intégrés Azure. Les options suivantes vous permettent de résoudre l’erreur :

  • Créez le principal de service avec le rôle « Propriétaire ». Comme pratique recommandée, vous devez accorder le privilège minimum nécessaire pour effectuer un travail donné. Par conséquent, utilisez uniquement le rôle « Propriétaire » si le principal de service est destiné à être utilisé dans cette capacité.
  • Créez un rôle personnalisé basé sur le rôle souhaité, par exemple Contributeur. Selon le rôle de base que vous utilisez, ajoutez l’action Microsoft.Authorization/*/Write au Actions bloc ou supprimez-la NotActions du bloc. Pour plus d’informations sur les rôles personnalisés, consultez Rôles personnalisés Azure.

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

Étapes suivantes

Contrôleur d’entrée Application Gateway