Créer un cluster Kubernetes avec Azure Kubernetes Service et TerraformCreate a Kubernetes cluster with Azure Kubernetes Service and Terraform

Azure Kubernetes Service (AKS) gère votre environnement Kubernetes hébergé, ce qui vous permet de déployer et de gérer de manière simple et rapide des applications en conteneur sans avoir à maîtriser l’orchestration de conteneurs.Azure Kubernetes Service (AKS) manages your hosted Kubernetes environment, making it quick and easy to deploy and manage containerized applications without container orchestration expertise. Il élimine également la charge des opérations en cours et la maintenance par configuration, la mise à niveau et la mise à l’échelle des ressources à la demande, sans déconnecter vos applications.It also eliminates the burden of ongoing operations and maintenance by provisioning, upgrading, and scaling resources on demand, without taking your applications offline.

Dans ce tutoriel, découvrez comment effectuer les tâches suivantes pour créer un cluster Kubernetes à l’aide de Terraform et AKS :In this tutorial, you learn how to perform the following tasks in creating a Kubernetes cluster using Terraform and AKS:

  • Utiliser HCL (HashiCorp Language) pour définir un cluster KubernetesUse HCL (HashiCorp Language) to define a Kubernetes cluster
  • Utiliser Terraform et AKS pour créer un cluster KubernetesUse Terraform and AKS to create a Kubernetes cluster
  • Utiliser l’outil kubectl pour tester la disponibilité d’un cluster KubernetesUse the kubectl tool to test the availability of a Kubernetes cluster

PrérequisPrerequisites

Créer la structure de répertoireCreate the directory structure

La première étape consiste à créer le répertoire qui contient vos fichiers de configuration Terraform pour l’exercice.The first step is to create the directory that holds your Terraform configuration files for the exercise.

  1. Accédez au portail Azure.Browse to the Azure portal.

  2. Ouvrez Azure Cloud Shell.Open Azure Cloud Shell. Si vous n’avez pas sélectionné d’environnement précédemment, choisissez Bash comme votre environnement.If you didn't select an environment previously, select Bash as your environment.

    Invite Cloud Shell

  3. Remplacez le répertoire par le répertoire clouddrive.Change directories to the clouddrive directory.

    cd clouddrive
    
  4. Créez un répertoire nommé terraform-aks-k8s.Create a directory named terraform-aks-k8s.

    mkdir terraform-aks-k8s
    
  5. Déplacez-vous dans le nouveau répertoire :Change directories to the new directory:

    cd terraform-aks-k8s
    

Déclarer le fournisseur AzureDeclare the Azure provider

Créez le fichier de configuration Terraform qui déclare le fournisseur Azure.Create the Terraform configuration file that declares the Azure provider.

  1. Dans Cloud Shell, créez un fichier nommé main.tf.In Cloud Shell, create a file named main.tf.

    vi main.tf
    
  2. Passez en mode insertion en sélectionnant la touche I.Enter insert mode by selecting the I key.

  3. Collez le code suivant dans l’éditeur :Paste the following code into the editor:

    provider "azurerm" {
        version = "~>1.5"
    }
    
    terraform {
        backend "azurerm" {}
    }
    
  4. Quittez le mode insertion en sélectionnant la touche Échap.Exit insert mode by selecting the Esc key.

  5. Enregistrez le fichier et quittez l’éditeur vi en entrant la commande suivante :Save the file and exit the vi editor by entering the following command:

    :wq
    

Définir un cluster KubernetesDefine a Kubernetes cluster

