Démarrage rapide : configurer la sauvegarde archivée d’un cluster Azure Kubernetes Service (AKS) à l’aide de Terraform

Ce guide de démarrage rapide explique comment configurer la sauvegarde archivée d’un cluster Azure Kubernetes Service (AKS) à l’aide de Terraform.

Sauvegarde Azure pour AKS est un service de sauvegarde cloud natif, adapté aux entreprises et centré sur les applications, qui vous permet de configurer rapidement la sauvegarde des clusters AKS.

Remarque

Les étapes incluses dans cet article sur la façon de déployer un cluster et de le protéger avec Sauvegarde AKS sont uniquement à des fins d’évaluation.

Avant de déployer un cluster prêt pour la production et d’utiliser les paramètres de sauvegarde avancés, nous vous recommandons de vous familiariser avec notre architecture de référence de base pour prendre en compte la façon dont elle s’aligne sur vos exigences métier.

Prérequis

Éléments à vérifier avant de configurer la sauvegarde AKS :

Ce guide de démarrage rapide suppose une compréhension élémentaire des concepts liés à Kubernetes. Pour plus d’informations, consultez [Concepts de base de Kubernetes pour Azure Kubernetes Service (AKS)][kubernetes-concepts].
Vous devez avoir un compte Azure avec un abonnement actif. Si vous n’en avez pas un, créez un compte gratuitement.
Installez et configurez Terraform.

Remarque

Vérifiez que la version Terraform utilisée est 3.99 ou ultérieure

Téléchargez kubectl.
Créez une valeur aléatoire pour le nom du groupe de ressources Azure à l’aide de random_pet.
Créez un groupe de ressources Azure à l’aide de azurerm_resource_group.
Accédez à la configuration du fournisseur AzureRM pour obtenir l’ID d’objet Azure à l’aide de azurerm_client_config.
Créez un cluster Kubernetes à l’aide de azurerm_kubernetes_cluster.
Créez une ressource AzAPI à l’aide de azapi_resource.
Créez un compte de stockage à l’aide de azurerm_storage_account.
Créez un conteneur d’objets blob à l’aide de azurerm_storage_container.
Installez l’extension Sauvegarde dans le cluster AKS à l’aide de azurerm_kubernetes_cluster_extension`.
Créez un coffre de Sauvegarde à l’aide deazurerm_data_protection_backup_vault.
Créez une stratégie de sauvegarde pour un cluster AKS à l’aide de azurerm_data_protection_backup_vault.
Activez l’accès approuvé entre le cluster AKS et le coffre de Sauvegarde à l’aide de azurerm_kubernetes_cluster_trusted_access_role_binding.
Activez les attributions de rôles à l’aide de azurerm_role_assignment.
Configurez la Sauvegarde d’un cluster AKS à l’aide de azurerm_data_protection_backup_policy_kubernetes_cluster.

Se connecter au compte Azure

Connectez-vous à votre compte Azure et authentifiez-vous à l’aide de l’une des méthodes suivantes :

Terraform prend en charge seulement l’authentification auprès d’Azure avec Azure CLI. L’authentification à l’aide d’Azure PowerShell n’est pas prise en charge. Ainsi, même si vous pouvez utiliser le module Azure PowerShell avec Terraform, vous devez d’abord vous authentifier auprès d’Azure.

Implémenter le code Terraform

Pour implémenter le code Terraform pour le flux de sauvegarde AKS, exécutez les scripts suivants :

Remarque

Découvrez comment utiliser des exemples de codes Terraform pour gérer les ressources Azure.

Créez un répertoire que vous pouvez utiliser pour tester l’exemple de code Terraform, et définissez-le comme votre répertoire actuel.

Créez un fichier nommé providers.tf et insérez le code suivant :

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

Créez un fichier nommé main.tf et insérez le code suivant :

 #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
  ]
}

Créez un fichier nommé variables.tf et insérez le code suivant :

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

Créez un fichier nommé outputs.tf et insérez le code suivant :

 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
 }

Initialiser Terraform

Exécutez terraform init pour initialiser le déploiement Terraform. Cette commande télécharge le fournisseur Azure à utiliser pour la gestion de vos ressources Azure.

terraform init -upgrade

Points essentiels :

Le paramètre -upgrade met à niveau les plug-ins de fournisseur nécessaires vers la version la plus récente qui est conforme aux contraintes de version de la configuration.

Créer un plan d’exécution Terraform

Exécutez terraform plan pour créer un plan d’exécution.

terraform plan -out main.tfplan

Points essentiels :

La commande terraform plan crée un plan d’exécution, mais ne l’exécute pas. Au lieu de cela, elle détermine les actions nécessaires pour créer la configuration spécifiée dans vos fichiers de configuration. Ce modèle vous permet de vérifier si le plan d’exécution répond à vos attentes avant d’apporter des modifications aux ressources réelles.
Le paramètre facultatif -out vous permet de spécifier un fichier de sortie pour le plan. L’utilisation du paramètre -out garantit que le plan que vous avez examiné correspond exactement à ce qui est appliqué.

Appliquer un plan d’exécution Terraform

Exécutez terraform apply pour appliquer le plan d’exécution à votre infrastructure cloud.

terraform apply main.tfplan

Points essentiels :

La commande exemple terraform apply part du principe que vous avez préalablement exécuté terraform plan -out main.tfplan.
Si vous avez spécifié un autre nom de fichier pour le paramètre -out, utilisez ce même nom dans l’appel à terraform apply.
Si vous n’avez pas utilisé le paramètre -out, appelez terraform apply sans aucun paramètre.

Résoudre les problèmes liés à Terraform sur Azure

Lorsque vous utilisez Terraform sur Azure, vous pouvez rencontrer des problèmes courants. Découvrez comment résoudre des problèmes.

Étape suivante

Dans ce guide de démarrage rapide, vous avez appris à déployer un cluster Kubernetes, à créer un coffre de Sauvegarde et à configurer la sauvegarde pour le cluster Kubernetes.

Pour en savoir plus :

Vue d’ensemble de la sauvegarde AKS. Restaurer le cluster AKS à l’aide de l’interface Azure CLI. Comment utiliser Sauvegarde Azure pour AKS.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-01-21

Partager via

Démarrage rapide : configurer la sauvegarde archivée d’un cluster Azure Kubernetes Service (AKS) à l’aide de Terraform

Prérequis

Se connecter au compte Azure

Implémenter le code Terraform

Initialiser Terraform

Créer un plan d’exécution Terraform

Appliquer un plan d’exécution Terraform

Résoudre les problèmes liés à Terraform sur Azure

Étape suivante

Commentaires

Ressources supplémentaires