Skapa ett Kubernetes-kluster med Azure Kubernetes Service terraform

Azure Kubernetes Service (AKS) hanterar din värdbaserade Kubernetes-miljö. Med AKS kan du distribuera och hantera program i containrar utan expertkunskaper om containerorkestrering. Med AKS kan du också utföra många vanliga underhållsåtgärder utan att ta appen offline. Dessa åtgärder omfattar etablering, uppgradering och skalning av resurser på begäran.

I den här artikeln kan du se hur du:

• Använda HCL (HashiCorp Language) för att definiera ett Kubernetes-kluster
• Använda Terraform och AKS för att skapa ett Kubernetes-kluster
• Använda verktyget kubectl för att testa tillgängligheten för ett Kubernetes-kluster

1. Konfigurera din miljö

• Azure-prenumeration: Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.

• Konfigurera Terraform: Om du inte redan har gjort det konfigurerar du Terraform med något av följande alternativ:

  • Konfigurera Terraform i Azure Cloud Shell med Bash
  • Konfigurera Terraform i Azure Cloud Shell med PowerShell
  • Konfigurera Terraform i Windows med Bash
  • Konfigurera Terraform i Windows med PowerShell

• Azure-tjänstenshuvudnamn: Om du inte har ett huvudnamn för tjänsten skapar du ett huvudnamn för tjänsten. Anteckna värdena för appId , displayName , och passwordtenant .

2. Skapa ett SSH-nyckelpar

Exemplet i den här artikeln använder ett SSH-nyckelpar för att verifiera användaren till den virtuella datorn.

Generera ett SSH-nyckelpar med någon av följande artiklar beroende på din miljö:

• Portal
• Windows
• Linux/MacOS

3. Skapa katalogstrukturen

Det första steget är att skapa katalogen som innehåller Terraform-konfigurationsfilerna för övningen.

1. Öppna en kommandotolk där du kan köra Terraform-kommandon.

2. Skapa en katalog som heter terraform-aks-k8s.

3. Ändra sökvägen till den nya katalogen:

4. Deklarera Azure-providern

En Terraform-konfigurationsfil börjar med leverantörens specifikation. När du använder Azure anger du Azure-providern (azurerm) i blocket.

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...

Viktiga punkter:

• Även om version attributet är valfritt rekommenderar HashiCorp att du fäster till en viss version av providern.
• Om du använder Azure-providern 1.x features tillåts inte blocket.
• Om du använder Azure-providern 2.x features krävs blocket.
• Resursdeklarationen förazurerm_resource_group två argument: och . Ange platshållarna till lämpliga värden för din miljö.
• Det lokala namngivna värdet för för resursgruppen används i alla artiklar om i - och -artiklar när du refererar till resursgruppen. Det här värdet är oberoende av resursgruppens namn och refererar endast till variabelnamnet i koden. Om du ändrar det här värdet i resursgruppsdefinitionen ändrar du det också i koden som refererar till det.

5. Definiera ett Kubernetes-kluster

Skapa Terraform-konfigurationsfilen som deklarerar resurserna för Kubernetes-klustret.

1. Skapa en fil som heter k8s.tf.

2. Infoga följande kod i den nya filen:

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

   Koden ovan anger namnet på klustret, platsen och resursgruppens namn. Prefixet för det fullständigt kvalificerade domännamnet (FQDN) anges också. FQDN används för att komma åt klustret.

   Med linux_profile posten kan du konfigurera inställningarna som aktiverar inloggning till arbetsnoderna med hjälp av SSH.

   Med AKS betalar du bara för arbetarnoderna. Posten default_node_pool konfigurerar informationen för dessa arbetsnoder. default_node_pool recordinnehåller antalet arbetsnoder som ska skapas och typen av arbetsnoder. Om du behöver skala upp eller ned klustret i framtiden ändrar du värdet count i den här posten.

6. Deklarera variablerna

1. Skapa en fil med variables.tf namnet som ska innehålla projektvariablerna och infoga följande 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. Skapa en Terraform-utdatafil

Med Terraform-utdata kan du definiera värden som markeras för användaren när en plan används i Terraform och kan hämtas med kommandot . I det här avsnittet skapar du en utdatafil som tillåter åtkomst till klustret med kubectl.

1. Skapa en fil som heter output.tf.

2. Infoga följande kod i den nya filen:

   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
       sensitive = true
   }
   
   output "host" {
       value = azurerm_kubernetes_cluster.k8s.kube_config.0.host
   }
   

8. Konfigurera Azure Storage för att lagra Terraform-tillstånd

Terraform spårar tillstånd lokalt via filen terraform.tfstate. Det här mönstret fungerar bra i en miljö med en enda person. I en miljö med flera personer används Azure Storage för att spåra tillstånd.

