Restaurer des bases de données SQL sur une machine virtuelle Azure à l’aide d’Azure CLI

Azure CLI permet de créer et de gérer des ressources Azure à partir de la ligne de commande ou par le biais de scripts. Cet article explique comment restaurer une base de données SQL sauvegardée sur une machine virtuelle Azure à l’aide d’Azure CLI. Vous pouvez également effectuer ces actions à l’aide du portail Azure.

Utilisez Azure Cloud Shell pour exécuter les commandes CLI.

Cet article suppose que vous avez une base de données SQL fonctionnant sur une VM Azure qui est sauvegardée via Sauvegarde Azure. Si vous avez appliqué la procédure de l’article Sauvegarder une base de données SQL dans Azure à l’aide de l’interface CLI pour sauvegarder votre base de données SQL, vous utiliserez les ressources suivantes :

  • Un groupe de ressources nommé SQLResourceGroup.
  • Un coffre nommé SQLVault.
  • Conteneur protégé nommé VMAppContainer;Compute;SQLResourceGroup;testSQLVM.
  • Une base de données ou un élément sauvegardé nommé sqldatabase;mssqlserver;testdb.
  • Ressources dans la région westus.

Pour voir les scénarios de sauvegarde et de restauration que nous prenons en charge, consultez la matrice de prise en charge. Pour les questions courantes, consultez les questions fréquemment posées.

Afficher les points de restauration d’une base de données sauvegardée

Pour afficher la liste de tous les points de récupération d’une base de données, utilisez la commande az backup recoverypoint list comme suit :

az backup recoverypoint list --resource-group SQLResourceGroup \
    --vault-name SQLVault \
    --container-name "VMAppContainer;Compute;SQLResourceGroup;testSQLVM" \
    --item-name "sqldatabase;mssqlserver;testdb" \
   --output table

La liste des points de récupération apparaît comme suit :

Name                      Time                               BackupManagementType   Item Name               		RecoveryPointType
-------------------       ---------------------------------  ---------------------  ----------------------  		------------------
7660777527047692711       2019-12-10T04:00:32.346000+00:00   AzureWorkload          sqldatabase;mssqlserver;testdb  Full
7896624824685666836       2019-12-15T10:33:32.346000+00:00   AzureWorkload          sqldatabase;mssqlserver;testdb  Differential
DefaultRangeRecoveryPoint                                    AzureWorkload          sqldatabase;mssqlserver;testdb  Log

La liste ci-dessus contient trois points de récupération : un pour la sauvegarde complète, un pour la sauvegarde différentielle et un pour la sauvegarde des journaux.

Note

Vous pouvez également afficher les points de début et de fin de chaque chaîne de sauvegarde de journaux non interrompue à l’aide de la commande az backup recoverypoint show-log-chain.

Prérequis pour restaurer une base de données

Avant de restaurer une base de données, vérifiez que les prérequis suivants sont remplis :

  • Vous pouvez restaurer la base de données uniquement sur une instance SQL dans la même région ou dans une autre région si la restauration interrégion est activée sur le coffre.
  • L’instance cible doit être enregistrée auprès du même coffre que la source, à l’exception de Restauration interrégion et Restauration avec plusieurs abonnements. .

Restaurer une base de données

Sauvegarde Azure peut restaurer des bases de données SQL s’exécutant sur des machines virtuelles Azure comme suit :

  • Restaurer à une date ou une heure spécifique (à la seconde), en utilisant les sauvegardes de fichiers journaux. Sauvegarde Azure détermine automatiquement les sauvegardes différentielles complètes appropriées, et la chaîne des sauvegardes de fichiers journaux nécessaires pour restaurer en fonction de la date/heure sélectionnée.
  • Restaurer en fonction d’une sauvegarde complète ou différentielle spécifique à un point de récupération spécifique.

Pour restaurer une base de données, utilisez la commande az restore restore-azurewl, qui nécessite entre autres un objet de configuration de récupération comme entrée. Vous pouvez générer cet objet à l’aide de la commande az backup recoveryconfig show. L’objet de configuration de récupération contient tous les détails nécessaires pour effectuer une restauration, notamment le mode de restauration : OriginalWorkloadRestore ou AlternateWorkloadRestore.

Note

OriginalWorkloadRestore : restaure les données sur la même instance SQL que la source d’origine. Cette option remplace la base de données d’origine. AlternateWorkloadRestore : restaure la base de données vers un autre emplacement et conserve la base de données source d’origine.

Restaurer à un autre emplacement

Pour restaurer une base de données à un autre emplacement, utilisez AlternateWorkloadRestore comme mode de restauration. Vous devez ensuite choisir le point de restauration, qui peut être un point antérieur dans le temps ou l’un des points de restauration précédents.

Nous allons procéder à la restauration vers un point de restauration précédent. Affichez la liste des points de restauration pour la base de données et choisissez celui vers lequel vous souhaitez effectuer la restauration. Ici, utilisons le point de restauration avec le nom 7660777527047692711.

