Démarrage rapide : Déployer un cluster Hôte de conteneur Azure Linux pour AKS en utilisant Terraform

Article
10/16/2024

Démarrez avec l’hôte de conteneur Azure Linux pour AKS en utilisant Terraform pour déployer un cluster hôte de conteneur Azure Linux. Après avoir installé les éléments prérequis, implémentez le code Terraform, initialisez Terraform, puis créez et appliquez un plan d’exécution Terraform.

Terraform permet la définition, l’aperçu et le déploiement d’une infrastructure cloud. Avec Terraform, vous créez des fichiers de configuration avec la syntaxe HCL. La syntaxe HCL vous permet de spécifier le fournisseur de services cloud et les éléments qui constituent 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.

Notes

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

Prérequis

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit Azure avant de commencer.
Si vous n’avez pas encore configuré Terraform, vous pouvez le faire en choisissant l’une des options suivantes :
Si vous n’avez pas de principal de service Azure, créez-en un. Notez les valeurs de appId, display_name, password et tenant.
Vous avez besoin de l’outil en ligne de commande Kubernetes kubectl. Si vous ne l’avez pas, téléchargez kubectl.

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

Pour accéder aux nœuds AKS, vous vous connectez à l’aide d’une paire de clés SSH (publique et privée), que vous générez à l’aide de la commande ssh-keygen. Par défaut, ces fichiers sont créés dans le répertoire ~/.ssh. L’exécution de la commande ssh-keygen remplace toute paire de clés SSH portant le même nom qui existe déjà dans l’emplacement donné.

Accédez à https://shell.azure.com pour ouvrir Cloud Shell dans votre navigateur.
Exécutez la commande ssh-keygen. L’exemple suivant crée une paire de clés SSH à l’aide du chiffrement RSA avec une longueur de 4096 bits :
```
ssh-keygen -t rsa -b 4096
```

Pour plus d’informations sur la création de clés SSH, consultez Créer et gérer les clés SSH pour l’authentification dans Azure.

Implémenter le code Terraform

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

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 {}
    }

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       = "azurelinuxpool"
        vm_size    = "Standard_D2_v2"
        node_count = var.agent_count
        os_sku = "AzureLinux"
      }
      linux_profile {
        admin_username = "azurelinux"

        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
      }
    }

De même, vous pouvez spécifier l’élément os_sku d’Azure Linux dans azurerm_kubernetes_cluster_node_pool.

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"
    }

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
    }

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 et créer un plan d’exécution

Initialisez Terraform et téléchargez les modules Azure dont vous avez besoin pour gérer vos ressources Azure en utilisant la commande terraform init.
```
terraform init
```
Créez un plan d’exécution Terraform à l’aide de la commande terraform plan.
```
terraform plan -out main.tfplan
```
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 les plans d’exécution persistants et la sécurité, consultez les avertissements de sécurité.
Appliquez le plan d’exécution Terraform à l’aide de la commande terraform apply.
```
terraform apply main.tfplan
```
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.

Vérifier les résultats

Obtenez le nom du groupe de ressources à l’aide de la commande echo suivante.
```
echo "$(terraform output resource_group_name)"
```
Accédez au portail Azure.
Sous Services Azure, sélectionnez Groupes de ressources et recherchez votre nouveau groupe de ressources pour voir si les ressources suivantes ont bien été créées dans cette démo :
- Solution : Par défaut, la démo nomme cette solution ContainerInsights. Le portail affiche le nom d’espace de travail de la solution entre parenthèses.
- Service Kubernetes : Par défaut, la démo 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émo nomme cet espace de travail avec le préfixe TestLogAnalyticsWorkspaceName- suivi d’un nombre aléatoire.
Obtenez la configuration Kubernetes à partir de l’état Terraform et stockez-la dans un fichier que kubectl peut lire en utilisant la commande echo.
```
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 cat suivante.
```
cat ./azurek8s
```
Si vous voyez << EOT au début et EOT à la fin, supprimez ces caractères du fichier. Sinon, vous risquez d’obtenir le message d’erreur suivant : 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 export suivante.
```
export KUBECONFIG=./azurek8s
```
Vérifiez l’intégrité du cluster à l’aide de la commande kubectl get nodes.
```
kubectl get nodes
```
Lorsque le cluster Hôte de conteneur Azure Linux a été créé, la supervision a été activée pour capturer les métriques d’intégrité pour les nœuds du 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é générées lorsque vous avez appliqué le plan d’exécution Terraform. Par exemple, l’adresse de l’hôte, le nom d’utilisateur du cluster Hôte de conteneur Azure Linux et le mot de passe du cluster Hôte de conteneur Azure Linux Container sont générés.

Pour afficher toutes les valeurs de sortie, exécutez terraform output. Pour afficher une valeur de sortie en particulier, exécutez echo "$(terraform output <output_value_name>)".

Nettoyer les ressources

Supprimer des ressources AKS

Lorsque vous n’avez plus besoin des ressources créées avec Terraform, vous pouvez les supprimer en effectuant les étapes suivantes.

Exécutez la commande terraform plan et spécifiez l’indicateur destroy.
```
terraform plan -destroy -out main.destroy.tfplan
```
Supprimez le plan d’exécution à l’aide de la commande terraform apply.
```
terraform apply main.destroy.tfplan
```

Suppression de principal de service

Attention

Ne supprimez le principal de service que vous avez utilisé dans cette démo que si vous n’en avez pas l’utilité pour autre chose.

Obtenez l’ID d’objet du principal de service à l’aide de la commande az ad sp list.

az ad sp list --display-name "<display_name>" --query "[].{\"Object ID\":id}" --output table

Supprimez le principal de service à l’aide de la commande az ad sp delete.
```
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

Dans ce guide de démarrage rapide, vous avez déployé un cluster hôte de conteneur Azure Linux. Pour en savoir plus sur l’Hôte de conteneur Azure Linux et suivre pas à pas un exemple complet illustrant le déploiement et la gestion d’un cluster, passez au tutoriel Hôte de conteneur Azure Linux.

Tutoriel sur l’hôte de conteneur Azure Linux

Partager via