I det här avsnittet ser du hur du utför följande uppgifter:

• Hämta lagringskontoinformation (kontonamn och kontonyckel)
• Skapa en lagringscontainer där Terraform-tillståndsinformation ska lagras.

1. I Azure-portalen väljer du Alla tjänster i vänstermenyn.

2. Välj Lagringskonton.

3. På fliken Lagringskonton väljer du namnet på det lagringskonto där Terraform ska lagra tillstånd. Du kan till exempel använda lagringskontot som skapades när du öppnade Cloud Shell första gången. Lagringskontonamnet som skapades av Cloud Shell börjar vanligtvis med cs följt av en slumpmässig sträng med siffror och bokstäver. Anteckna det lagringskonto som du väljer. Det här värdet behövs senare.

4. Välj Åtkomstnycklar på fliken för lagringskonto.

   

5. Anteckna nyckelvärdet för key1. (Om du väljer ikonen till höger om nyckeln kopieras värdet till Urklipp.)

   

6. Skapa en container i ditt Azure Storage-konto. Ersätt platshållarna med lämpliga värden för din miljö.

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

9. Skapa Kubernetes-klustret

I det här avsnittet får du se hur du använder kommandot för att skapa de resurser som definierats i terraform init konfigurationsfilerna som du skapade i föregående avsnitt.

1. Initiera Terraform i Cloud Shell. Ersätt platshållarna med lämpliga värden för din miljö.

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

   Kommandot terraform init visar hur du initierar plugin-programmet för backend och providern:

   

2. Exportera autentiseringsuppgifterna för tjänstens huvudnamn. Ersätt platshållarna med lämpliga värden från tjänstens huvudnamn.

   export TF_VAR_client_id=<service-principal-appid>
   export TF_VAR_client_secret=<service-principal-password>
   

3. Kör kommandot terraform plan för att skapa Terraform-planen som definierar infrastrukturelementen.

   terraform plan -out out.plan
   

   Kommandot terraform plan visar resurserna som kommer att skapas när du kör kommandot terraform apply:

   

4. Kör kommandot terraform apply för att tillämpa planen för att skapa Kubernetes-klustret. Processen för att skapa ett Kubernetes-kluster kan ta flera minuter, vilket resulterar i att Cloud Shell-sessionen tar slut. Om tidsgränsen Cloud Shell tidsgränsen för sessionen kan du följa stegen i avsnittet "Återställa från en Cloud Shell tidsgräns" så att du kan slutföra processen.

   terraform apply out.plan
   

   Kommandot terraform apply visar resultatet av att skapa resurserna som definierats i konfigurationsfilerna:

   

5. I menyn Azure Portal du Alla resurser på den vänstra menyn för att se de resurser som skapats för ditt nya Kubernetes-kluster.

   

10. Återställa från en Cloud Shell tidsgräns

Om Cloud Shell-sessionens slut kan du utföra följande steg för att återställa:

1. Starta en Cloud Shell-session.

2. Ändra till katalogen som innehåller dina Terraform-konfigurationsfiler.

   cd /clouddrive/terraform-aks-k8s
   

3. Kör följande kommando:

   export KUBECONFIG=./azurek8s
   

11. Testa Kubernetes-klustret

Kubernetes-verktygen kan användas för att verifiera det nyligen skapade klustret.

1. Hämta Kubernetes-konfigurationen från Terraform-tillståndet och lagra den i en fil som kubectl kan läsa.

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

2. Kontrollera att det föregående kommandot inte har lagt till ett EOT ASCII-tecken

   cat ./azurek8s
   

   Om du ser << EOT i början och slutet redigerar du innehållet i filen för att ta bort EOT dessa. Detta är nödvändigt, annars kan du få följande meddelande: error: error loading config file "./azurek8s": yaml: line 2: mapping values ​​are not allowed in this context

3. Ange en miljövariabel så att kubectl hämtar korrekt konfiguration.

   export KUBECONFIG=./azurek8s
   

4. Kontrollera klustrets hälsotillstånd.

   kubectl get nodes
   

   Du bör se information för dina arbetarnoder och de bör ha statusen Ready enligt följande bild:

   

12. Övervaka hälsotillstånd och loggar

När AKS-klustret skapades aktiverades övervakning för att registrera hälsomått för både klusternoderna och poddarna. De här hälsomåtten är tillgängliga i Azure-portalen. Mer information om övervakning av hälsotillstånd för containrar finns i Övervaka hälsotillstånd för Azure Kubernets Service.

Felsöka Terraform på Azure

Felsöka vanliga problem när du använder Terraform på Azure

Nästa steg