Schnellstart: Bereitstellen eines Clusters für den Azure Linux-Containerhost für AKS mithilfe von Terraform

Artikel
10/16/2024

Führen Sie erste Schritte mit dem Azure Linux-Containerhost mithilfe von Terraform aus, um einen Cluster für den Azure Linux-Containerhost bereitzustellen. Nach der Installation der erforderlichen Komponenten implementieren Sie den Terraform-Code, initialisieren Terraform und erstellen und wenden einen Terraform-Ausführungsplan an.

Mit Terraform können Sie eine Cloudinfrastruktur definieren, eine Vorschau der Cloudinfrastruktur anzeigen und die Cloudinfrastruktur bereitstellen. Mit Terraform können Sie Konfigurationsdateien mit HCL-Syntax erstellen. Mit der HCL-Syntax können Sie den Cloudanbieter und Elemente angeben, aus denen sich Ihre Cloudinfrastruktur zusammensetzt. Nach der Erstellung Ihrer Konfigurationsdateien erstellen Sie einen Ausführungsplan, mit dem Sie eine Vorschau Ihrer Infrastrukturänderungen anzeigen können, bevor diese bereitgestellt werden. Nach der Überprüfung der Änderungen wenden Sie den Ausführungsplan an, um die Infrastruktur bereitzustellen.

Hinweis

Der Beispielcode in diesem Artikel befindet sich im Microsoft Terraform-GitHub-Repository.

Voraussetzungen

Sollten Sie über kein Azure-Abonnement verfügen, können Sie zunächst ein kostenloses Azure-Konto erstellen.
Wenn Sie Terraform noch nicht konfiguriert haben, können Sie dazu eine der folgenden Optionen verwenden:
Erstellen Sie einen Dienstprinzipal, falls Sie noch nicht über einen Azure-Dienstprinzipal verfügen. Notieren Sie sich appId, display_name, password und tenant.
Sie benötigen das Kubernetes-Befehlszeilentool kubectl. Falls dieses Tool noch nicht vorhanden ist, laden Sie kubectl herunter.

Erstellen eines SSH-Schlüsselpaars

Für den Zugriff auf AKS-Knoten stellen Sie eine Verbindung mithilfe eines SSH-Schlüsselpaars (öffentlich und privat) her, das Sie mithilfe des Befehls ssh-keygen generieren. Diese Dateien werden standardmäßig im Verzeichnis ~/.ssh erstellt. Durch die Ausführung des Befehls ssh-keygen wird jedes SSH-Schlüsselpaar mit dem gleichen Namen überschrieben, das bereits am angegebenen Speicherort vorhanden ist.

Navigieren Sie zu https://shell.azure.com, um Cloud Shell in Ihrem Browser zu öffnen.
Führen Sie den Befehl ssh-keygen aus. Das folgende Beispiel erstellt ein SSH-Schlüsselpaar mittels RSA-Verschlüsselung und einer Bitlänge von 4096:
```
ssh-keygen -t rsa -b 4096
```

Weitere Informationen zum Erstellen von SSH-Schlüsseln finden Sie unter Erstellen und Verwalten von SSH-Schlüsseln für die Authentifizierung in Azure.

Implementieren des Terraform-Codes

Erstellen Sie ein Verzeichnis, in dem der Terraform-Beispielcode getestet werden soll, und legen Sie es als aktuelles Verzeichnis fest.

Erstellen Sie eine Datei namens providers.tf, und fügen Sie den folgenden Code ein:

    terraform {
      required_version = ">=1.0"

      required_providers {
        azurerm = {
          source  = "hashicorp/azurerm"
          version = "~>3.0"
        }
        random = {
          source  = "hashicorp/random"
          version = "~>3.0"
        }
      }
    }

    provider "azurerm" {
      features {}
    }

Erstellen Sie eine Datei namens main.tf, und fügen Sie den folgenden Code ein:

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

Ebenso können Sie Azure Linux os_sku in azurerm_kubernetes_cluster_node_pool angeben.

Erstellen Sie eine Datei namens variables.tf, und fügen Sie den folgenden Code ein:

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

Erstellen Sie eine Datei namens outputs.tf, und fügen Sie den folgenden Code ein:

    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
    }

Erstellen Sie eine Datei namens terraform.tfvars, und fügen Sie den folgenden Code ein:

    aks_service_principal_app_id = "<service_principal_app_id>"
    aks_service_principal_client_secret = "<service_principal_password>"

Initialisieren von Terraform und Erstellen eines Ausführungsplan

Initialisieren Sie Terraform, und laden Sie die Azure-Module herunter, die zum Verwalten Ihrer Azure-Ressourcen erforderlich sind, mit dem Befehl „terraform init“.
```
terraform init
```
Erstellen Sie mit dem Befehl „terraform plan“ einen Terraform-Ausführungsplan.
```
terraform plan -out main.tfplan
```
Durch den Befehl terraform plan wird ein Ausführungsplan erstellt, aber nicht ausgeführt. Stattdessen werden die Aktionen ermittelt, die erforderlich sind, um die in Ihren Konfigurationsdateien angegebene Konfiguration zu erstellen. Mit diesem Muster können Sie überprüfen, ob der Ausführungsplan Ihren Erwartungen entspricht, bevor Sie Änderungen an den eigentlichen Ressourcen vornehmen.

