Udostępnij za pośrednictwem

Szybki start: wdrażanie hosta kontenera systemu Linux platformy Azure dla klastra usługi AKS przy użyciu narzędzia Terraform

  • Artykuł

Rozpocznij pracę z hostem kontenera systemu Linux platformy Azure przy użyciu narzędzia Terraform, aby wdrożyć klaster hostów kontenerów systemu Linux platformy Azure. Po zainstalowaniu wymagań wstępnych należy zaimplementować kod programu Terraform, zainicjować program Terraform i utworzyć i zastosować plan wykonywania programu Terraform.

Narzędzie Terraform umożliwia definiowanie, wyświetlanie wersji zapoznawczej i wdrażanie infrastruktury chmury. Za pomocą narzędzia Terraform tworzysz pliki konfiguracji przy użyciu składni HCL. Składnia listy HCL umożliwia określenie dostawcy usług w chmurze i elementów tworzących infrastrukturę chmury. Po utworzeniu plików konfiguracji utworzysz plan wykonywania, który umożliwia wyświetlenie podglądu zmian infrastruktury przed ich wdrożeniem. Po zweryfikowaniu zmian należy zastosować plan wykonywania w celu wdrożenia infrastruktury.

Uwaga

Przykładowy kod w tym artykule znajduje się w repozytorium Microsoft Terraform GitHub.

Wymagania wstępne

Tworzenie pary kluczy SSH

Aby uzyskać dostęp do węzłów usługi AKS, należy nawiązać połączenie przy użyciu pary kluczy SSH (publicznej i prywatnej), która jest generowana przy użyciu ssh-keygen polecenia . Domyślnie te pliki są tworzone w katalogu ~/.ssh . ssh-keygen Uruchomienie polecenia zastępuje dowolną parę kluczy SSH o tej samej nazwie już istniejącej w danej lokalizacji.

  1. Przejdź do witryny , https://shell.azure.com aby otworzyć usługę Cloud Shell w przeglądarce.

  2. Uruchom polecenie ssh-keygen. Poniższy przykład tworzy parę kluczy SSH przy użyciu szyfrowania RSA i długości bitu 4096:

    ssh-keygen -t rsa -b 4096

Aby uzyskać więcej informacji na temat tworzenia kluczy SSH, zobacz Tworzenie kluczy SSH i zarządzanie nimi na potrzeby uwierzytelniania na platformie Azure.

Implementowanie kodu narzędzia Terraform

  1. Utwórz katalog, w którym chcesz przetestować przykładowy kod narzędzia Terraform i ustawić go jako bieżący katalog.

  2. Utwórz plik o nazwie providers.tf i wstaw następujący kod:

        terraform {
      required_version = ">=1.0"

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

    provider "azurerm" {
      features {}
    }

  3. Utwórz plik o nazwie main.tf i wstaw następujący kod:

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

    Podobnie można określić system Azure Linux os_sku w azurerm_kubernetes_cluster_node_pool.

  4. Utwórz plik o nazwie variables.tf i wstaw następujący kod:

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

  5. Utwórz plik o nazwie outputs.tf i wstaw następujący kod:

        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
    }

  6. Utwórz plik o nazwie terraform.tfvars i wstaw następujący kod:

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

Inicjowanie programu Terraform i tworzenie planu wykonania

  1. Zainicjuj narzędzie Terraform i pobierz moduły platformy Azure wymagane do zarządzania zasobami platformy Azure przy użyciu terraform init polecenia .

    terraform init

  2. Utwórz plan wykonywania narzędzia Terraform przy użyciu terraform plan polecenia .

    terraform plan -out main.tfplan

    Polecenie terraform plan tworzy plan wykonania, ale nie wykonuje go. Zamiast tego określa, jakie akcje są niezbędne do utworzenia konfiguracji określonej w plikach konfiguracji. Ten wzorzec umożliwia sprawdzenie, czy plan wykonania jest zgodny z oczekiwaniami przed wprowadzeniem jakichkolwiek zmian w rzeczywistych zasobach.

    Opcjonalny -out parametr umożliwia określenie pliku wyjściowego dla planu. Użycie parametru -out gwarantuje, że sprawdzony plan jest dokładnie tym, co jest stosowane.

    Aby dowiedzieć się więcej na temat utrwalania planów wykonywania i zabezpieczeń, zobacz ostrzeżenia dotyczące zabezpieczeń.

  3. Zastosuj plan wykonywania narzędzia Terraform przy użyciu terraform apply polecenia .

    terraform apply main.tfplan

    Powyższe terraform apply polecenie zakłada, że wcześniej uruchomiono terraform plan -out main.tfplanpolecenie . Jeśli określono inną nazwę pliku dla parametru -out , użyj tej samej nazwy pliku w wywołaniu metody terraform apply. Jeśli parametr nie został użyty, wywołaj metodę -out terraform apply bez żadnych parametrów.

