Erstellen eines Kubernetes-Clusters mit Azure Kubernetes Service unter Verwendung von TerraformCreate a Kubernetes cluster with Azure Kubernetes Service using Terraform

Azure Kubernetes Service (AKS) verwaltet Ihre gehostete Kubernetes-Umgebung.Azure Kubernetes Service (AKS) manages your hosted Kubernetes environment. Mit AKS können Sie ganz ohne Kenntnisse im Bereich Containerorchestrierung containerbasierte Anwendungen bereitstellen und verwalten.AKS allows you to deploy and manage containerized applications without container orchestration expertise. Darüber hinaus lassen sich mit AKS viele gängige Wartungsvorgänge ausführen, ohne die App offline schalten zu müssen.AKS also enables you to do many common maintenance operations without taking your app offline. Zu diesen Vorgängen zählen unter anderem das Bereitstellen, Upgraden und Skalieren von Ressourcen nach Bedarf.These operations include provisioning, upgrading, and scaling resources on demand.

In diesem Artikel lernen Sie Folgendes:In this article, you learn how to do the following tasks:

  • Verwenden von HCL (HashiCorp-Sprache) zum Definieren eines Kubernetes-ClustersUse HCL (HashiCorp Language) to define a Kubernetes cluster
  • Verwenden von Terraform und AKS zum Erstellen eines Kubernetes-ClustersUse Terraform and AKS to create a Kubernetes cluster
  • Verwenden des kubectl-Tools zum Testen der Verfügbarkeit eines Kubernetes-ClustersUse the kubectl tool to test the availability of a Kubernetes cluster

VoraussetzungenPrerequisites

  • Azure-Abonnement: Wenn Sie über kein Azure-Abonnement verfügen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.Azure subscription: If you don't have an Azure subscription, create a free account before you begin.

Erstellen der VerzeichnisstrukturCreate the directory structure

Der erste Schritt ist das Erstellen des Verzeichnisses, das Ihre Terraform-Konfigurationsdateien für die Übung enthält.The first step is to create the directory that holds your Terraform configuration files for the exercise.

  1. Navigieren Sie zum Azure-Portal.Browse to the Azure portal.

  2. Öffnen Sie Azure Cloud Shell.Open Azure Cloud Shell. Falls Sie zuvor noch keine Umgebung ausgewählt haben, wählen Sie Bash als Umgebung aus.If you didn't select an environment previously, select Bash as your environment.

    Cloud Shell-Eingabeaufforderung

  3. Wechseln Sie in das Verzeichnis clouddrive.Change directories to the clouddrive directory.

    cd clouddrive
    
  4. Erstellen Sie ein Verzeichnis namens terraform-aks-k8s.Create a directory named terraform-aks-k8s.

    mkdir terraform-aks-k8s
    
  5. Wechseln Sie zum neuen Verzeichnis:Change directories to the new directory:

    cd terraform-aks-k8s
    

Deklarieren des Azure-AnbietersDeclare the Azure provider

Erstellen Sie die Terraform-Konfigurationsdatei, die den Azure-Anbieter deklariert.Create the Terraform configuration file that declares the Azure provider.

  1. Erstellen Sie in Cloud Shell eine Datei namens main.tf.In Cloud Shell, create a file named main.tf.

    code main.tf
    
  2. Fügen Sie den folgenden Code in den Editor ein:Paste the following code into the editor:

    provider "azurerm" {
        # The "feature" block is required for AzureRM provider 2.x. 
        # If you are using version 1.x, the "features" block is not allowed.
        version = "~>2.0"
        features {}
    }
    
    terraform {
        backend "azurerm" {}
    }
    
  3. Speichern Sie die Datei ( <STRG+S), und beenden Sie den Editor ( <STRG+Q).Save the file (<Ctrl>S) and exit the editor (<Ctrl>Q).

Definieren eines Kubernetes-ClustersDefine a Kubernetes cluster