Der optionale Parameter -out ermöglicht die Angabe einer Ausgabedatei für den Plan. Durch die Verwendung des Parameters -out wird sichergestellt, dass genau der von Ihnen überprüfte Plan angewendet wird.

Weitere Informationen zum Speichern von Ausführungsplänen und zur Sicherheit finden Sie unter Sicherheitswarnungen.
Wenden Sie den Terraform-Ausführungsplan mit dem Befehl „terraform apply“ an.
```
terraform apply main.tfplan
```
Beim obigen Befehl terraform apply wird davon ausgegangen, dass Sie zuvor terraform plan -out main.tfplan ausgeführt haben. Wenn Sie einen anderen Dateinamen für den -out-Parameter angegeben haben, verwenden Sie denselben Dateinamen im Aufruf von terraform apply. Wenn Sie den Parameter -out nicht verwendet haben, rufen Sie terraform apply ohne Parameter auf.

Überprüfen der Ergebnisse

Rufen Sie die Ressourcengruppe mit dem Befehl „echo“ ab.
```
echo "$(terraform output resource_group_name)"
```
Navigieren Sie zum Azure-Portal.
Wählen Sie unter Azure-Dienste die Option Ressourcengruppen aus, und suchen Sie Ihre neue Ressourcengruppe, um die folgenden in dieser Demo erstellten Ressourcen anzuzeigen:
- Lösung: Standardmäßig benennt die Demo diese Lösung ContainerInsights. Im Portal wird der Arbeitsbereichsname der Lösung in Klammern angezeigt.
- Kubernetes-Dienst: Standardmäßig benennt die Demo diesen Dienst k8stest. (Ein Managed Kubernetes-Cluster wird auch AKS/Azure Kubernetes Service genannt.)
- Log Analytics-Arbeitsbereich: Standardmäßig benennt die Demo diesen Arbeitsbereich mit dem Präfix TestLogAnalyticsWorkspaceName-, gefolgt von einer Zufallszahl.
Rufen Sie die Kubernetes-Konfiguration aus dem Terraform-Status ab, und speichern Sie sie mit dem Befehl „echo“ in einer Datei, die kubectl lesen kann.
```
echo "$(terraform output kube_config)" > ./azurek8s
```
Vergewissern Sie sich, dass der vorherige Befehl kein ASCII EOT-Zeichen hinzugefügt hat, indem Sie den Befehl „cat“ verwenden.
```
cat ./azurek8s
```
Wenn am Anfang << EOT und am Ende EOT angezeigt wird, entfernen Sie diese Zeichen aus der Datei. Sie erhalten andernfalls unter Umständen die folgende Fehlermeldung: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context.
Legen Sie mit dem Befehl „export“ eine Umgebungsvariable fest, damit kubectl die richtige Konfiguration übernimmt.
```
export KUBECONFIG=./azurek8s
```
Überprüfen Sie die Integrität des Clusters mithilfe des Befehls „kubectl get nodes“.
```
kubectl get nodes
```
Beim Erstellen des Azure Linux-Containerhostclusters wurde die Überwachung aktiviert, um Integritätsmetriken für die Clusterknoten und die Pods zu erfassen. Diese Integritätsmetriken sind im Azure-Portal verfügbar. Weitere Informationen zur Überwachung der Integrität von Containern finden Sie unter Überwachen der Integrität von Azure Kubernetes Service.

Beim Anwenden des Terraform-Ausführungsplans wurden mehrere Schlüsselwerte ausgegeben. Beispielsweise werden die Hostadresse, der Benutzername und das Kennwort des Azure Linux-Containerhostclusters ausgegeben.

Führen Sie terraform output aus, um alle Ausgabewerte anzuzeigen. Führen Sie echo "$(terraform output <output_value_name>)" aus, um einen bestimmten Ausgabewert anzuzeigen.

Bereinigen von Ressourcen

Löschen von AKS-Ressourcen

Wenn Sie die mit Terraform erstellten Ressourcen nicht mehr benötigen, können Sie sie mithilfe der folgenden Schritte entfernen.

Führen Sie den Befehl „terraform plan“ aus, und geben Sie das destroy-Flag an.
```
terraform plan -destroy -out main.destroy.tfplan
```
Entfernen Sie den Ausführungsplan mithilfe des Befehls „terraform apply“.
```
terraform apply main.destroy.tfplan
```

Löschen eines Dienstprinzipals

Achtung

Löschen Sie den Dienstprinzipal, den Sie in dieser Demo verwendet haben, nur, wenn Sie ihn nicht für andere Zwecke verwenden.

Rufen Sie mit dem Befehl „az ad sp list“ die Objekt-ID des Dienstprinzipals ab.

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

Löschen Sie den Dienstprinzipal mithilfe des Befehls „az ad sp delete“.
```
az ad sp delete --id <service_principal_object_id>
```

Problembehandlung für Terraform in Azure

Behandeln Sie allgemeine Probleme bei der Verwendung von Terraform in Azure.

Nächste Schritte

In dieser Schnellstartanleitung haben Sie einen Azure Linux-Containerhostcluster bereitgestellt. Weitere Informationen zum Azure Linux-Containerhost und ein vollständiges Beispiel für die Clusterbereitstellung und -verwaltung finden Sie im Tutorial zum Azure Linux-Containerhost.

Tutorial zum Azure Linux-Containerhost

Freigeben über