Démarrage rapide : Créer un cluster Kubernetes avec Azure Kubernetes Service à l’aide de Terraform

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 vous permet de déployer et de gérer des applications conteneurisées sans expertise d’orchestration de conteneurs. AKS vous permet également d’effectuer de nombreuses opérations de maintenance courantes sans mettre votre application hors connexion. Ces opérations incluent le provisionnement, la mise à niveau et la mise à l’échelle des ressources à la demande.

Dans cet article, vous apprendrez comment :

  • Utiliser HCL (HashiCorp Language) pour définir un cluster Kubernetes
  • Utiliser Terraform et AKS pour créer un cluster Kubernetes
  • Utiliser l’outil kubectl pour tester la disponibilité d’un cluster Kubernetes

Notes

L’exemple de code de cet article se trouve dans le dépôt GitHub Microsoft Terraform.

Prérequis

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

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 = ">=1.0"
    
      required_providers {
        azurerm = {
          source  = "hashicorp/azurerm"
          version = "~>3.0"
        }
        random = {
          source  = "hashicorp/random"
          version = "~>3.0"
        }
      }
    }
    
    provider "azurerm" {
      features {}
    }
    
  3. 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_id" "log_analytics_workspace_name_suffix" {
      byte_length = 8
    }
    
    resource "azurerm_log_analytics_workspace" "test" {
      location            = var.log_analytics_workspace_location
      # The WorkSpace name has to be unique across the whole of azure;
      # not just the current subscription/tenant.
      name                = "${var.log_analytics_workspace_name}-${random_id.log_analytics_workspace_name_suffix.dec}"
      resource_group_name = azurerm_resource_group.rg.name
      sku                 = var.log_analytics_workspace_sku
    }
    
    resource "azurerm_log_analytics_solution" "test" {
      location              = azurerm_log_analytics_workspace.test.location
      resource_group_name   = azurerm_resource_group.rg.name
      solution_name         = "ContainerInsights"
      workspace_name        = azurerm_log_analytics_workspace.test.name
      workspace_resource_id = azurerm_log_analytics_workspace.test.id
    
      plan {
        product   = "OMSGallery/ContainerInsights"
        publisher = "Microsoft"
      }
    }
    
    resource "azurerm_kubernetes_cluster" "k8s" {
      location            = azurerm_resource_group.rg.location
      name                = var.cluster_name
      resource_group_name = azurerm_resource_group.rg.name
      dns_prefix          = var.dns_prefix
      tags                = {
        Environment = "Development"
      }
    
      default_node_pool {
        name       = "agentpool"
        vm_size    = "Standard_D2_v2"
        node_count = var.agent_count
      }
      linux_profile {
        admin_username = "ubuntu"
    
        ssh_key {
          key_data = file(var.ssh_public_key)
        }
      }
      network_profile {
        network_plugin    = "kubenet"
        load_balancer_sku = "standard"
      }
      service_principal {
        client_id     = var.aks_service_principal_app_id
        client_secret = var.aks_service_principal_client_secret
      }
    }
    
  4. Créez un fichier nommé variables.tf et insérez le code suivant :

    variable "agent_count" {
      default = 3
    }
    
    # The following two variable declarations are placeholder references.
    # Set the values for these variable in terraform.tfvars
    variable "aks_service_principal_app_id" {
      default = ""
    }
    
    variable "aks_service_principal_client_secret" {
      default = ""
    }
    
    variable "cluster_name" {
      default = "k8stest"
    }
    
    variable "dns_prefix" {
      default = "k8stest"
    }
    
    # Refer to https://azure.microsoft.com/global-infrastructure/services/?products=monitor for available Log Analytics regions.
    variable "log_analytics_workspace_location" {
      default = "eastus"
    }
    
    variable "log_analytics_workspace_name" {
      default = "testLogAnalyticsWorkspaceName"
    }
    
    # Refer to https://azure.microsoft.com/pricing/details/monitor/ for Log Analytics pricing
    variable "log_analytics_workspace_sku" {
      default = "PerGB2018"
    }
    
    variable "resource_group_location" {
      default     = "eastus"
      description = "Location of the resource group."
    }
    
    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 "ssh_public_key" {
      default = "~/.ssh/id_rsa.pub"
    }
    
  5. Créez un fichier nommé outputs.tf et insérez le code suivant :

    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
    }
    
    output "resource_group_name" {
      value = azurerm_resource_group.rg.name
    }
    
  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>"
    

Initialiser Terraform

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

terraform init

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

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 -out paramètre, appelez terraform apply sans aucun paramètre.

Vérifier les résultats

  1. Obtenez le nom du groupe de ressources.

    echo "$(terraform output resource_group_name)"
    
  2. Accédez au portail Azure.

  3. Sous Services Azure, sélectionnez Groupes de ressources et recherchez votre nouveau groupe de ressources pour afficher les ressources suivantes créées dans cette démonstration :

    • Solution: Par défaut, la démonstration nomme cette solution ContainerInsights. Le portail affiche le nom de l’espace de travail de la solution entre parenthèses.
    • Service Kubernetes : Par défaut, la démonstration nomme ce service k8stest. (Un cluster Kubernetes managé est également appelé AKS / Azure Kubernetes Service.)
    • Espace de travail Log Analytics : Par défaut, la démonstration nomme cet espace de travail avec un préfixe de TestLogAnalyticsWorkspaceName, suivi d’un nombre aléatoire.
  4. Obtenez la configuration Kubernetes à partir de l’état Terraform et stockez-la dans un fichier que kubectl peut lire.

    echo "$(terraform output kube_config)" > ./azurek8s
    
  5. Vérifiez que la commande précédente n’a pas ajouté de caractère ASCII EOT.

    cat ./azurek8s
    

    Points essentiels :

    • Si vous voyez << EOT au début et EOT à la fin, supprimez ces caractères du fichier. Sinon, vous pouvez recevoir le message d’erreur suivant : error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context
  6. Définissez une variable d’environnement pour que kubectl choisisse la bonne configuration.

    export KUBECONFIG=./azurek8s
    
  7. Vérifiez l’intégrité du cluster.

    kubectl get nodes
    

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

Points essentiels :

  • Lorsque de la création du 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 clés ont été générées lorsque vous avez appliqué le plan d’exécution Terraform. Par exemple, l’adresse hôte, le nom d’utilisateur du cluster AKS et le mot de passe du cluster AKS sont générés.
  • Pour afficher toutes les valeurs de sortie, exécutez terraform output.
  • Pour afficher une valeur de sortie spécifique, exécutez echo "$(terraform output <output_value_name>)".

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 :

  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
    

Suppression de principal de service

Attention

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

  1. Exécutez az ad sp list pour obtenir l’ID d’objet du principal de service.

    az ad sp list --display-name "<display_name>" --query "[].{\"Object ID\":id}" --output table
    
    
  2. Exécutez az ad sp delete pour supprimer le principal de service.

    az ad sp delete --id <service_principal_object_id>
    

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