Weryfikowanie wyników

  1. Pobierz nazwę grupy zasobów przy użyciu następującego echo polecenia.

    echo "$(terraform output resource_group_name)"

  2. Przejdź do witryny Azure Portal.

  3. W obszarze Usługi platformy Azure wybierz pozycję Grupy zasobów i znajdź nową grupę zasobów, aby wyświetlić następujące zasoby utworzone w tym pokazie:

    • Rozwiązanie: domyślnie pokazowe nazwy tego rozwiązania ContainerInsights. W portalu jest wyświetlana nazwa obszaru roboczego rozwiązania w nawiasie.
    • Usługa Kubernetes: domyślnie pokaz nazywa tę usługę k8stest. (Zarządzany klaster Kubernetes jest również nazywany usługą AKS/Azure Kubernetes Service).
    • Obszar roboczy usługi Log Analytics: domyślnie pokazowe nazwy tego obszaru roboczego z prefiksem TestLogAnalyticsWorkspaceName, a następnie liczbą losową.

  4. Pobierz konfigurację platformy Kubernetes ze stanu narzędzia Terraform i zapisz ją w pliku, który narzędzie kubectl może odczytać przy użyciu następującego echo polecenia.

    echo "$(terraform output kube_config)" > ./azurek8s

  5. Sprawdź, czy poprzednie polecenie nie dodało znaku EOT ASCII przy użyciu następującego cat polecenia.

    cat ./azurek8s

    Jeśli zobaczysz << EOT na początku i EOT na końcu, usuń te znaki z pliku. W przeciwnym razie może zostać wyświetlony następujący komunikat o błędzie: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context.

  6. Ustaw zmienną środowiskową, aby narzędzie kubectl pobiera poprawną konfigurację przy użyciu następującego export polecenia.

    export KUBECONFIG=./azurek8s

  7. Sprawdź kondycję klastra przy użyciu kubectl get nodes polecenia .

    kubectl get nodes

    Po utworzeniu klastra hostów kontenerów systemu Linux platformy Azure monitorowanie zostało włączone w celu przechwytywania metryk kondycji zarówno dla węzłów klastra, jak i zasobników. Te metryki kondycji są dostępne w witrynie Azure Portal. Aby uzyskać więcej informacji dotyczących monitorowania kondycji kontenera, zobacz Monitorowanie kondycji usługi Azure Kubernetes Service.

    Podczas stosowania planu wykonywania narzędzia Terraform zostało wyświetlonych kilka wartości kluczowych. Na przykład adres hosta, nazwa użytkownika klastra kontenera systemu Linux platformy Azure i hasło klastra hostów kontenerów systemu Linux platformy Azure są danymi wyjściowymi.

    Aby wyświetlić wszystkie wartości wyjściowe, uruchom polecenie terraform output. Aby wyświetlić określoną wartość wyjściową, uruchom polecenie echo "$(terraform output <output_value_name>)".

Czyszczenie zasobów

Usuwanie zasobów usługi AKS

Jeśli nie potrzebujesz już zasobów utworzonych za pomocą narzędzia Terraform, możesz je usunąć, wykonując następujące kroki.

  1. terraform plan Uruchom polecenie i określ flagędestroy.

    terraform plan -destroy -out main.destroy.tfplan

  2. Usuń plan wykonywania przy użyciu terraform apply polecenia .

    terraform apply main.destroy.tfplan

Usuwanie jednostki usługi

Uwaga

Usuń jednostkę usługi używaną w tym pokazie tylko wtedy, gdy nie używasz jej dla innych elementów.

  1. Pobierz identyfikator obiektu jednostki usługi przy użyciu az ad sp list polecenia

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

  2. Usuń jednostkę usługi przy użyciu az ad sp delete polecenia .

    az ad sp delete --id <service_principal_object_id>

Rozwiązywanie problemów z programem Terraform na platformie Azure

Rozwiązywanie typowych problemów podczas korzystania z programu Terraform na platformie Azure.

Następne kroki

W tym przewodniku Szybki start wdrożono klaster hostów kontenerów systemu Linux platformy Azure. Aby dowiedzieć się więcej na temat hosta kontenera systemu Linux platformy Azure i zapoznać się z kompletnym przykładem wdrażania klastra i zarządzania nim, przejdź do samouczka dotyczącego hosta kontenera systemu Linux platformy Azure.

Samouczek dotyczący usługi Azure Linux Container Host