Avec le nom du point de restauration et du mode de restauration ci-dessus, créons l’objet de configuration de récupération avec la commande az backup recoveryconfig show. Vérifiez les paramètres restants dans cette commande :

  • --target-item-name : nom à utiliser par la base de données restaurée. Dans ce scénario, nous avons utilisé le nom restored_database.
  • --target-server-name : il s’agit du nom d’un serveur SQL qui est correctement inscrit auprès d’un coffre Recovery Services et se trouve dans la même région que la base de données à restaurer. Ici, vous restaurez la base de données sur le même serveur SQL que celui que vous avez protégé, nommé testSQLVM.
  • --target-server-type : pour la restauration des bases de données SQL, vous devez utiliser SQLInstance.

az backup recoveryconfig show --resource-group SQLResourceGroup \
    --vault-name SQLVault \
    --container-name "VMAppContainer;Compute;SQLResourceGroup;testSQLVM" \
    --item-name "SQLDataBase;mssqlserver;testdb" \
    --restore-mode AlternateWorkloadRestore \
    --rp-name 7660777527047692711 \
    --target-item-name restored_database \
    --target-server-name testSQLVM \
    --target-server-type SQLInstance \
    --workload-type SQLDataBase \
    --output json

La réponse à la requête ci-dessus est un objet de configuration de récupération qui se présente comme suit :

{
  "container_id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/SQLResourceGroup/providers/Microsoft.RecoveryServices/vaults/SQLVault/backupFabrics/Azure/protectionContainers/vmappcontainer;compute;SQLResourceGroup;testSQLVM",
  "container_uri": "VMAppContainer;compute;SQLResourceGroup;testSQLVM",
  "database_name": "MSSQLSERVER/restored_database",
  "filepath": null,
  "item_type": "SQL",
  "item_uri": "SQLDataBase;mssqlserver;testdb",
  "log_point_in_time": null,
  "recovery_mode": null,
  "recovery_point_id": "7660777527047692711",
  "restore_mode": "AlternateLocation",
  "source_resource_id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/SQLResourceGroup/providers/Microsoft.Compute/virtualMachines/testSQLVM",
  "workload_type": "SQLDataBase",
  "alternate_directory_paths": []
}

À présent, pour restaurer la base de données, exécutez la commande az restore restore-azurewl. Pour utiliser cette commande, nous allons entrer la sortie JSON ci-dessus enregistrée dans un fichier nommé recoveryconfig.json.

az backup restore restore-azurewl --resource-group SQLResourceGroup \
    --vault-name SQLVault \
    --recovery-config recoveryconfig.json \
    --output table

La sortie se présente sous la forme suivante :

Name                                  Operation    Status      Item Name                          Backup Management Type    Start Time UTC                    Duration
------------------------------------  -----------  ----------  ---------------------------------  ------------------------  --------------------------------  --------------
be7ea4a4-0752-4763-8570-a306b0a0106f  Restore      InProgress  testdb [testSQLVM]  				  AzureWorkload             2022-06-21T03:51:06.898981+00:00  0:00:05.652967

La réponse vous fournit le nom du travail. Vous pouvez utiliser ce nom pour effectuer le suivi de l’état du travail à l’aide de la commande az backup job show.

Restaurer et remplacer

Pour restaurer à l’emplacement d’origine, nous allons utiliser OriginalWorkloadRestore comme mode de restauration. Vous devez ensuite choisir le point de restauration, qui peut être un point antérieur dans le temps ou l’un des points de restauration précédents.

À titre d’exemple, choisissons le point dans le temps précédent « 28-11-2019-09:53:00 » pour le restaurer. Vous pouvez spécifier ce point de restauration aux formats suivants : jj-mm-aaaa, jj-mm-aaaa-hh:mm:ss. Pour choisir un point dans le temps valide pour la restauration, utilisez la commande az backup recoverypoint show-log-chain, qui liste les intervalles de sauvegardes de chaîne de journaux non interrompues.

az backup recoveryconfig show --resource-group SQLResourceGroup \
    --vault-name SQLVault \
    --container-name "VMAppContainer;Compute;SQLResourceGroup;testSQLVM" \
    --item-name "sqldatabase;mssqlserver;testdb" \
    --restore-mode OriginalWorkloadRestore \
    --log-point-in-time 20-06-2022-09:02:41 \
    --output json

La réponse à la requête ci-dessus est un objet de configuration de récupération qui se présente comme suit :

{
  "alternate_directory_paths": null,
  "container_id": null,
  "container_uri": "VMAppContainer;Compute;SQLResourceGroup;testSQLVM",
  "database_name": null,
  "filepath": null,
  "item_type": "SQL",
  "item_uri": "SQLDataBase;mssqlserver;testdb",
  "log_point_in_time": "20-06-2022-09:02:41",
  "recovery_mode": null,
  "recovery_point_id": "DefaultRangeRecoveryPoint",
  "restore_mode": "OriginalLocation",
  "source_resource_id": "/subscriptions/62b829ee-7936-40c9-a1c9-47a93f9f3965/resourceGroups/SQLResourceGroup/providers/Microsoft.Compute/virtualMachines/testSQLVM",
  "workload_type": "SQLDataBase"
}

