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

Article
05/27/2023

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.

Cet article explique comment créer un cluster Kubernetes avec Azure Kubernetes Service (AKS) à l’aide de Terraform. L’exemple de code est entièrement encapsulé de sorte qu’il crée automatiquement un principal de service et une paire de clés SSH (à l’aide du fournisseur AzAPI).

Dans cet article, vous apprendrez comment :

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 à l’aide de azurerm_client_config.
Créez un espace de travail Log Analytics à l’aide de azurerm_log_analytics_workspace.
Créez une solution Log Analytics à l’aide de azurerm_log_analytics_solution.
Créez un cluster Kubernetes à l’aide de azurerm_kubernetes_cluster.
Créez une inscription d’application Azure Active Directory à l’aide de azuread_application.
Créez un principal de service Azure à l’aide de azuread_service_principal.
Créez un mot de passe de principal de service Azure à l’aide de azuread_service_principal_password.
Créez une ressource AzAPI azapi_resource.
Créez une ressource AzAPI pour générer une paire de clés SSH à l’aide de azapi_resource_action.

Notes

Cet article a été créé partiellement à l’aide d’une intelligence artificielle. Avant la publication, un auteur a examiné et révisé le contenu en fonction des besoins. Consultez Nos principes d’utilisation du contenu généré par l’IA dans Microsoft Learn.

Prérequis

Configurer Terraform : si ce n’est déjà fait, configurez Terraform à l’aide de l’une des options suivantes :

Outil en ligne de commande Kubernetes (kubectl) :téléchargez kubectl.

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 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 {
    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é sp.tf et insérez le code suivant :

# Create Azure AD App Registration
resource "azuread_application" "app" {
  display_name = "my-app"
  owners       = [local.current_user_id]
}

# Create Service Principal
resource "azuread_service_principal" "app" {
  application_id               = azuread_application.app.application_id
  app_role_assignment_required = true
  owners                       = [local.current_user_id]
}

# Create Service Principal password
resource "azuread_service_principal_password" "app" {
  service_principal_id = azuread_service_principal.app.id
}

# Sleep for 30 seconds to allow for propagation
# of the Service Principal creation before attempting
# to create the AKS cluster.
resource "time_sleep" "wait_30_seconds" {
  create_duration = "30s"

  depends_on = [azuread_service_principal_password.app]
}

# Output the Service Principal and password
output "sp" {
  value     = azuread_service_principal.app.id
  sensitive = true
}

output "sp_password" {
  value     = azuread_service_principal_password.app.value
  sensitive = true
}

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" "ssh_public_key" {
  type      = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  name      = random_pet.ssh_key_name.id
  location  = "westus3"
  parent_id = azurerm_resource_group.rg.id
}

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

output "key_data" {
  value     = azapi_resource.ssh_public_key.body
  sensitive = true
}

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
}

data "azurerm_client_config" "current" {}

locals {
  current_user_id = coalesce(var.msi_id, data.azurerm_client_config.current.object_id)
}

resource "random_pet" "azurerm_log_analytics_workspace_name" {
  prefix = "ws"
}

resource "azurerm_log_analytics_workspace" "test" {
  location            = var.log_analytics_workspace_location
  name                = random_pet.azurerm_log_analytics_workspace_name.id
  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 "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

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

    ssh_key {
      key_data = jsondecode(azapi_resource_action.ssh_public_key_gen.output).publicKey
    }
  }
  network_profile {
    network_plugin    = "kubenet"
    load_balancer_sku = "standard"
  }
  service_principal {
    client_id     = azuread_service_principal.app.application_id
    client_secret = azuread_service_principal_password.app.value
  }

  depends_on = [time_sleep.wait_30_seconds]
}

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
}

# For available Log Analytics regions, refer to:
# https://azure.microsoft.com/global-infrastructure/services/?products=monitor
variable "log_analytics_workspace_location" {
  type        = string
  default     = "eastus"
  description = "Location of the Log Analytics workspace."
}

# For Log Analytics pricing, refer to:
# https://azure.microsoft.com/pricing/details/monitor
variable "log_analytics_workspace_sku" {
  type        = string
  description = "The SKU of the Log Analytics workspace. Choose from: Free, PerNode, Premium, Standard, Standalone, Unlimited, CapacityReservation, PerGB2018"
  default     = "PerGB2018"

  validation {
    condition     = contains(["Free", "PerNode", "Premium", "Standard", "Standalone", "Unlimited", "CapacityReservation", "PerGB2018"], var.log_analytics_workspace_sku)
    error_message = "The Log Analytics workspace SKU must be one of the following: Free, PerNode, Premium, Standard, Standalone, Unlimited, CapacityReservation, PerGB2018"
  }
}

variable "msi_id" {
  type        = string
  description = "The Managed Service Identity ID used to create the service principal. If this value is null (the default), the AzureRM provider configuration Object ID is used.."
  default     = null
}

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 "log_analytics_workspace_name" {
  value = azurerm_log_analytics_workspace.test.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é.
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 :

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

Vérifier les résultats

Azure CLI

Obtenez le nom du groupe de ressources Azure.

resource_group_name=$(terraform output -raw resource_group_name)

Exécutez az monitor log-analytics workspace list pour afficher le nom du nouvel espace de travail Log Analytics.

az monitor log-analytics workspace list \
  --resource-group $resource_group_name \
  --query "[].{\"Workspace name\":name}" \
  --output table

Exécutez az monitor log-analytics solution list pour afficher le nom de la nouvelle solution Log Analytics.
```
az monitor log-analytics solution list \
  --resource-group $resource_group_name \
  --query "value[*].{\"Solution name\":name}" \
  --output table  
```
Points essentiels :
- La valeur entre parenthèses est le nom de l’espace de travail Log Analytics dans lequel la solution Log Analytics a été créée.

Exécutez az aks list pour afficher le nom du nouveau cluster Kubernetes.

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.
```
echo "$(terraform output kube_config)" > ./azurek8s
```
Vérifiez que la commande précédente n’a pas ajouté de caractère EOT ASCII.
```
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
Définissez une variable d’environnement pour que kubectl choisisse la bonne configuration.
```
export KUBECONFIG=./azurek8s
```
Vérifiez l’intégrité du cluster.
```
kubectl get nodes
```

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 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 AKS et le mot de passe du cluster AKS sont générés.

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é.
- 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é.
Exécutez terraform apply pour appliquer le plan d’exécution.
```
terraform apply main.destroy.tfplan
```

Suppression de principal de service

Obtenez l’ID du principal de service.
```
sp=$(terraform output -raw sp)
```
Exécutez az ad sp delete pour supprimer le principal de service.
```
az ad sp delete --id $sp
```

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

En savoir plus sur l’utilisation d’AKS

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

Prérequis

Implémenter le code Terraform

Initialiser Terraform

Créer un plan d’exécution Terraform

Appliquer un plan d’exécution Terraform

Vérifier les résultats

Nettoyer les ressources

Supprimer des ressources AKS

Suppression de principal de service

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

Étapes suivantes

Ressources supplémentaires

Ressources supplémentaires