Snabbstart: Konfigurera en valvsäkerhetskopia för ett AKS-kluster (Azure Kubernetes Service) med Terraform

Den här snabbstarten beskriver hur du konfigurerar en valvsäkerhetskopia för ett AKS-kluster (Azure Kubernetes Service) med Terraform.

Azure Backup för AKS är en molnbaserad, företagsklar, programcentrerad säkerhetskopieringstjänst som gör att du snabbt kan konfigurera säkerhetskopiering för AKS-kluster.

Förutsättningar

Saker att se till innan du konfigurerar AKS-säkerhetskopiering:

• Den här snabbstarten förutsätter grundläggande kunskaper om Kubernetes-begrepp. Mer information finns i [Kubernetes core concepts for Azure Kubernetes Service (AKS)][kubernetes-concepts].

• Du behöver ett Azure-konto med en aktiv prenumeration. Om du inte har något skapar du ett konto kostnadsfritt.

• Installera och konfigurera Terraform.

• Ladda ned kubectl.

• Skapa ett slumpmässigt värde för Azure-resursgruppens namn med hjälp av random_pet.

• Skapa en Azure-resursgrupp med hjälp av azurerm_resource_group.

• Få åtkomst till konfigurationen av AzureRM-leverantören för att hämta Azure-objekt-ID med azurerm_client_config.

• Skapa ett Kubernetes-kluster med .azurerm_kubernetes_cluster

• Skapa en AzAPI-resurs med .azapi_resource

• Skapa ett lagringskonto med .azurerm_storage_account

• Skapa en blobcontainer med azurerm_storage_container.

• Installera säkerhetskopieringstillägget i AKS-klustret med hjälp av azurerm_kubernetes_cluster_extension".

• Skapa ett Säkerhetskopieringsvalv med .azurerm_data_protection_backup_vault

• Skapa en säkerhetskopieringsprincip för AKS-kluster med azurerm_data_protection_backup_vault.

• Aktivera betrodd åtkomst mellan AKS-kluster och Backup-valv med hjälp av azurerm_kubernetes_cluster_trusted_access_role_binding.

• Aktivera rolltilldelningar med hjälp av azurerm_role_assignment.

• Konfigurera säkerhetskopiering för ett AKS-kluster med .azurerm_data_protection_backup_policy_kubernetes_cluster

Logga in på Azure-konto

Logga in på ditt Azure-konto och autentisera med någon av följande metoder:

Terraform stöder endast autentisering till Azure med Azure CLI. Autentisering med Azure PowerShell stöds inte. Även om du kan använda Azure PowerShell-modulen när du utför ditt Terraform-arbete måste du därför först autentisera till Azure.

Utför implementeringen av Terraform-koden

Kör följande skript för att implementera Terraform-koden för AKS-säkerhetskopieringsflödet:

1. Skapa en katalog som du kan använda för att testa Terraform-exempelkoden och göra den till din aktuella katalog.

2. Skapa en fil med namnet providers.tf och infoga följande kod:

   terraform {
     required_providers {
       azurerm = {
         source = "hashicorp/azurerm"
         version = "3.99.0"
       }
     }
   }
   
   provider "azurerm" {
      features {}
      subscription_id   = "<azure_subscription_id>"
      tenant_id = "<azure_subscription_tenant_id>"
   }
   