À présent, pour restaurer la base de données, exécutez la commande az restore restore-azurewl. Pour utiliser cette commande, nous allons entrer la sortie JSON ci-dessus enregistrée dans un fichier nommé recoveryconfig.json.

az backup restore restore-azurewl --resource-group sqlResourceGroup \
    --vault-name sqlVault \
    --recovery-config recoveryconfig.json \
    --output table

La sortie se présente sous la forme suivante :

Name                                  Operation    Status      Item Name                        Backup Management Type    Start Time UTC                    Duration
------------------------------------  -----------  ----------  -------------------------------  ------------------------  --------------------------------  --------------
1730ec49-166a-4bfd-99d5-93027c2d8480  Restore      InProgress  testdb [testSQLVM]  				AzureWorkload             2022-06-21T04:04:11.161411+00:00  0:00:03.118076

La réponse vous fournit le nom du travail. Vous pouvez utiliser ce nom pour effectuer le suivi de l’état du travail à l’aide de la commande az backup job show.

Restaurer dans une région secondaire

Pour restaurer une base de données dans la région secondaire, spécifiez un coffre cible et un serveur situés dans la région secondaire, dans la configuration de restauration.

az backup recoveryconfig show --resource-group SQLResourceGroup \
    --vault-name SQLVault \
    --container-name "VMAppContainer;compute;SQLResourceGroup;testSQLVM" \
    --item-name "sqldatabase;mssqlserver;testdb" \
    --restore-mode AlternateWorkloadRestore \
    --from-full-rp-name 293170069256531 \
    --rp-name 293170069256531 \
    --target-server-name targetSQLServer \
    --target-container-name "VMAppContainer;compute;SQLResourceGroup;targetSQLServer" \
    --target-item-name testdb_restore_1 \
    --target-server-type SQLInstance \
    --workload-type SQLDataBase \
    --target-resource-group SQLResourceGroup \
    --target-vault-name targetVault \
    --backup-management-type AzureWorkload

La réponse est un objet de configuration de récupération qui apparaît comme suit :

 {
  "container_id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/SQLResourceGroup/providers/Microsoft.RecoveryServices/vaults/targetVault/backupFabrics/Azure/protectionContainers/vmappcontainer;compute;SQLResourceGroup;targetSQLServer",
  "container_uri": "VMAppContainer;compute;SQLResourceGroup;testSQLVM",
  "database_name": "MSSQLSERVER/testdb_restore_1",
  "filepath": null,
  "item_type": "SQL",
  "item_uri": "SQLDataBase;mssqlserver;testdb",
  "log_point_in_time": null,
  "recovery_mode": null,
  "recovery_point_id": "293170069256531",
  "restore_mode": "AlternateLocation",
  "source_resource_id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/SQLResourceGroup/providers/Microsoft.Compute/virtualMachines/testSQLVM",
  "workload_type": "SQLDataBase",
  "alternate_directory_paths": []
}

Utilisez cette configuration de récupération dans la commande az restore restore-azurewl. Sélectionnez l’indicateur --use-secondary-region pour restaurer la base de données dans la région secondaire.

az backup restore restore-azurewl --resource-group SQLResourceGroup \
    --vault-name SQLVault \
    --recovery-config recoveryconfig.json \
    --use-secondary-region \
    --output table

La sortie se présente sous la forme suivante :

Name                                  Operation           Status      Item Name                  Backup Management Type    Start Time UTC                    Duration
------------------------------------  ------------------  ----------  -------------------------  ------------------------  --------------------------------  --------------
0d863259-b0fb-4935-8736-802c6667200b  CrossRegionRestore  InProgress  testdb [testSQLVM] 		 AzureWorkload             2022-06-21T08:29:24.919138+00:00  0:00:12.372421

Note

L’objectif RPO (objectif de point de récupération) pour que les données de sauvegarde soient disponibles dans la région secondaire est de 12 heures. Ainsi, quand vous activez la restauration CRR (restauration interrégionale), l’objectif RPO de la région secondaire est de 12 heures + la durée de la fréquence de journalisation (qui peut être définie à une valeur minimale de 15 minutes).

Restaurer sous forme de fichiers

Pour restaurer les données de sauvegarde sous forme de fichiers plutôt que sous forme de base de données, nous allons utiliser RestoreAsFiles comme mode de restauration. Choisissez ensuite le point de restauration, qui peut être un point antérieur dans le temps ou l’un des points de restauration précédents. Une fois les fichiers vidés dans un chemin d’accès spécifié, vous pouvez placer ces fichiers sur n’importe quelle machine SQL sur laquelle vous souhaitez les restaurer sous forme de base de données. Étant donné que vous pouvez déplacer ces fichiers sur n’importe quel ordinateur, vous pouvez désormais restaurer les données entre les abonnements et les régions.

Choisissez le point dans le temps précédent 28-11-2019-09:53:00 à restaurer et l’emplacement où déposer les fichiers de sauvegarde comme C:\restoreasfiles sur le même serveur SQL. Vous pouvez spécifier ce point de restauration dans l’un des formats suivants : jj-mm-aaaa ou jj-mm-aaaa-hh:mm:ss. Pour choisir un point dans le temps valide pour la restauration, utilisez la commande az backup recoverypoint show-log-chain, qui liste les intervalles de sauvegardes de chaîne de journaux non interrompues.

Avec le nom du point de restauration et du mode de restauration ci-dessus, créons l’objet de configuration de récupération avec la commande az backup recoveryconfig show. Vérifiez chacun des paramètres restants dans cette commande :

  • --target-container-name : il s’agit du nom d’un serveur SQL qui est correctement inscrit auprès d’un coffre Recovery Services et se trouve dans la même région que la base de données à restaurer. Restaurons la base de données sous forme de fichiers sur le même serveur SQL que vous avez protégé, appelé mssqlserver.
  • --rp-name : pour une limite de restauration dans le temps, le nom du point de restauration est DefaultRangeRecoveryPoint.
az backup recoveryconfig show --resource-group SQLResourceGroup \
    --vault-name SQLVault \
    --container-name "VMAppContainer;Compute;SQLResourceGroup;testSQLVM" \
    --item-name "sqldatabase;mssqlserver;testdb" \
    --restore-mode RestoreAsFiles \
    --rp-name 932606668166874635 \
    --target-container-name "VMAppContainer;Compute;SQLResourceGroup;testSQLVM" \
    --filepath "C:\restoreasfiles" \
    --output json

La réponse à la requête ci-dessus est un objet de configuration de récupération qui se présente comme suit :

{
  "alternate_directory_paths": null,
  "container_id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/SQLResourceGroup/providers/Microsoft.RecoveryServices/vaults/SQLVault/backupFabrics/Azure/protectionContainers/VMAppContainer;Compute;SQLResourceGroup;testSQLVM",
  "container_uri": "VMAppContainer;compute;SQLResourceGroup;testSQLVM",
  "database_name": null,
  "filepath": "C:\restoreasfiles",
  "item_type": "SQL",
  "item_uri": "SQLDataBase;mssqlserver;testdb",
  "log_point_in_time": null,
  "recovery_mode": "FileRecovery",
  "recovery_point_id": "932606668166874635",
  "restore_mode": "AlternateLocation",
  "source_resource_id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/SQLResourceGroup/providers/Microsoft.Compute/virtualMachines/testSQLVM",
  "workload_type": "SQLDataBase"
}

À présent, pour restaurer la base de données sous forme de fichiers, exécutez la commande az restore restore-azurewl. Pour utiliser cette commande, nous allons entrer la sortie JSON ci-dessus enregistrée dans un fichier nommé recoveryconfig.json.

az backup restore restore-azurewl --resource-group SQLResourceGroup \
    --vault-name SQLVault \
    --recovery-config recoveryconfig.json \
    --output json

La sortie se présente sous la forme suivante :

{
  "eTag": null,
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/SQLResourceGroup/providers/Microsoft.RecoveryServices/vaults/SQLVault/backupJobs/e9cd9e73-e3a3-425a-86a9-8dd1c500ff56",
  "location": null,
  "name": "e9cd9e73-e3a3-425a-86a9-8dd1c500ff56",
  "properties": {
    "actionsInfo": [
      "1"
    ],
    "activityId": "9e7c8ee4-f1ef-11ec-8a2c-3c52826c1a9a",
    "backupManagementType": "AzureWorkload",
    "duration": "0:00:04.304322",
    "endTime": null,
    "entityFriendlyName": "testdb [testSQLVM]",
    "errorDetails": null,
    "extendedInfo": {
      "dynamicErrorMessage": null,
      "propertyBag": {
        "Job Type": "Restore as files"
      },
      "tasksList": [
        {
          "status": "InProgress",
          "taskId": "Transfer data from vault"
        }
      ]
    },
    "isUserTriggered": true,
    "jobType": "AzureWorkloadJob",
    "operation": "Restore",
    "startTime": "2022-06-22T05:53:32.951666+00:00",
    "status": "InProgress",
    "workloadType": "SQLDataBase"
  },
  "resourceGroup": "SQLResourceGroup",
  "tags": null,
  "type": "Microsoft.RecoveryServices/vaults/backupJobs"
}

La réponse vous fournit le nom du travail. Vous pouvez utiliser ce nom pour effectuer le suivi de l’état du travail à l’aide de la commande az backup job show.

Note

Si vous ne souhaitez pas restaurer toute la chaîne, mais uniquement un sous-ensemble de fichiers, suivez les étapes décrites ici.

Restauration entre abonnements

Grâce à la restauration entre abonnements (CSR), vous avez la possibilité de restaurer n’importe quel abonnement et tout coffre sous votre locataire si des autorisations de restauration sont disponibles. Par défaut, une CSR est activée sur tous les coffres Recovery Services (coffres existants et nouvellement créés).