Créez le fichier de configuration Terraform qui déclare les ressources du cluster Kubernetes.Create the Terraform configuration file that declares the resources for the Kubernetes cluster.

  1. Dans Cloud Shell, créez un fichier nommé k8s.tf.In Cloud Shell, create a file named k8s.tf.

    vi k8s.tf
    
  2. Passez en mode insertion en sélectionnant la touche I.Enter insert mode by selecting the I key.

  3. Collez le code suivant dans l’éditeur :Paste the following code into the editor:

    resource "azurerm_resource_group" "k8s" {
        name     = "${var.resource_group_name}"
        location = "${var.location}"
    }
    
    resource "random_id" "log_analytics_workspace_name_suffix" {
        byte_length = 8
    }
    
    resource "azurerm_log_analytics_workspace" "test" {
        # 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}"
        location            = "${var.log_analytics_workspace_location}"
        resource_group_name = "${azurerm_resource_group.k8s.name}"
        sku                 = "${var.log_analytics_workspace_sku}"
    }
    
    resource "azurerm_log_analytics_solution" "test" {
        solution_name         = "ContainerInsights"
        location              = "${azurerm_log_analytics_workspace.test.location}"
        resource_group_name   = "${azurerm_resource_group.k8s.name}"
        workspace_resource_id = "${azurerm_log_analytics_workspace.test.id}"
        workspace_name        = "${azurerm_log_analytics_workspace.test.name}"
    
        plan {
            publisher = "Microsoft"
            product   = "OMSGallery/ContainerInsights"
        }
    }
    
    resource "azurerm_kubernetes_cluster" "k8s" {
        name                = "${var.cluster_name}"
        location            = "${azurerm_resource_group.k8s.location}"
        resource_group_name = "${azurerm_resource_group.k8s.name}"
        dns_prefix          = "${var.dns_prefix}"
    
        linux_profile {
            admin_username = "ubuntu"
    
            ssh_key {
                key_data = "${file("${var.ssh_public_key}")}"
            }
        }
    
        agent_pool_profile {
            name            = "agentpool"
            count           = "${var.agent_count}"
            vm_size         = "Standard_DS1_v2"
            os_type         = "Linux"
            os_disk_size_gb = 30
        }
    
        service_principal {
            client_id     = "${var.client_id}"
            client_secret = "${var.client_secret}"
        }
    
        addon_profile {
            oms_agent {
            enabled                    = true
            log_analytics_workspace_id = "${azurerm_log_analytics_workspace.test.id}"
            }
        }
    
        tags = {
            Environment = "Development"
        }
    }
    

    Le code précédent définit le nom du cluster, l’emplacement et le resource_group_name.The preceding code sets the name of the cluster, location, and the resource_group_name. De plus, la valeur dns_prefix, qui fait partie du nom de domaine complet (FQDN) utilisé pour accéder au cluster, est définie.In addition, the dns_prefix value - that forms part of the fully qualified domain name (FQDN) used to access the cluster - is set.

    L’enregistrement linux_profile vous permet de configurer les paramètres servant à vous connecter aux nœuds worker à l’aide de SSH.The linux_profile record allows you to configure the settings that enable signing into the worker nodes using SSH.

    Avec AKS, vous payez uniquement pour les nœuds worker.With AKS, you pay only for the worker nodes. L’enregistrement agent_pool_profile configure les détails de ces nœuds worker.The agent_pool_profile record configures the details for these worker nodes. L’enregistrement agent_pool_profile inclut le nombre de nœuds worker à créer et le type de nœuds worker.The agent_pool_profile record includes the number of worker nodes to create and the type of worker nodes. Si vous avez besoin d’augmenter ou de réduire l’échelle du cluster par la suite, modifiez la valeur count dans cet enregistrement.If you need to scale up or scale down the cluster in the future, you modify the count value in this record.

  4. Quittez le mode insertion en sélectionnant la touche Échap.Exit insert mode by selecting the Esc key.

  5. Enregistrez le fichier et quittez l’éditeur vi en entrant la commande suivante :Save the file and exit the vi editor by entering the following command:

    :wq
    