3. Skapa en fil med namnet main.tf och infoga följande kod:

    #Get Subscription and Tenant Id from Config
   
   data "azurerm_client_config" "current" {
   }
   
   #Create a Resource Group where Backup Vault and AKS Cluster will be created
   resource "azurerm_resource_group" "rg" {
     location = var.resource_group_location
     name     = var.resource_group_name
   }
   
   #Create a Resource Group where Storage Account and Snapshots related to backup will be created
   resource "azurerm_resource_group" "backuprg" {
     location = var.backup_resource_group_location
     name = var.backup_resource_group_name
   }
   
   #Create an AKS Cluster 
   resource "azurerm_kubernetes_cluster" "akscluster" {
     resource_group_name = azurerm_resource_group.rg.name
     name           = var.aks_cluster_name
     location       = azurerm_resource_group.rg.location
     dns_prefix     = var.dns_prefix
   
     identity {
       type = "SystemAssigned"
     }
   
     default_node_pool {
       name       = "agentpool"
       vm_size    = "Standard_D2_v2"
       node_count = var.node_count
     }
   
     network_profile {
       network_plugin    = "kubenet"
       load_balancer_sku = "standard"
     }
   
     depends_on = [azurerm_resource_group.rg,azurerm_resource_group.backuprg]
   }
   
   #Create a Backup Vault
   resource "azurerm_data_protection_backup_vault" "backupvault" {
     name                = var.backupvault_name
     resource_group_name = resource.azurerm_resource_group.rg.name
     location            = resource.azurerm_resource_group.rg.location
     datastore_type      = var.datastore_type
     redundancy          = var.redundancy
   
     identity {
       type = "SystemAssigned"
     }
     depends_on = [azurerm_kubernetes_cluster.akscluster]
   }
   
   #Create a Backup Policy with 4 hourly backups and 7 day retention duration
   resource "azurerm_data_protection_backup_policy_kubernetes_cluster" "policy" {
     name                = var.backuppolicy_name
     resource_group_name = var.resource_group_name
     vault_name          = var.backupvault_name
   
     backup_repeating_time_intervals = ["R/2024-04-14T06:33:16+00:00/PT4H"]
     default_retention_rule {
       life_cycle {
         duration        = "P7D"
         data_store_type = "OperationalStore"
       }
     }
   depends_on = [resource.azurerm_data_protection_backup_vault.backupvault]
   }
   
   #Create a Trusted Access Role Binding between AKS Cluster and Backup Vault
   resource "azurerm_kubernetes_cluster_trusted_access_role_binding" "trustedaccess" {
     kubernetes_cluster_id = azurerm_kubernetes_cluster.akscluster.id
     name                  = "backuptrustedaccess"
     roles                 = ["Microsoft.DataProtection/backupVaults/backup-operator"]
     source_resource_id    = azurerm_data_protection_backup_vault.backupvault.id
     depends_on = [resource.azurerm_data_protection_backup_vault.backupvault, azurerm_kubernetes_cluster.akscluster]
   }
   
   #Create a Backup Storage Account provided in input for Backup Extension Installation
   resource "azurerm_storage_account" "backupsa" {
     name                     = "tfaksbackup1604"
     resource_group_name      = azurerm_resource_group.backuprg.name
     location                 = azurerm_resource_group.backuprg.location
     account_tier             = "Standard"
     account_replication_type = "LRS"
     depends_on = [azurerm_kubernetes_cluster_trusted_access_role_binding.trustedaccess]
   }
   
   #Create a Blob Container where backup items will stored
   resource "azurerm_storage_container" "backupcontainer" {
     name                  = "tfbackup"
     storage_account_name  = azurerm_storage_account.backupsa.name
     container_access_type = "private"
     depends_on = [azurerm_storage_account.backupsa]
   }
   
   #Create Backup Extension in AKS Cluster
   resource "azurerm_kubernetes_cluster_extension" "dataprotection" {
     name = var.backup_extension_name
     cluster_id = azurerm_kubernetes_cluster.akscluster.id
     extension_type = var.backup_extension_type
     configuration_settings = {
       "configuration.backupStorageLocation.bucket" = azurerm_storage_container.backupcontainer.name
        "configuration.backupStorageLocation.config.storageAccount" = azurerm_storage_account.backupsa.name
        "configuration.backupStorageLocation.config.resourceGroup" = azurerm_storage_account.backupsa.resource_group_name
        "configuration.backupStorageLocation.config.subscriptionId" =  data.azurerm_client_config.current.subscription_id
        "credentials.tenantId" = data.azurerm_client_config.current.tenant_id
        "configuration.backupStorageLocation.config.useAAD" = true
        "configuration.backupStorageLocation.config.storageAccountURI" = azurerm_storage_account.backupsa.primary_blob_endpoint
       }
     depends_on = [azurerm_storage_container.backupcontainer]
   }
   
   #Assign Role to Extension Identity over Storage Account
   resource "azurerm_role_assignment" "extensionrole" {
     scope                = azurerm_storage_account.backupsa.id
     role_definition_name = "Storage Blob Data Contributor"
     principal_id         = azurerm_kubernetes_cluster_extension.dataprotection.aks_assigned_identity[0].principal_id
     depends_on = [azurerm_kubernetes_cluster_extension.dataprotection]
   }
   
   #Assign Role to Backup Vault over AKS Cluster
   resource "azurerm_role_assignment" "vault_msi_read_on_cluster" {
     scope                = azurerm_kubernetes_cluster.akscluster.id
     role_definition_name = "Reader"
     principal_id         = azurerm_data_protection_backup_vault.backupvault.identity[0].principal_id
     depends_on = [azurerm_kubernetes_cluster.akscluster,resource.azurerm_data_protection_backup_vault.backupvault]
   }
   
   #Assign Role to Backup Vault over Snapshot Resource Group
   resource "azurerm_role_assignment" "vault_msi_read_on_snap_rg" {
     scope                = azurerm_resource_group.backuprg.id
     role_definition_name = "Reader"
     principal_id         = azurerm_data_protection_backup_vault.backupvault.identity[0].principal_id
     depends_on = [azurerm_kubernetes_cluster.akscluster,resource.azurerm_data_protection_backup_vault.backupvault]
   }
   
   #Assign Role to AKS Cluster over Snapshot Resource Group
   resource "azurerm_role_assignment" "cluster_msi_contributor_on_snap_rg" {
     scope                = azurerm_resource_group.backuprg.id
     role_definition_name = "Contributor"
     principal_id         = try(azurerm_kubernetes_cluster.akscluster.identity[0].principal_id,null)
     depends_on = [azurerm_kubernetes_cluster.akscluster,resource.azurerm_kubernetes_cluster.akscluster,resource.azurerm_resource_group.backuprg]
   }
   
   #Create Backup Instance for AKS Cluster
   resource "azurerm_data_protection_backup_instance_kubernetes_cluster" "akstfbi" {
     name                         = "example"
     location                     = azurerm_resource_group.backuprg.location
     vault_id                     = azurerm_data_protection_backup_vault.backupvault.id
     kubernetes_cluster_id        = azurerm_kubernetes_cluster.akscluster.id
     snapshot_resource_group_name = azurerm_resource_group.backuprg.name
     backup_policy_id             = azurerm_data_protection_backup_policy_kubernetes_cluster.policy.id
   
     backup_datasource_parameters {
       excluded_namespaces              = []
       excluded_resource_types          = []
       cluster_scoped_resources_enabled = true
       included_namespaces              = []
       included_resource_types          = []
       label_selectors                  = []
       volume_snapshot_enabled          = true
     }
   
     depends_on = [
       resource.azurerm_data_protection_backup_vault.backupvault,
       azurerm_data_protection_backup_policy_kubernetes_cluster.policy,
       azurerm_role_assignment.extensionrole,
       azurerm_role_assignment.vault_msi_read_on_cluster,
       azurerm_role_assignment.vault_msi_read_on_snap_rg,
       azurerm_role_assignment.cluster_msi_contributor_on_snap_rg
     ]
   }
   