Note

  • Vous pouvez déclencher la restauration entre abonnements à partir d’un coffre Recovery Services.
  • La CSR est prise en charge uniquement pour des sauvegardes basées sur une diffusion en continu et n’est pas prise en charge pour des sauvegardes basées sur des instantanés.
  • La restauration inter-région (CRR) avec CSR n’est pas prise en charge.
az backup vault create

Ajoutez le paramètre cross-subscription-restore-state qui vous permet de définir l’état CSR du coffre lors de la création et de la mise à jour du coffre.

az backup recoveryconfig show

Ajoutez le paramètre --target-subscription-id qui vous permet de fournir l’abonnement cible en tant qu’entrée lors du déclenchement de la restauration avec plusieurs abonnements pour des sources de données SQL ou HANA.

Example:

   az backup vault create -g {rg_name} -n {vault_name} -l {location} --cross-subscription-restore-state Enable
   az backup recoveryconfig show --restore-mode alternateworkloadrestore --backup-management-type azureworkload -r {rp} --target-container-name {target_container} --target-item-name {target_item} --target-resource-group {target_rg} --target-server-name {target_server} --target-server-type SQLInstance --target-subscription-id {target_subscription} --target-vault-name {target_vault} --workload-type SQLDataBase --ids {source_item_id}

Restaurer les instantanés d’instance SQL

Les exemples suivants utilisent la syntaxe shell PowerShell, pas Bash. Utilisez une version Azure CLI qui expose les options d’instantanés présentées dans cet article. Examinez les prérequis pour restaurer l’instantané et la matrice de support.

Remplacez les espaces réservés avant de les utiliser. Complétez la configuration commune et choisissez uniquement le scénario de restauration requis. Les exemples suivants sont des alternatives, pas un script à exécuter en entier. Les commandes de restauration peuvent écraser les données ou modifier les liaisons de disque.

Configurer les variables de restauration d’instantané

Utilisez l’abonnement du coffre pour $vaultSubscription. Préparez le groupe de ressources cible et l’identité gérée attribuée par l’utilisateur avec les autorisations requises :

$vaultSubscription = "<vault-subscription-id>"
$vaultRg = "<vault-rg>"
$vaultName = "<vault-name>"
$sourceVm = "<source-vm-name>"
$targetVm = "<target-vm-name>"
$targetInstanceName = "<target-instance-name>"
$restoreRg = "<restore-resource-group>"
$uamiId = "/subscriptions/<subscription-id>/resourceGroups/<identity-rg>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<identity-name>"
$vaultArgs = @("--subscription", $vaultSubscription, "--resource-group", $vaultRg, "--vault-name", $vaultName)

az backup vault show --subscription $vaultSubscription --resource-group $vaultRg --name $vaultName
az backup container list @vaultArgs --backup-management-type AzureWorkload `
  --query "[].{Name:name,VM:properties.friendlyName}" --output table
$containerName = "<native-source-container-name>"
$targetContainerName = "<native-target-container-name>"
$sourceArgs = $vaultArgs + @("--container-name", $containerName, "--backup-management-type", "AzureWorkload")

az backup item list @sourceArgs --workload-type SQLInstance --output json
$instanceItemName = "<native-protected-instance-item-name>"
$instanceArgs = $sourceArgs + @("--item-name", $instanceItemName, "--workload-type", "SQLInstance")

Copiez les noms exacts des conteneurs natifs et des éléments protégés à partir de la sortie du service. La configuration source et destination ci-dessus utilise le même coffre. Pour les restaurations en emplacement alternatif, vérifiez que l’instance cible est détectable :

az backup protectable-item show @vaultArgs --workload-type MSSQL `
  --protectable-item-type SQLInstance --name $targetInstanceName --server-name $targetVm

Les options longues dans ces exemples prennent également en charge les alias plus courts suivants :

Option longue Alias
--restore-point-query-type --rp-query-type
--get-latest-recovery-point-only --latest-rp-only
--base-snapshot-recovery-point-id --base-snapshot-rp-id
--base-recovery-point-datasource-id --base-datasource-id

Points de récupération d'instantanée de requête

Listez tous les types de points de récupération demandés pour une fenêtre temporelle, uniquement les instantanés, ou uniquement le dernier instantané :

$startDate = (Get-Date).ToUniversalTime().AddDays(-7).ToString("dd-MM-yyyy-HH:mm:ss")
$endDate = (Get-Date).ToUniversalTime().ToString("dd-MM-yyyy-HH:mm:ss")
az backup recoverypoint list @instanceArgs --start-date $startDate --end-date $endDate `
  --restore-point-query-type FullDifferentialAndSnapshot --output json
az backup recoverypoint list @instanceArgs --restore-point-query-type Snapshot --output json
az backup recoverypoint list @instanceArgs --restore-point-query-type Snapshot `
  --get-latest-recovery-point-only true --output json

Choisissez explicitement un point de récupération ; ne présumez pas de l’ordre de la liste. Récupérez ses détails complets pour inspecter les bases de données et les informations sur le système de fichiers incluses :

$snapshotRpName = "<selected-snapshot-recovery-point-name>"
$snapshotJson = az backup recoverypoint show @instanceArgs --name $snapshotRpName --output json
if ($LASTEXITCODE -ne 0) { throw "Could not read the selected snapshot recovery point." }
$snapshotRp = $snapshotJson | ConvertFrom-Json

$snapshotRp.properties.extendedInfo.includedDatabases | Select-Object datasourceName, datasourceId
$snapshotRp.properties.extendedInfo.snapshotRecoveryPointInfo.snapshotResourceGroup
$snapshotRp.properties.extendedInfo.snapshotRecoveryPointInfo.sourceFilesystemInfo |
  Select-Object label, fileSystemType, accessPaths, isOnStorageSpace, storageSpaceInfo, diskInfoList

Interroger des plages de journaux basées sur des instantanés

Récupérez l’instanceprotectedItemDataSourceId. Cet ID est la source de données de base pour les requêtes de journaux, et non l’ID de la source de données d’une base de données individuelle.

$instanceJson = az backup item show @sourceArgs --name $instanceItemName `
  --workload-type SQLInstance --output json
if ($LASTEXITCODE -ne 0) { throw "Could not read the protected instance." }
$instanceItem = $instanceJson | ConvertFrom-Json
$instanceDatasourceId = $instanceItem.properties.protectedItemDataSourceId

az backup item list @sourceArgs --workload-type MSSQL --output json
$dbItemName = "<selected-native-database-item-name>"
$databaseArgs = $sourceArgs + @("--item-name", $dbItemName, "--workload-type", "MSSQL")
az backup recoverypoint show-log-chain @databaseArgs `
  --recovery-mode SnapshotAttachAndRecover `
  --base-snapshot-recovery-point-id $snapshotRpName `
  --base-recovery-point-datasource-id $instanceDatasourceId --output json

Sélectionnez un élément de base de données correspondant à l’une des bases de données incluses dans l’instantané. Utilisez show-log-chain pour des plages de temps de récupération continue, plutôt que de traiter les points de récupération individuels comme des plages de journaux.

Restauration de l’emplacement original de l’instance

Générez la configuration de restauration de l’emplacement original (OLR).

$configFile = ".\instance-olr.json"
az backup recoveryconfig show @instanceArgs --rp-name $snapshotRpName `
  --restore-mode OriginalWorkloadRestore --recovery-mode SnapshotAttachAndRecover `
  --snapshot-rg $restoreRg --identity-arm-id $uamiId --output json |
  Set-Content -Encoding utf8 $configFile

Avant de soumettre, inspectez les mappages de volume. La restauration de l’emplacement original peut écraser les bases de données originales.

Restaurer l'instance à un autre emplacement

Utilisez le conteneur de destination, le serveur et l’instance SQL. Définissez --target-item-name sur le nom de base de données cible requis ou un modèle de nommage d’instance supporté par le service :

$configFile = ".\instance-alr.json"
az backup recoveryconfig show @instanceArgs --rp-name $snapshotRpName `
  --restore-mode AlternateWorkloadRestore --recovery-mode SnapshotAttachAndRecover `
  --target-container-name $targetContainerName --target-server-name $targetVm `
  --target-server-type SQLInstance --target-instance-name $targetInstanceName `
  --target-item-name "<target-database-name-or-service-supported-instance-pattern>" `
  --snapshot-rg $restoreRg --identity-arm-id $uamiId --output json |
  Set-Content -Encoding utf8 $configFile

Restauration de l’instance à un instant donné

Utilisez l’instantané d’instance sélectionné et son ID de la source de données de base issus des requêtes précédentes. Associer chaque base de données incluse à un élément protégé unique, puis interroger ses plages de journal au-dessus de ce snapshot :

$includedDatabases = @($snapshotRp.properties.extendedInfo.includedDatabases)
if ($includedDatabases.Count -eq 0) { throw "The snapshot has no included databases." }
$itemsJson = az backup item list @sourceArgs --workload-type MSSQL --output json
if ($LASTEXITCODE -ne 0) { throw "Could not list protected databases." }
$databaseItems = @($itemsJson | ConvertFrom-Json)
$logRangesPerDb = @{}
foreach ($database in $includedDatabases) {
  $matchingItems = @($databaseItems | Where-Object {
    $_.properties.protectedItemDataSourceId -eq $database.datasourceId
  })
  if ($matchingItems.Count -eq 0) {
    $matchingItems = @($databaseItems | Where-Object {
      $_.name -eq "SQLDataBase;$($database.datasourceName)" -or
      $_.properties.friendlyName -eq $database.datasourceName
    })
  }
  if ($matchingItems.Count -ne 1) {
    throw "Could not uniquely resolve included database $($database.datasourceName)."
  }
  $rangesJson = az backup recoverypoint show-log-chain @sourceArgs `
    --item-name $matchingItems[0].name --workload-type MSSQL `
    --recovery-mode SnapshotAttachAndRecover `
    --base-snapshot-recovery-point-id $snapshotRpName `
    --base-recovery-point-datasource-id $instanceDatasourceId `
    --query "[].properties.timeRanges[]" --output json
  if ($LASTEXITCODE -ne 0) { throw "Could not query snapshot-based log ranges." }
  $logRangesPerDb[$database.datasourceName] = @(
    foreach ($range in ($rangesJson | ConvertFrom-Json)) {
      if (-not $range.startTime -or -not $range.endTime) {
        throw "The service returned a log range without startTime or endTime."
      }
      [PSCustomObject]@{
        ItemName = $matchingItems[0].name
        StartTime = ([DateTimeOffset]$range.startTime).UtcDateTime
        EndTime = ([DateTimeOffset]$range.endTime).UtcDateTime
      }
    }
  )
  if ($logRangesPerDb[$database.datasourceName].Count -eq 0) {
    throw "No snapshot-based log ranges for $($database.datasourceName)."
  }
}

Inspectez les plages d’une base de données et choisissez une heure UTC. L’exemple suivant choisit la dernière heure de fin pour cette base de données, puis vérifie que l’heure est également disponible pour chaque base de données incluse. Si la validation échoue, sélectionnez une heure dans les plages disponibles communes et relancez la vérification :

$selectedDatabase = "<instance-name>;<database-name>"
if (-not $logRangesPerDb.ContainsKey($selectedDatabase)) {
  throw "Select a database from logRangesPerDb.Keys."
}
$selectedRanges = @($logRangesPerDb[$selectedDatabase] | Sort-Object EndTime)
$selectedRanges | Format-Table ItemName, StartTime, EndTime
$rangeIndex = -1
$pointInTime = $selectedRanges[$rangeIndex].EndTime
foreach ($databaseName in $logRangesPerDb.Keys) {
  $matchingRanges = @($logRangesPerDb[$databaseName] | Where-Object {
    $_.StartTime -le $pointInTime -and $_.EndTime -ge $pointInTime
  })
  if ($matchingRanges.Count -eq 0) {
    throw "The chosen restore time is unavailable for $databaseName."
  }
}
$pit = $pointInTime.ToString("dd-MM-yyyy-HH:mm:ss")

Générez la configuration PITR en utilisant l’instantané de base et le temps de relecture du journal validé :

$configFile = ".\instance-pit.json"
az backup recoveryconfig show @instanceArgs --rp-name $snapshotRpName --log-point-in-time $pit `
  --restore-mode AlternateWorkloadRestore --recovery-mode SnapshotAttachAndRecover `
  --target-container-name $targetContainerName --target-server-name $targetVm `
  --target-server-type SQLInstance --target-instance-name $targetInstanceName `
  --target-item-name "<target-database-name-or-service-supported-instance-pattern>" `
  --snapshot-rg $restoreRg --identity-arm-id $uamiId --no-recovery-mode `
  --output json | Set-Content -Encoding utf8 $configFile

--no-recovery-mode demande que les bases de données restent non restaurées pour les étapes de récupération ultérieures. Examinez si ce comportement est approprié pour votre plan de rétablissement.

Restaurer l'instance sous forme de disques

Utilisez SnapshotAttach pour la restauration en tant que disques (RAD), plutôt que l’attachement d’instantané suivi d’une récupération de base de données :

$configFile = ".\instance-rad.json"
az backup recoveryconfig show @instanceArgs --rp-name $snapshotRpName `
  --restore-mode AlternateWorkloadRestore --recovery-mode SnapshotAttach `
  --target-container-name $targetContainerName --target-server-name $targetVm `
  --target-server-type SQLInstance --target-instance-name $targetInstanceName `
  --snapshot-rg $restoreRg --identity-arm-id $uamiId --output json |
  Set-Content -Encoding utf8 $configFile

Restaurer une base de données protégée dans une instance

Sélectionnez le nom exact de l’élément natif de la base de données depuis le conteneur source. Pour les restaurations de points de récupération, choisissez explicitement un instantané de base de données :

az backup item list @sourceArgs --workload-type MSSQL --output json
$dbItemName = "<native-protected-database-item-name>"
$databaseArgs = $sourceArgs + @("--item-name", $dbItemName, "--workload-type", "MSSQL")
az backup recoverypoint list @databaseArgs --restore-point-query-type Snapshot --output json
$dbSnapshotRpName = "<chosen-database-snapshot-recovery-point-name>"
az backup recoverypoint show @databaseArgs --name $dbSnapshotRpName --output json

Restauration de la base de données vers un autre emplacement

