Tworzenie klastra Kubernetes za pomocą narzędzia Azure Kubernetes Service pomocą narzędzia Terraform

Usługa Azure Kubernetes Service (AKS) zarządza hostowanym środowiskiem Kubernetes. AKS umożliwia wdrażanie konteneryzowanych aplikacji i zarządzanie nimi bez specjalistycznej wiedzy z zakresu orkiestracji kontenerów. Ponadto za pomocą usługi AKS można wykonać wiele typowych operacji konserwacji bez konieczności przechowania aplikacji w tryb offline. Te operacje obejmują aprowizowanie, uaktualnianie i skalowanie zasobów na żądanie.

W tym artykule omówiono sposób wykonywania następujących zadań:

  • Definiowanie klastra Kubernetes za pomocą języka HCL (HashiCorp Language)
  • Tworzenie klastra Kubernetes za pomocą narzędzia Terraform i usługi AKS
  • Testowanie dostępności klastra Kubernetes za pomocą narzędzia kubectl

1. Konfigurowanie środowiska

  • Subskrypcja platformy Azure: jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.
  • Jednostkę usługi platformy Azure: jeśli nie masz jednostki usługi, utwórz jednostkę usługi. Zanotuj wartości appId parametrów , displayName , i password tenant .

2. Tworzenie pary kluczy SSH

W przykładzie w tym artykule użyto pary kluczy SSH do zweryfikowania użytkownika na maszynie wirtualnej.

Wygeneruj parę kluczy SSH, korzystając z jednego z następujących artykułów w zależności od środowiska:

3. Tworzenie struktury katalogów

Pierwszym krokiem jest utworzenie katalogu, w którym będą przechowywane pliki konfiguracji narzędzia Terraform dla tego ćwiczenia.

  1. Otwórz wiersz polecenia, z którego można uruchamiać polecenia programu Terraform.

  2. Utwórz katalog o nazwie terraform-aks-k8s.

  3. Zmień katalog na nowy:

4. Deklarowanie dostawcy platformy Azure

Plik konfiguracji programu Terraform rozpoczyna się od specyfikacji dostawcy. W przypadku korzystania z platformy Azure należy określić dostawcę platformy Azure (azurerm) w provider bloku.

terraform {
  required_providers {
    azurerm = {
      source = "hashicorp/azurerm"
      version = "~>2.0"
    }
  }
}
provider "azurerm" {
  features {}
}
resource "azurerm_resource_group" "rg" {
  name = "<resource_group_name>"
  location = "<location>"
}

# Your Terraform code goes here...

Kluczowe punkty:

  • Chociaż atrybut version jest opcjonalny, firma HashiCorp zaleca przypinanie do danej wersji dostawcy.
  • Jeśli używasz dostawcy platformy Azure 1.x, features blok nie jest dozwolony.
  • Jeśli używasz dostawcy platformy Azure 2.x, features blok jest wymagany.
  • Deklaracja zasobu azurerm_resource_group dwa argumenty: name i location . Ustaw symbole zastępcze na odpowiednie wartości dla swojego środowiska.
  • Nazwana lokalna wartość dla grupy zasobów jest używana w artykułach z how-to-how i article podczas odwoływania się rg do grupy zasobów. Ta wartość jest niezależna od nazwy grupy zasobów i odwołuje się tylko do nazwy zmiennej w kodzie. Jeśli zmienisz tę wartość w definicji grupy zasobów, zmień ją również w kodzie, który się do niego odwołuje.

5. Definiowanie klastra Kubernetes

Utwórz plik konfiguracji narzędzia Terraform zawierający deklarację zasobów dla klastra Kubernetes.

  1. Utwórz plik o nazwie k8s.tf.

  2. Wstaw następujący kod do nowego pliku:

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

    Poprzedni kod ustawia nazwę klastra, lokalizację i nazwę grupy zasobów. Ustawiono również prefiks w pełni kwalifikowanej nazwy domeny (FQDN). Do uzyskiwania dostępu do klastra jest używana węzły FQDN.

    Rekord linux_profile umożliwia skonfigurowanie ustawień umożliwiających logowanie się do węzłów procesu roboczego przy użyciu SSH.

    W przypadku usługi AKS płacisz tylko za węzły procesu roboczego. Rekord default_node_pool konfiguruje szczegóły dla tych węzłów procesu roboczego. Zawiera default_node_pool record liczbę węzłów procesu roboczego do utworzenia oraz typ węzłów procesu roboczego. Jeśli w przyszłości konieczne będzie skalowanie klastra w górę lub w dół, zmodyfikuj count wartość w tym rekordzie.

6. Deklarowanie zmiennych

  1. Utwórz plik o variables.tf nazwie , który będzie zawierał zmienne projektu, i wstaw następujący kod:

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

7. Tworzenie pliku wyjściowego programu Terraform

Dane wyjściowe narzędzia Terraform umożliwiają definiowanie wartości, które będą wyróżnione dla użytkownika, gdy narzędzie Terraform zastosuje plan, i do których będzie można wysyłać zapytania za pomocą polecenia terraform output. W tej sekcji utworzysz plik wyjściowy umożliwiający uzyskanie dostępu do klastra za pomocą narzędzia kubectl.

  1. Utwórz plik o nazwie output.tf.

  2. Wstaw następujący kod do nowego pliku:

    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
    }
    