4. Skapa en fil med namnet variables.tf och infoga följande kod:

   variable "aks_cluster_name" {
     type        = string
     default     = "Contoso_AKS_TF"
     description = "Name of the AKS Cluster."
   }
   
   variable "backup_extension_name" {
     type        = string
     default     = "azure-aks-backup"
     description = "Name of the AKS Cluster Extension."
   }
   
   variable "backup_extension_type" {
     type        = string
     default     = "microsoft.dataprotection.kubernetes"
     description = "Type of the AKS Cluster Extension."
   }
   
   variable "dns_prefix" {
     type        = string
     default     = "contoso-aks-dns-tf"
     description = "DNS Name of AKS Cluster made with Terraform"
   }
   
   variable "node_count" {
     type        = number
     description = "The initial quantity of nodes for the node pool."
     default     = 3
   }
   
   variable "resource_group_location" {
     type        = string
     default     = "eastus"
     description = "Location of the resource group."
   }
   
   variable "backup_resource_group_name" {
     type        = string
     default     = "Contoso_TF_Backup_RG"
     description = "Location of the resource group."
   }
   
   variable "backup_resource_group_location" {
     type        = string
     default     = "eastus"
     description = "Location of the resource group."
   }
   
   variable "resource_group_name" {
     type        = string
     default     = "Contoso_TF_RG"
     description = "Location of the resource group."
   }
   
   variable "cluster_id" {
     type        = string
     default     = "/subscriptions/c3d3eb0c-9ba7-4d4c-828e-cb6874714034/resourceGroups/Contoso_TF_RG/providers/Microsoft.ContainerService/managedClusters/Contoso_AKS_TF"
     description = "Location of the resource group."
   }
   
   variable "backupvault_name" {
     type        = string
     default     = "BackupVaultTF"
     description = "Name of the Backup Vault"
   }
   
   variable "datastore_type" {
     type        = string
     default     = "OperationalStore"
   }
   
   variable "redundancy" {
     type        = string
     default     = "LocallyRedundant"
   }
   
   variable "backuppolicy_name" {
     type        = string
     default     = "aksbackuppolicytfv1"
   }
   