Déclarer les variablesDeclare the variables

  1. Dans Cloud Shell, créez un fichier nommé variables.tf.In Cloud Shell, create a file named variables.tf.

    vi variables.tf
    
  2. Passez en mode insertion en sélectionnant la touche I.Enter insert mode by selecting the I key.

  3. Collez le code suivant dans l’éditeur :Paste the following code into the editor:

    variable "client_id" {}
    variable "client_secret" {}
    
    variable "agent_count" {
        default = 3
    }
    
    variable "ssh_public_key" {
        default = "~/.ssh/id_rsa.pub"
    }
    
    variable "dns_prefix" {
        default = "k8stest"
    }
    
    variable cluster_name {
        default = "k8stest"
    }
    
    variable resource_group_name {
        default = "azure-k8stest"
    }
    
    variable location {
        default = "Central US"
    }
    
    variable log_analytics_workspace_name {
        default = "testLogAnalyticsWorkspaceName"
    }
    
    # refer https://azure.microsoft.com/global-infrastructure/services/?products=monitor for log analytics available regions
    variable log_analytics_workspace_location {
        default = "eastus"
    }
    
    # refer https://azure.microsoft.com/pricing/details/monitor/ for log analytics pricing 
    variable log_analytics_workspace_sku {
        default = "PerGB2018"
    }
    
  4. Quittez le mode insertion en sélectionnant la touche Échap.Exit insert mode by selecting the Esc key.

  5. Enregistrez le fichier et quittez l’éditeur vi en entrant la commande suivante :Save the file and exit the vi editor by entering the following command:

    :wq
    

Créer un fichier de sortie TerraformCreate a Terraform output file

Les sorties Terraform vous permettent de définir des valeurs qui sont présentées en surbrillance à l’utilisateur quand Terraform applique un plan, et qui peuvent être interrogées à l’aide de la commande terraform output.Terraform outputs allow you to define values that will be highlighted to the user when Terraform applies a plan, and can be queried using the terraform output command. Dans cette section, créez un fichier de sortie qui permet d’accéder au cluster avec kubectl.In this section, you create an output file that allows access to the cluster with kubectl.

  1. Dans Cloud Shell, créez un fichier nommé output.tf.In Cloud Shell, create a file named output.tf.

    vi output.tf
    
  2. Passez en mode insertion en sélectionnant la touche I.Enter insert mode by selecting the I key.

  3. Collez le code suivant dans l’éditeur :Paste the following code into the editor:

    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}"
    }
    
    output "host" {
        value = "${azurerm_kubernetes_cluster.k8s.kube_config.0.host}"
    }
    
  4. Quittez le mode insertion en sélectionnant la touche Échap.Exit insert mode by selecting the Esc key.

  5. Enregistrez le fichier et quittez l’éditeur vi en entrant la commande suivante :Save the file and exit the vi editor by entering the following command:

    :wq
    

Configurer le stockage Azure pour stocker l’état de TerraformSet up Azure storage to store Terraform state