8. Konfigurowanie usługi Azure Storage do przechowywania stanu narzędzia Terraform

Narzędzie Terraform śledzi stan lokalnie za pośrednictwem pliku terraform.tfstate. Ten wzorzec sprawdza się dobrze w środowisku jednoosobowym. W środowisku wieloosobowym usługa Azure Storage służy do śledzenia stanu.

W tej sekcji przedstawiono sposób wykonywania następujących zadań:

  • Pobieranie informacji o koncie magazynu (nazwa konta i klucz konta)
  • Utwórz kontener magazynu, w którym będą przechowywane informacje o stanie terraform.
  1. W witrynie Azure Portal wybierz pozycję Wszystkie usługi z menu po lewej stronie.

  2. Wybierz pozycję Konta magazynu.

  3. Na karcie Konta usługi Storage wybierz nazwę konta magazynu, na którym ma być przechowywany stan narzędzia Terraform. Na przykład możesz skorzystać z konta magazynu utworzonego przy pierwszym otwarciu usługi Cloud Shell. Nazwa konta magazynu utworzonego przez usługę Cloud Shell zwykle zaczyna się od ciągu cs, po którym następuje losowy ciąg liter i cyfr. Zanotuj wybrane konto magazynu. Ta wartość będzie potrzebna później.

  4. Na karcie konta magazynu wybierz pozycję Klucze dostępu.

    Menu konta magazynu

  5. Zanotuj wartość klucza key1. (Wybranie ikony po prawej stronie klucza spowoduje skopiowanie wartości do schowka).

    Klucze dostępu konta magazynu

  6. Utwórz kontener na koncie usługi Azure Storage. Zastąp symbole zastępcze odpowiednimi wartościami dla twojego środowiska.

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

9. Tworzenie klastra Kubernetes

W tej sekcji zobaczysz, jak za pomocą polecenia utworzyć zasoby zdefiniowane w plikach konfiguracji utworzonych terraform init w poprzednich sekcjach.

  1. W Cloud Shell zaimicjuj program Terraform. Zastąp symbole zastępcze odpowiednimi wartościami dla twojego środowiska.

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

    Polecenie wyświetla powodzenie inicjowania wtyczki zaplecza i terraform init dostawcy:

    Przykładowe wyniki wykonania polecenia „terraform init”

  2. Wyeksportuj poświadczenia jednostki usługi. Zastąp symbole zastępcze odpowiednimi wartościami z jednostki usługi.

    export TF_VAR_client_id=<service-principal-appid>
    export TF_VAR_client_secret=<service-principal-password>
    
  3. Uruchom polecenie terraform plan, aby utworzyć plan narzędzia Terraform definiujący elementy infrastruktury.

    terraform plan -out out.plan
    

    Polecenie terraform plan spowoduje wyświetlenie zasobów, które zostaną utworzone po uruchomieniu polecenia terraform apply:

    Przykładowe wyniki wykonania polecenia „terraform plan”

  4. Uruchom polecenie terraform apply, aby zastosować plan w celu utworzenia klastra Kubernetes. Proces tworzenia klastra Kubernetes może potrwać kilka minut, co Cloud Shell limit czasu sesji. Jeśli Cloud Shell limit czasu sesji, możesz wykonać kroki opisane w sekcji "Odzyskiwanie po Cloud Shell limitu czasu", aby umożliwić ukończenie procesu.

    terraform apply out.plan
    

    Polecenie terraform apply spowoduje wyświetlenie wyników tworzenia zasobów zdefiniowanych w plikach konfiguracji:

    Przykładowe wyniki wykonania polecenia „terraform apply”

  5. W okienku Azure Portal pozycję Wszystkie zasoby w menu po lewej stronie, aby wyświetlić zasoby utworzone dla nowego klastra Kubernetes.

    Wszystkie zasoby w Azure Portal

10. Odzyskiwanie po Cloud Shell limitu czasu

Jeśli Cloud Shell przejmie czas sesji, możesz wykonać następujące kroki, aby odzyskać:

  1. Uruchom sesję usługi Cloud Shell.

  2. Przejdź do katalogu zawierającego pliki konfiguracji narzędzia Terraform.

    cd /clouddrive/terraform-aks-k8s
    
  3. Uruchom następujące polecenie:

    export KUBECONFIG=./azurek8s
    

11. Testowanie klastra Kubernetes

Nowo utworzony klaster można sprawdzić za pomocą narzędzi usługi Kubernetes.

  1. Pobierz konfigurację usługi Kubernetes ze stanu narzędzia Terraform i zapisz ją w pliku możliwym do odczytania przez narzędzie kubectl.

    echo "$(terraform output kube_config)" > ./azurek8s
    
  2. Ustaw zmienną środowiskową tak, aby narzędzie kubectl pobrało poprawną konfigurację.

    export KUBECONFIG=./azurek8s
    
  3. Sprawdź kondycję klastra.

    kubectl get nodes
    

    Powinny zostać wyświetlone szczegóły węzłów procesu roboczego. Wszystkie one powinny mieć stan Gotowy, jak pokazano na poniższej ilustracji:

    Narzędzie kubectl umożliwia sprawdzenie kondycji klastra Kubernetes

12. Monitorowanie kondycji i dzienników

Podczas tworzenia klastra AKS włączono monitorowanie, aby przechwycić metryki kondycji dla zasobników i węzłów klastra. 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.

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