5. Skapa en fil med namnet outputs.tf och infoga följande kod:

    output "aks_resource_group" {
      value = azurerm_resource_group.rg.name
    }
   
    output "snapshot_resource_group" {
      value = azurerm_resource_group.backuprg.name
    }
   
    output "kubernetes_cluster_name" {
      value = azurerm_kubernetes_cluster.akscluster.name
    }
   
    output "backup_vault_name" {
      value = azurerm_data_protection_backup_vault.backupvault.name
    }
   
    output "backup_instance_id" {
      value = azurerm_data_protection_backup_instance_kubernetes_cluster.akstfbi.id
    }
   

Initiera Terraform

Kör terraform init för att initiera Terraform-distributionen. Det här kommandot laddar ned den Azure-provider som krävs för att hantera dina Azure-resurser.

terraform init -upgrade

Viktiga punkter:

• Parametern -upgrade uppgraderar nödvändiga provider-plugin-program till den senaste versionen som uppfyller konfigurationens versionsbegränsningar.

Skapa en Terraform-utförandeplan

Kör terraform plan för att skapa en exekveringsplan.

terraform plan -out main.tfplan

Viktiga punkter:

• Kommandot terraform plan skapar en utförandeplan, men utför den inte. I stället avgör den vilka åtgärder som krävs för att skapa den konfiguration som anges i konfigurationsfilerna. Med det här mönstret kan du kontrollera om åtgärdsplanen stämmer överens med dina förväntningar innan du gör några ändringar i faktiska resurser.
• Med den valfria -out parametern kan du ange en utdatafil för planen. Med hjälp av parametern -out ser du till att planen du granskade är exakt vad som tillämpas.

Tillämpa en Terraform-utförandeplan

Kör terraform apply för att tillämpa körningsplanen på din molninfrastruktur.

terraform apply main.tfplan

Viktiga punkter:

• terraform apply Exempelkommandot förutsätter att du tidigare körde terraform plan -out main.tfplan.
• Om du har angett ett annat filnamn för parametern -out använder du samma filnamn i anropet till terraform apply.
• Om du inte använde parametern -out anropar terraform apply du utan några parametrar.

Felsöka Terraform i Azure

När du använder Terraform i Azure kan du stöta på vanliga problem. Lär dig hur du felsöker.

Gå vidare

I den här snabbstarten har du lärt dig hur du distribuerar ett Kubernetes-kluster, skapar ett säkerhetskopieringsvalv och konfigurerar säkerhetskopiering för Kubernetes-klustret.

Läs mer om: