Guida introduttiva: Configurare il backup con insieme di credenziali per un cluster servizio Azure Kubernetes (AKS) con Terraform

Questa guida introduttiva descrive come configurare il backup con insieme di credenziali per un cluster del servizio Azure Kubernetes (servizio Azure Kubernetes AKS) con Terraform.

Backup di Azure per il servizio Azure Kubernetes è un servizio di backup incentrato sulle applicazioni, di livello aziendale e nativo del cloud che consente di configurare rapidamente il backup per i cluster del servizio Azure Kubernetes.

Prerequisiti

Elementi da verificare prima di configurare il backup del servizio Azure Kubernetes:

• Questa guida introduttiva presuppone una comprensione di base dei concetti relativi a Kubernetes. Per altre informazioni, vedere i [concetti di base relativi a Kubernetes per il servizio Azure Kubernetes][kubernetes-concepts].

• È necessario un account Azure con una sottoscrizione attiva. Se non si dispone di un account, crearne uno gratuitamente.

• Installa e configura Terraform.

• Scaricare kubectl.

• Creare un valore casuale per il nome del gruppo di risorse di Azure usando random_pet.

• Creare un gruppo di risorse di Azure usando azurerm_resource_group.

• Accedere alla configurazione del provider AzureRM per ottenere l'ID oggetto di Azure usando azurerm_client_config.

• Creare un cluster Kubernetes usando azurerm_kubernetes_cluster.

• Creare una risorsa AzAPI usando azapi_resource.

• Creare un account di archiviazione usando azurerm_storage_account.

• Creare un contenitore BLOB usando azurerm_storage_container.

• Installare l'estensione Backup di Azure nel cluster del servizio Azure Kubernetes usando azurerm_kubernetes_cluster_extension`.

• Creare un insieme di credenziali di Backup usando azurerm_data_protection_backup_vault.

• Creare un criterio di backup per il cluster del servizio Azure Kubernetes usando azurerm_data_protection_backup_vault.

• Abilitare l'accesso attendibile tra il cluster del servizio Azure Kubernetes e l'insieme di credenziali di Backup usando azurerm_kubernetes_cluster_trusted_access_role_binding.

• Abilitare le assegnazioni di ruolo usando azurerm_role_assignment.

• Configurare Backup per un cluster del servizio Azure Kubernetes usando azurerm_data_protection_backup_policy_kubernetes_cluster.

Accedere all'account Azure

Accedere all'account Azure ed eseguire l'autenticazione usando uno dei metodi seguenti:

Terraform supporta l'autenticazione in Azure solo con l'interfaccia della riga di comando di Azure. L'autenticazione con Azure PowerShell non è supportata. Pertanto, anche se è possibile usare il modulo Azure PowerShell quando si esegue il lavoro di Terraform, è prima necessario eseguire l'autenticazione in Azure.

Implementare il codice Terraform

Per implementare il codice Terraform per il flusso di backup del servizio Azure Kubernetes, eseguire gli script seguenti:

1. Creare una directory che è possibile usare per testare il codice Terraform di esempio e impostarlo come directory corrente.

2. Creare un file denominato providers.tf e inserire il codice seguente:

   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. Creare un file denominato main.tf e inserire il codice seguente:

    #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
       }
     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 Account 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. Creare un file denominato variables.tf e inserire il codice seguente:

   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. Creare un file denominato outputs.tf e inserire il codice seguente:

    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
    }
   

Inizializzare Terraform

Per inizializzare la distribuzione di Terraform, eseguire terraform init. Questo comando scarica il provider di Azure necessario per gestire le risorse di Azure.

terraform init -upgrade

Punti principali:

• Il parametro -upgrade aggiorna i plug-in del provider necessari alla versione più recente conforme ai vincoli di versione della configurazione.

Creare un piano di esecuzione Terraform

Eseguire terraform plan per creare un piano di esecuzione.

terraform plan -out main.tfplan

Punti principali:

• Il comando terraform plan consente di creare un piano di esecuzione, ma non di eseguirlo. Determina invece le azioni necessarie per creare la configurazione specificata nei file di configurazione. Questo modello consente di verificare se il piano di esecuzione corrisponde alle aspettative prima di apportare modifiche alle risorse effettive.
• Il parametro -out facoltativo consente di specificare un file di output per il piano. L'uso del parametro -out garantisce che il piano esaminato sia esattamente quello che viene applicato.

Applicare un piano di esecuzione Terraform

Eseguire terraform apply per applicare il piano di esecuzione all'infrastruttura cloud.

terraform apply main.tfplan

Punti principali:

• Il comando terraform apply di esempio presuppone che in precedenza sia stato eseguito terraform plan -out main.tfplan.
• Se è stato specificato un nome file diverso per il parametro -out, usare lo stesso nome file nella chiamata a terraform apply.
• Se non è stato usato il parametro -out, chiamare terraform apply senza parametri.

Risolvere i problemi di Terraform in Azure

Quando si usa Terraform in Azure, è possibile riscontrare problemi comuni. Informazioni sulla risoluzione dei problemi.

Passaggio successivo

In questo argomento di avvio rapido si è appreso come distribuire un cluster Kubernetes, creare un insieme di credenziali di Backup e configurare il backup per il cluster Kubernetes.

Altre informazioni su: