Sauvegarde de l’infrastructure Azure avec Python et Aztfexport
Posté par Dino, mise à jour le 09/05/2026 à 09:09:36
Dans un monde DevOps idéal, chaque ressource cloud provient de Terraform ou Bicep. Dans la vraie vie, nous traitons avec des « ClickOps ». Un ingénieur ajuste manuellement un Network Security Group (NSG) pour réparer une panne de production, ou un groupe de ressources hérité existe sans aucune définition de code.Lorsqu’une catastrophe survient — comme la suppression accidentelle d’un groupe de ressources — vous ne pouvez pas simplement « relancer le pipeline » si celui-ci ne correspond pas à la réalité.
Pour résoudre cela, nous avons besoin d’un moteur de secours de configuration. Bien qu’Azure crée des sauvegardes pour les données, il ne sauvegarde pas nativement l’état de l’infrastructure.
Cet article présente une solution utilisant Python pour orchestrer aztfexport (Azure Export de Microsoft pour Terraform). En enveloppant cet outil dans un script Python, nous pouvons découvrir dynamiquement des ressources, les rétroconcevoir en code Terraform et les envoyer vers un stockage immuable.
Le problème : le « fossé d’État »
Infrastructure as Code (IaC) est généralement unidirectionnel :
Code → Cloud
Le problème survient lorsque le cloud change indépendamment du code.
* Dérive : L’environnement vivant diverge du dépôt
* Héritage : Les ressources créées il y a des années n’ont pas de définition IaC
* Audit : Vous avez besoin d’un instantané exact de l’apparence exacte du pare-feu mardi dernier
Ce dont nous avons besoin, c’est d’un flux de travail qui soit le suivant :
Code → cloud → sauvegarde
La solution : un contrôleur d’automatisation Python
Au lieu de nous appuyer sur des fichiers CI/CD YAML rigides, nous utilisons Python. Cela nous permet de boucler dynamiquement les abonnements, de gérer les erreurs d’authentification avec grâce et d’interagir directement avec Azure Blob Storage pour l’archivage.
La mise en œuvre : du cloud au code postal
Nous utilisons le module pour contrôler l’outil CLI et le SDK Azure pour Python afin de gérer le stockage.subprocessaztfexport
Prérequis
aztfexport installé sur le couloir
azure-identity et bibliothèquesazure-storage-blob
backup_infra.py
import os
import subprocess
import shutil
import datetime
from azure.identity import DefaultAzureCredential
from azure.storage.blob import BlobServiceClient
# Configuration
SUBSCRIPTION_ID = os.getenv("AZURE_SUBSCRIPTION_ID")
TARGET_RG = "mission-critical-rg"
BACKUP_CONTAINER = "infra-backups"
STORAGE_ACCOUNT_URL = "https://mybackupvault.blob.core.windows.net"
def run_export(resource_group):
"""
Runs aztfexport to reverse-engineer the Azure Resource Group
into Terraform configuration files.
"""
timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
output_dir = f"./exports/{resource_group}/{timestamp}"
print(f" Starting export for {resource_group}...")
# Construct the command
# --non-interactive: Auto-accepts defaults
# --hcl-only: Generates .tf files (you can omit this to get state file as well)
cmd = [
"aztfexport",
"resource-group",
resource_group,
"--non-interactive",
"--output-dir", output_dir
]
try:
# Run the export tool
result = subprocess.run(
cmd,
check=True,
capture_output=True,
text=True
)
print(f" Export successful for {resource_group}")
return output_dir
except subprocess.CalledProcessError as e:
print(f" Export failed: {e.stderr}")
return None
def archive_and_upload(source_dir, resource_group):
"""
Compresses the Terraform files and uploads to Azure Blob Storage
"""
# 1. Create Zip Archive
zip_name = f"{resource_group}-backup"
shutil.make_archive(zip_name, 'zip', source_dir)
full_zip_path = f"{zip_name}.zip"
# 2. Upload to Blob Storage
print(f" Uploading {full_zip_path} to immutable storage...")
credential = DefaultAzureCredential()
blob_service_client = BlobServiceClient(account_url=STORAGE_ACCOUNT_URL, credential=credential)
container_client = blob_service_client.get_container_client(container=BACKUP_CONTAINER)
with open(full_zip_path, "rb") as data:
container_client.upload_blob(name=full_zip_path, data=data, overwrite=True)
print(f" Backup secured: {full_zip_path}")
# Cleanup local files
os.remove(full_zip_path)
shutil.rmtree(source_dir)
if __name__ == "__main__":
# Orchestration Logic
export_path = run_export(TARGET_RG)
if export_path:
archive_and_upload(export_path, TARGET_RG)
Pourquoi Python plutôt que Bash ou YAML ?
Gestion des erreurs : Si elle échoue partiellement (par exemple, une ressource verrouillée), Python peut détecter le code d’erreur spécifique, le journaliser et décider s’il doit réessayer ou passer, plutôt que de faire planter tout le pipeline.aztfexport
Découverte dynamique : Vous pouvez facilement ajouter une fonction pour interroger Azure Resource Graph (requête az graph) afin de lister tous les groupes de ressources tagués ) et itérer à travers eux. Les pipelines YAML ont du mal avec ce niveau de boucle dynamique.Backup=True
Intégration SDK : L’intégration directe avec Azure Key Vault et Blob Storage est plus sécurisée et robuste via le SDK Python que d’utiliser des commandes CLI dans un script.
La stratégie de restauration : la porte « Examiner et appliquer »
Automatiser les sauvegardes est inutile si vous ne pouvez pas les restaurer. Comme la sortie est du code Terraform standard, la restauration suit les pratiques IaC familières.
Lorsqu’une catastrophe survient (par exemple, un sous-réseau est supprimé) :
Aller chercher : Téléchargez le dernier code postal depuis Blob Storage
Critique : Inspecter les fichiers — génère un fichier de mappage qui relie le code aux identifiants des ressources.tfaztfexport
Postulez : Cours. Terraform détectera que l’identifiant de ressource manque dans le cloud et le recréera selon la configuration définie dans la sauvegardeterraform apply
Conclusion
L’infrastructure doit être traitée avec la même rigueur en matière de protection des données que les bases de données. En implémentant un pattern Reverse-IaC utilisant Python et , vous créez un environnement auto-documenté et auto-sauvegardant.aztfexport
Cette approche transforme la « boîte noire » des ressources Azure héritées en code transparent et versionné — offrant à la fois un filet de sécurité pour la reprise après sinistre et une base pour une modernisation future.
Ajouter une réponse
A voir aussi :
Les dernières discussions:
Qui est Réponse Rapide?
Réponse rapide est un site internet communautaire. Son objectif premier est de permettre à ses membres et visiteurs de poser leurs questions et d’avoir des réponses en si peu de temps.Quelques avantages de réponse rapide :
Vous n’avez pas besoins d’être inscrit pour poser ou répondre aux questions.Les réponses et les questions des visiteurs sont vérifiées avant leurs publications.
Parmi nos membres, des experts sont là pour répondre à vos questions.
Vous posez vos questions et vous recevez des réponses en si peu de temps.