Terraform suit l’état en local via le fichier terraform.tfstate.Terraform tracks state locally via the terraform.tfstate file. Ce modèle fonctionne bien dans un environnement comptant une seule personne.This pattern works well in a single-person environment. Toutefois, dans un environnement à plusieurs personnes plus pratique, vous devez suivre l’état sur le serveur en utilisant le stockage Azure.However, in a more practical multi-person environment, you need to track state on the server utilizing Azure storage. Dans cette section, récupérez les informations de compte de stockage nécessaires (nom de compte et clé de compte) et créez un conteneur de stockage dans lequel les informations d’état de Terraform seront stockées.In this section, you retrieve the necessary storage account information (account name and account key), and create a storage container into which the Terraform state information will be stored.

  1. Dans le portail Azure, sélectionnez Tous les services dans le menu à gauche.In the Azure portal, select All services in the left menu.

  2. Sélectionnez Comptes de stockage.Select Storage accounts.

  3. Sous l’onglet Comptes de stockage, sélectionnez le nom du compte de stockage dans lequel Terraform doit stocker l’état.On the Storage accounts tab, select the name of the storage account into which Terraform is to store state. Par exemple, vous pouvez utiliser le compte de stockage créé lorsque vous ouvrez Cloud Shell pour la première fois.For example, you can use the storage account created when you opened Cloud Shell the first time. Le nom du compte de stockage créé par Cloud Shell commence généralement par cs suivi d’une chaîne aléatoire de chiffres et lettres.The storage account name created by Cloud Shell typically starts with cs followed by a random string of numbers and letters. N’oubliez pas le nom du compte de stockage que vous sélectionnez, car vous en aurez besoin plus tard.Remember the name of the storage account you select, as it is needed later.

  4. Sous l’onglet du compte de stockage, sélectionnez Clés d’accès.On the storage account tab, select Access keys.

    Menu du compte de stockage

  5. Notez la valeur key1 key.Make note of the key1 key value. (Quand vous sélectionnez l’icône à droite de la clé, la valeur est copiée dans le Presse-papiers.)(Selecting the icon to the right of the key copies the value to the clipboard.)

    Clés d’accès au compte de stockage

  6. Dans Cloud Shell, créez un conteneur dans votre compte de stockage Azure (remplacez les espaces réservés <YourAzureStorageAccountName > et <YourAzureStorageAccountAccessKey > par des valeurs appropriées à votre compte de stockage Azure).In Cloud Shell, create a container in your Azure storage account (replace the <YourAzureStorageAccountName> and <YourAzureStorageAccountAccessKey> placeholders with the appropriate values for your Azure storage account).

    az storage container create -n tfstate --account-name <YourAzureStorageAccountName> --account-key <YourAzureStorageAccountKey>
    

Créer un cluster KubernetesCreate the Kubernetes cluster

Dans cette section, vous voyez comment utiliser la commande terraform init pour créer les ressources définies dans les fichiers de configuration que vous avez créés dans les sections précédentes.In this section, you see how to use the terraform init command to create the resources defined the configuration files you created in the previous sections.

  1. Dans Cloud Shell, initialisez Terraform (remplacez les espaces réservés <YourAzureStorageAccountName> et <YourAzureStorageAccountAccessKey> par des valeurs appropriées à votre compte de stockage Azure).In Cloud Shell, initialize Terraform (replace the <YourAzureStorageAccountName> and <YourAzureStorageAccountAccessKey> placeholders with the appropriate values for your Azure storage account).

    terraform init -backend-config="storage_account_name=<YourAzureStorageAccountName>" -backend-config="container_name=tfstate" -backend-config="access_key=<YourStorageAccountAccessKey>" -backend-config="key=codelab.microsoft.tfstate" 
    

    La commande terraform init affiche la réussite de l’initialisation du backend et du plug-in du fournisseur :The terraform init command displays the success of initializing the backend and provider plugin:

    Exemple de résultats « terraform init »

  2. Exportez les informations d’identification du principal de service.Export your service principal credentials. Remplacez respectivement les espaces réservés <votre-id-client> et <votre-secret-client> par les valeurs d’appId et de mot de passe associées à votre principal de service.Replace the <your-client-id> and <your-client-secret> placeholders with the appId and password values associated with your service principal, respectively.

    export TF_VAR_client_id=<your-client-id>
    export TF_VAR_client_secret=<your-client-secret>
    
  3. Exécutez la commande terraform plan pour créer le plan Terraform qui définit les éléments d’infrastructure.Run the terraform plan command to create the Terraform plan that defines the infrastructure elements.

    terraform plan -out out.plan
    

    La commande terraform plan affiche les ressources qui seront créées lorsque vous exécuterez la commande terraform apply :The terraform plan command displays the resources that will be created when you run the terraform apply command:

    Exemple de résultats « terraform plan »

  4. Exécutez la commande terraform apply pour appliquer le plan servant à créer le cluster Kubernetes.Run the terraform apply command to apply the plan to create the Kubernetes cluster. Le processus de création d’un cluster Kubernetes peut prendre plusieurs minutes, ce qui peut aboutir à l’expiration de la session Cloud Shell. Si la session Cloud Shell expire, vous pouvez suivre les étapes de la section « Récupérer suite à l’expiration de Cloud Shell » pour poursuivre le tutoriel.The process to create a Kubernetes cluster can take several minutes, resulting in the Cloud Shell session timing out. If the Cloud Shell session times out, you can follow the steps in the section "Recover from a Cloud Shell timeout" to enable you to complete the tutorial.

    terraform apply out.plan
    

    La commande terraform apply affiche les résultats de la création des ressources définies dans vos fichiers de configuration :The terraform apply command displays the results of creating the resources defined in your configuration files:

    Exemple de résultats « terraform apply »

  5. Dans le portail Azure, sélectionnez Tous les services dans le menu de gauche pour voir les ressources créées pour votre nouveau cluster Kubernetes.In the Azure portal, select All services in the left menu to see the resources created for your new Kubernetes cluster.

    Invite Cloud Shell

