Szybki przewodnik: Wdrożenie hosta kontenera Linux w Azure dla klastra AKS za pomocą Terraform

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 HCL umożliwia określenie dostawcy usług w chmurze i elementów tworzących infrastrukturę chmurową. 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.

Ważne

Od 30 listopada 2025 r. usługa Azure Kubernetes Service (AKS) nie obsługuje już ani nie zapewnia aktualizacji zabezpieczeń dla systemu Azure Linux 2.0. Obraz węzła systemu Linux 2.0 platformy Azure został zamrożony w wersji 202512.06.0. Od 31 marca 2026 r. obrazy węzłów zostaną usunięte i nie będzie można skalować pul węzłów. Przeprowadź migrację do obsługiwanej wersji systemu Linux platformy Azure, uaktualniając pule węzłów do obsługiwanej wersji rozwiązania Kubernetes lub migrując do systemu osSku AzureLinux3. Aby uzyskać więcej informacji, zobacz Wycofywanie: pule węzłów Linux 2.0 platformy Azure w usłudze AKS.

Wymagania wstępne

Jeśli nie masz jeszcze konta platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.
Jeśli program Terraform nie został jeszcze skonfigurowany, możesz to zrobić przy użyciu jednej z następujących opcji:
Jeśli nie masz głównej usługi platformy Azure, utwórz główną usługę. Zanotuj wartości appId, , display_namepasswordi tenant.
Potrzebujesz narzędzia wiersza polecenia Kubernetes. Jeśli go nie masz, pobierz narzędzie kubectl.

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.

Przejdź do witryny , https://shell.azure.com aby otworzyć usługę Cloud Shell w przeglądarce.
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

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

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

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.

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

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
    }

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

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
```
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ń.
Zastosuj plan wykonywania narzędzia Terraform przy użyciu polecenia terraform apply.
```
terraform apply main.tfplan
```
Powyższe polecenie terraform apply zakłada, że wcześniej uruchomiono terraform plan -out main.tfplan. Jeśli określono inną nazwę pliku dla parametru -out , użyj tej samej nazwy pliku w wywołaniu metody terraform apply. Jeśli nie użyłeś parametru -out, wywołaj terraform apply bez żadnych parametrów.

Weryfikowanie wyników

Pobierz nazwę grupy zasobów przy użyciu następującego echo polecenia.
```
echo "$(terraform output resource_group_name)"
```
Przejdź do witryny Azure Portal.
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 demo nazywa to rozwiązanie ContainerInsights. W portalu nazwa obszaru roboczego rozwiązania jest wyświetlana w nawiasie.
- Usługa Kubernetes: domyślnie demo 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 demonstracje nadają temu obszarowi roboczemu nazwę z prefiksem TestLogAnalyticsWorkspaceName-, po którym następuje liczba losowa.
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
```
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.
Ustaw zmienną środowiskową, aby narzędzie kubectl pobiera poprawną konfigurację przy użyciu następującego export polecenia.
```
export KUBECONFIG=./azurek8s
```
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.

terraform plan Uruchom polecenie i określ flagędestroy.
```
terraform plan -destroy -out main.destroy.tfplan
```
Usuń plan wykonywania przy użyciu terraform apply polecenia .
```
terraform apply main.destroy.tfplan
```

Usuwanie jednostki usługi

Uwaga

Usuń konto usługi, z którego korzystałeś w tym demo, tylko jeśli nie używasz go do niczego innego.

Pobierz identyfikator obiektu jednostki usługi za pomocą polecenia az ad sp list

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

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 szybkim starcie wdrożono klaster hostów kontenerowych Linux na platformie 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

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-09-11