Erstellen Sie die Terraform-Konfigurationsdatei, die die Ressourcen für den Kubernetes-Cluster deklariert.Create the Terraform configuration file that declares the resources for the Kubernetes cluster.

  1. Erstellen Sie in Cloud Shell eine Datei namens k8s.tf.In Cloud Shell, create a file named k8s.tf.

    code k8s.tf
    
  2. Fügen Sie den folgenden Code in den Editor ein: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)
            }
        }
    
        default_node_pool {
            name            = "agentpool"
            node_count      = var.agent_count
            vm_size         = "Standard_D2_v2"
        }
    
        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
            }
        }
    
        network_profile {
        load_balancer_sku = "Standard"
        network_plugin = "kubenet"
        }
    
        tags = {
            Environment = "Development"
        }
    }
    

    Der obige Code legt den Namen des Clusters, den Standort und den Ressourcengruppennamen fest.The preceding code sets the name of the cluster, location, and the resource group name. Des Weiteren wird das Präfix für den vollständig qualifizierten Domänennamen (Fully Qualified Domain Name, FQDN) festgelegt.The prefix for the fully qualified domain name (FQDN) is also set. Der FQDN wird für den Zugriff auf den Cluster verwendet.The FQDN is used to access the cluster.

    Mit dem Datensatz linux_profile können Sie die Einstellungen konfigurieren, die eine Anmeldung bei Workerknoten mithilfe von SSH ermöglichen.The linux_profile record allows you to configure the settings that enable signing into the worker nodes using SSH.

    Mit AKS zahlen Sie nur für die Workerknoten.With AKS, you pay only for the worker nodes. Der Datensatz default_node_pool konfiguriert die Details für diese Workerknoten.The default_node_pool record configures the details for these worker nodes. Der Datensatz default_node_pool record enthält die Anzahl der zu erstellenden Workerknoten und den Typ der Workerknoten.The default_node_pool record includes the number of worker nodes to create and the type of worker nodes. Wenn Sie den Cluster in der Zukunft hochskalieren oder herunterskalieren müssen, ändern Sie den Wert count in diesem Datensatz.If you need to scale up or scale down the cluster in the future, you modify the count value in this record.

  3. Speichern Sie die Datei ( <STRG+S), und beenden Sie den Editor ( <STRG+Q).Save the file (<Ctrl>S) and exit the editor (<Ctrl>Q).

Deklarieren der VariablenDeclare the variables

  1. Erstellen Sie in Cloud Shell eine Datei namens variables.tf.In Cloud Shell, create a file named variables.tf.

    code variables.tf
    
  2. Fügen Sie den folgenden Code in den Editor ein: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"
    }
    
  3. Speichern Sie die Datei ( <STRG+S), und beenden Sie den Editor ( <STRG+Q).Save the file (<Ctrl>S) and exit the editor (<Ctrl>Q).

Erstellen einer Terraform-AusgabedateiCreate a Terraform output file

Mit Terraform-Ausgaben können Sie Werte definieren, die für den Benutzer hervorgehoben werden, wenn Terraform einen Plan anwendet. Sie können mit dem Befehl terraform output abgefragt werden.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. In diesem Abschnitt erstellen Sie eine Ausgabedatei, die Zugriff auf den Cluster mit kubectl ermöglicht.In this section, you create an output file that allows access to the cluster with kubectl.

  1. Erstellen Sie in Cloud Shell eine Datei namens output.tf.In Cloud Shell, create a file named output.tf.

    code output.tf
    
  2. Fügen Sie den folgenden Code in den Editor ein: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
    }
    
  3. Speichern Sie die Datei ( <STRG+S), und beenden Sie den Editor ( <STRG+Q).Save the file (<Ctrl>S) and exit the editor (<Ctrl>Q).

Einrichten von Azure-Speicher zum Speichern des Terraform-StatusSet up Azure storage to store Terraform state

Terraform verfolgt den Status lokal über die Datei terraform.tfstate.Terraform tracks state locally via the terraform.tfstate file. Dieses Muster funktioniert gut in einer Umgebung mit nur einer Person.This pattern works well in a single-person environment. In einer Umgebung mit mehreren Personen wird Azure Storage verwendet, um den Zustand zu verfolgen.In a multi-person environment, Azure storage is used to track state.

In diesem Abschnitt lernen Sie, wie Sie folgende Aufgaben ausführen:In this section, you see how to do the following tasks:

  • Abrufen von Speicherkontoinformationen (Kontoname und Kontoschlüssel)Retrieve storage account information (account name and account key)
  • Erstellen eines Speichercontainers zum Speichern von Terraform-ZustandsinformationenCreate a storage container into which Terraform state information will be stored.
  1. Wählen Sie im Azure-Portal im linken Menü Alle Dienste aus.In the Azure portal, select All services in the left menu.

  2. Wählen Sie Speicherkonten aus.Select Storage accounts.

  3. Wählen Sie auf der Registerkarte Speicherkonten den Namen des Speicherkontos aus, in dem Terraform den Status speichern soll.On the Storage accounts tab, select the name of the storage account into which Terraform is to store state. Beispielsweise können Sie das Speicherkonto verwenden, das erstellt wurde, als Sie Cloud Shell zum ersten Mal geöffnet haben.For example, you can use the storage account created when you opened Cloud Shell the first time. Der Name des von Cloud Shell erstellten Speicherkontos beginnt in der Regel mit cs gefolgt von einer zufälligen Zeichenfolge aus Zahlen und Buchstaben.The storage account name created by Cloud Shell typically starts with cs followed by a random string of numbers and letters. Notieren Sie sich den Namen des ausgewählten Speicherkontos.Take note of the storage account you select. Dieser Wert wird später benötigt.This value is needed later.

  4. Wählen Sie auf der Registerkarte des Speicherkontos Zugriffsschlüssel aus.On the storage account tab, select Access keys.

    Menü des Speicherkontos

  5. Notieren Sie sich den Schlüsselwert von Schlüssel1.Make note of the key1 key value. (Wenn Sie das Symbol auf der rechten Seite des Schlüssels auswählen, wird der Wert in die Zwischenablage kopiert.)(Selecting the icon to the right of the key copies the value to the clipboard.)

    Speicherkonto-Zugriffsschlüssel

  6. Erstellen Sie in Cloud Shell einen Container in Ihrem Azure-Speicherkonto.In Cloud Shell, create a container in your Azure storage account. Ersetzen Sie die Platzhalter durch entsprechende Werte für Ihre Umgebung.Replace the placeholders with appropriate values for your environment.

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

Erstellen des Kubernetes-ClustersCreate the Kubernetes cluster

In diesem Abschnitt erfahren Sie, wie der Befehl terraform init verwendet wird, um die Ressourcen zu erstellen, die in den Konfigurationsdateien definiert sind, die Sie in den vorherigen Abschnitten erstellt haben.In this section, you see how to use the terraform init command to create the resources defined in the configuration files you created in the previous sections.

  1. Initialisieren Sie Terraform in Cloud Shell.In Cloud Shell, initialize Terraform. Ersetzen Sie die Platzhalter durch entsprechende Werte für Ihre Umgebung.Replace the placeholders with appropriate values for your environment.

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

    Der Befehl terraform init zeigt den Erfolg der Initialisierung von Back-End- und -Anbieter-Plug-Ins an:The terraform init command displays the success of initializing the backend and provider plug-in:

    Beispiel für Ergebnisse von „terraform init“

  2. Exportieren Sie die Anmeldeinformationen für den Dienstprinzipal.Export your service principal credentials. Ersetzen Sie die Platzhalter durch entsprechende Werte Ihres Dienstprinzipals.Replace the placeholders with appropriate values from your service principal.

    export TF_VAR_client_id=<service-principal-appid>
    export TF_VAR_client_secret=<service-principal-password>
    
  3. Führen Sie den Befehl terraform plan aus, um den Terraform-Plan zu erstellen, der die Infrastrukturelemente definiert.Run the terraform plan command to create the Terraform plan that defines the infrastructure elements.

    terraform plan -out out.plan
    

    Der Befehl terraform plan zeigt die Ressourcen an, die erstellt werden, wenn Sie den Befehl terraform apply ausführen:The terraform plan command displays the resources that will be created when you run the terraform apply command:

    Beispiel für Ergebnisse von „terraform plan“

  4. Führen Sie den Befehl terraform apply aus, um den Plan zum Erstellen des Kubernetes-Clusters anzuwenden.Run the terraform apply command to apply the plan to create the Kubernetes cluster. Der Prozess zum Erstellen eines Kubernetes-Clusters dauert einige Minuten. Dies kann zu einem Timeout der Cloud Shell-Sitzung führen. Wenn ein Timeout der Cloud Shell-Sitzung eintritt, können Sie die Schritte im Abschnitt „Wiederherstellen nach einem Cloud Shell-Timeout“ ausführen, um den Prozess abzuschließen.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 process.

    terraform apply out.plan
    

    Der Befehl terraform apply zeigt die Ergebnisse der Erstellung der Ressourcen an, die in den Konfigurationsdateien definiert sind:The terraform apply command displays the results of creating the resources defined in your configuration files:

    Beispiel für Ergebnisse von „terraform apply“

  5. Wählen Sie im Azure-Portal im linken Menü die Option Alle Ressourcen aus, um die Ressourcen anzuzeigen, die für Ihren neuen Kubernetes-Cluster erstellt wurden.In the Azure portal, select All resources in the left menu to see the resources created for your new Kubernetes cluster.

    Alle Ressourcen im Azure-Portal