Récupérer suite à l’expiration de Cloud ShellRecover from a Cloud Shell timeout

Si la session Cloud Shell expire, vous pouvez effectuer les étapes suivantes pour récupérer :If the Cloud Shell session times out, you can perform the following steps to recover:

  1. Démarrez une session Cloud Shell.Start a Cloud Shell session.

  2. Accédez au répertoire qui contient vos fichiers de configuration Terraform.Change to the directory containing your Terraform configuration files.

    cd /clouddrive/terraform-aks-k8s
    
  3. Exécutez la commande suivante :Run the following command:

    export KUBECONFIG=./azurek8s
    

Tester le cluster KubernetesTest the Kubernetes cluster

Les outils Kubernetes peuvent être utilisés pour vérifier le cluster nouvellement créé.The Kubernetes tools can be used to verify the newly created cluster.

  1. Obtenez la configuration Kubernetes à partir de l’état Terraform et stockez-la dans un fichier que kubectl peut lire.Get the Kubernetes configuration from the Terraform state and store it in a file that kubectl can read.

    echo "$(terraform output kube_config)" > ./azurek8s
    
  2. Définissez une variable d’environnement pour que kubectl choisisse la bonne configuration.Set an environment variable so that kubectl picks up the correct config.

    export KUBECONFIG=./azurek8s
    
  3. Vérifiez l’intégrité du cluster.Verify the health of the cluster.

    kubectl get nodes
    

    Vous devriez voir les détails de vos nœuds worker, et tous doivent avoir un état Ready, comme illustré dans l’image suivante :You should see the details of your worker nodes, and they should all have a status Ready, as shown in the following image:

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

Analyser le fonctionnement et les journaux d’activitéMonitor health and logs

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.When the AKS cluster was created, monitoring was enabled to capture health metrics for both the cluster nodes and pods. Ces mesures sont disponibles dans le portail Azure.These health metrics are available in the Azure portal. Pour plus d’informations sur la supervision de l’intégrité des conteneurs, consultez Superviser l’intégrité d’Azure Kubernetes Service.For more information on container health monitoring, see Monitor Azure Kubernetes Service health.

Étapes suivantesNext steps

Dans cet article, vous avez appris à utiliser Terraform et AKS pour créer un cluster Kubernetes.In this article, you learned how to use Terraform and AKS to create a Kubernetes cluster. Pour en savoir plus sur Terraform sur Azure, consultez les ressources supplémentaires suivantes :Here are some additional resources to help you learn more about Terraform on Azure:

Hub Terraform sur Microsoft.comTerraform Hub in Microsoft.com
Documentation Terraform Azure ProviderTerraform Azure provider documentation
Source Terraform Azure ProviderTerraform Azure provider source
Modules Terraform AzureTerraform Azure modules