$configFile = ".\database-alr.json"
az backup recoveryconfig show @databaseArgs --rp-name $dbSnapshotRpName `
  --restore-mode AlternateWorkloadRestore --recovery-mode SnapshotAttachAndRecover `
  --target-container-name $targetContainerName --target-server-name $targetVm `
  --target-server-type SQLInstance --target-instance-name $targetInstanceName `
  --target-item-name "<restored-db-name>" --snapshot-rg $restoreRg `
  --identity-arm-id $uamiId --no-recovery-mode --output json |
  Set-Content -Encoding utf8 $configFile

Restauration de la base de données à un instant donné

Interrogez les plages de logs disponibles et choisissez une heure UTC dans une plage retournée. Utilisez le format dd-MM-yyyy-HH:mm:ss :

az backup recoverypoint show-log-chain @databaseArgs --output json
$pit = "<dd-MM-yyyy-HH:mm:ss-in-UTC-within-a-returned-range>"
$configFile = ".\database-pit.json"
az backup recoveryconfig show @databaseArgs --log-point-in-time $pit `
  --restore-mode AlternateWorkloadRestore --recovery-mode SnapshotAttachAndRecover `
  --target-container-name $targetContainerName --target-server-name $targetVm `
  --target-server-type SQLInstance --target-instance-name $targetInstanceName `
  --target-item-name "<restored-db-name>" --snapshot-rg $restoreRg `
  --identity-arm-id $uamiId --no-recovery-mode --output json |
  Set-Content -Encoding utf8 $configFile

Les exemples de restauration de bases de données précédents utilisent --no-recovery-modeégalement . Vérifiez ce paramètre avant de soumettre.

Restaurer la base de données en tant que disques

$configFile = ".\database-rad.json"
az backup recoveryconfig show @databaseArgs --rp-name $dbSnapshotRpName `
  --restore-mode AlternateWorkloadRestore --recovery-mode SnapshotAttach `
  --target-container-name $targetContainerName --target-server-name $targetVm `
  --target-server-type SQLInstance --target-instance-name $targetInstanceName `
  --snapshot-rg $restoreRg --identity-arm-id $uamiId --output json |
  Set-Content -Encoding utf8 $configFile

Restauration de base de données sous forme de disques avec les journaux sous forme de fichiers

Définissez $pit à une heure UTC valide à partir des plages de journaux de la base de données, comme dans l’exemple PITR de la base de données. Générez la configuration de rattachement au disque, puis définissez la destination pour les fichiers journaux :

$configFile = ".\database-rad-logs.json"
az backup recoveryconfig show @databaseArgs --log-point-in-time $pit `
  --restore-mode AlternateWorkloadRestore --recovery-mode SnapshotAttach `
  --target-container-name $targetContainerName --target-server-name $targetVm `
  --target-server-type SQLInstance --target-instance-name $targetInstanceName `
  --snapshot-rg $restoreRg --identity-arm-id $uamiId --output json |
  Set-Content -Encoding utf8 $configFile

Après avoir confirmé que la génération de configuration a réussi, modifiez les correspondances générées :

$cfg = Get-Content -Raw $configFile | ConvertFrom-Json
$cfg.target_directory_mapping = @{ all = 'C:\temp' }
($cfg.target_physical_path | Where-Object source_path -eq 'E:\').target_path = 'M:\'
$cfg | ConvertTo-Json -Depth 100 | Set-Content -Encoding utf8 $configFile

Examiner et soumettre une restauration d'instantané

Pour chaque scénario sélectionné, vérifiez que az backup recoveryconfig show s’exécute correctement avant d’utiliser sa sortie. Inspectez le fichier généré et les mappages de volume. Remappez uniquement les volumes source qui nécessitent un chemin cible différent. Remplacez les lettres de lecteur données en exemple par des chemins réels :

$cfg = Get-Content -Raw $configFile | ConvertFrom-Json
$cfg.target_physical_path | Format-Table source_path, target_path
($cfg.target_physical_path | Where-Object source_path -eq 'E:\').target_path = 'X:\'
$cfg | ConvertTo-Json -Depth 100 | Set-Content -Encoding utf8 $configFile

Le remappage précédent est optionnel. Conservez les mappages prévus pour le scénario choisi, y compris toute configuration des disques et fichiers journaux de la base de données.

Si un détachement de disque est nécessaire pour résoudre un conflit de système de fichiers, ajouter uniquement les identifiants de disque explicitement approuvés à la configuration générée :

$cfg = Get-Content -Raw $configFile | ConvertFrom-Json
$cfg.disks_to_detach_on_clash = @(
  "/subscriptions/<subscription-id>/resourceGroups/<disk-rg>/providers/Microsoft.Compute/disks/<disk-name>"
)
$cfg | ConvertTo-Json -Depth 100 | Set-Content -Encoding utf8 $configFile

Warning

Détacher des disques existants peut perturber les charges de travail de destination. Vérifiez chaque identifiant de disque et la configuration complète de récupération avant de soumettre la restauration. N’appliquez pas l’exemple optionnel du détachement du disque à moins que l’opération ne soit requise et approuvée.

Soumettez uniquement le fichier de configuration pour l’opération choisie :

az backup restore restore-azurewl @vaultArgs --recovery-config $configFile

Suivez le nom du job retourné avec az backup job show. Pour les commandes stop-protection et désenregistrement, voir Gérer les sauvegardes instantanées d’instance SQL.

Étape suivante

Contenu connexe

  • Dernière mise à jour :