Wiederherstellen nach einem Cloud Shell-TimeoutRecover from a Cloud Shell timeout

Bei einem Timeout der Cloud Shell-Sitzung können Sie zur Wiederherstellung die folgenden Schritte ausführen:If the Cloud Shell session times out, you can do the following steps to recover:

  1. Starten Sie eine Cloud Shell-Sitzung.Start a Cloud Shell session.

  2. Wechseln Sie zu dem Verzeichnis, das Ihre Terraform Konfigurationsdateien enthält.Change to the directory containing your Terraform configuration files.

    cd /clouddrive/terraform-aks-k8s
    
  3. Führen Sie den folgenden Befehl aus:Run the following command:

    export KUBECONFIG=./azurek8s
    

Testen des Kubernetes-ClustersTest the Kubernetes cluster

Die Kubernetes-Tools können verwendet werden, um den neu erstellten Cluster zu überprüfen.The Kubernetes tools can be used to verify the newly created cluster.

  1. Rufen Sie die Kubernetes-Konfiguration aus dem Terraform-Status ab, und speichern Sie sie in einer Datei, die kubectl lesen kann.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. Legen Sie eine Umgebungsvariable so fest, dass kubectl die richtige Konfiguration auswählt.Set an environment variable so that kubectl picks up the correct config.

    export KUBECONFIG=./azurek8s
    
  3. Überprüfen Sie die Integrität des Clusters.Verify the health of the cluster.

    kubectl get nodes
    

    Sie sollten die Details der Workerknoten sehen, und sie sollten alle den Status Ready aufweisen, wie in der folgenden Abbildung dargestellt:You should see the details of your worker nodes, and they should all have a status Ready, as shown in the following image:

    Das kubectl-Tool ermöglicht die Überprüfung der Integrität des Kubernetes-Clusters

Überwachung von Integrität und ProtokollenMonitor health and logs

Beim Erstellen des AKS-Clusters wurde die Überwachung aktiviert, um Integritätsmetriken für die Clusterknoten und die Pods zu erfassen.When the AKS cluster was created, monitoring was enabled to capture health metrics for both the cluster nodes and pods. Diese Integritätsmetriken sind im Azure-Portal verfügbar.These health metrics are available in the Azure portal. Weitere Informationen zur Überwachung der Integrität von Containern finden Sie unter Überwachen der Integrität von Azure Kubernetes Service.For more information on container health monitoring, see Monitor Azure Kubernetes Service health.

ProblembehandlungTroubleshooting

Verwenden Sie für Terraform-spezifischen Support einen Supportkanal der HashiCorp-Community zu Terraform:For Terraform-specific support, use one of HashiCorp's community support channels to Terraform:

Nächste SchritteNext steps