Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
Azure CLI wordt gebruikt voor het maken en beheren van Azure-resources vanaf de opdrachtregel of door middel van scripts. In dit artikel wordt beschreven hoe u een back-up van een SQL-database op een Azure-VM herstelt met behulp van Azure CLI. U kunt deze acties ook uitvoeren met behulp van Azure Portal.
Gebruik Azure Cloud Shell om CLI-opdrachten uit te voeren.
Dit artikel gaat ervan uit dat je een SQL-database hebt draaien op een Azure VM die wordt geback-upt met Azure Backup. Als u met behulp van CLI een back-up maakt van een SQL-database in Azure, gebruikt u de volgende resources:
- Een resourcegroep met de naam
SQLResourceGroup. - Een kluis met de naam
SQLVault. - Beveiligde container met de naam
VMAppContainer;Compute;SQLResourceGroup;testSQLVM. - Een geback-upte database/item genaamd
sqldatabase;mssqlserver;testdb. - Middelen in de
westusregio.
Zie de ondersteuningsmatrix voor het weergeven van de back-up- en herstelscenario's die we vandaag ondersteunen. Zie de veelgestelde vragen voor veelgestelde vragen.
Herstelpunten weergeven voor een back-up van een database
Als u de lijst met alle herstelpunten voor een database wilt weergeven, gebruikt u de opdracht az backup recoverypoint list als:
az backup recoverypoint list --resource-group SQLResourceGroup \
--vault-name SQLVault \
--container-name "VMAppContainer;Compute;SQLResourceGroup;testSQLVM" \
--item-name "sqldatabase;mssqlserver;testdb" \
--output table
De lijst met herstelpunten wordt weergegeven als:
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
De bovenstaande lijst bevat drie herstelpunten: elk voor volledige, differentiële en logboekback-up.
Opmerking
U kunt ook de begin- en eindpunten van elke niet-verbroken logboekback-upketen weergeven met behulp van de opdracht az backup recoverypoint show-log-chain .
Vereisten voor het herstellen van een database
Zorg ervoor dat aan de volgende vereisten wordt voldaan voordat u een database herstelt:
- U kunt de database alleen herstellen naar een SQL-exemplaar in dezelfde regio of naar een andere regio indien Cross Region Restore is ingeschakeld voor de kluis.
- Het doelexemplaren moeten worden geregistreerd bij dezelfde kluis als de bron, behalve tijdens herstel tussen regio's en herstel tussen abonnementen. .
Een database herstellen
Azure Backup kan SQL-databases herstellen die worden uitgevoerd op Virtuele Azure-machines als:
- Herstel naar een specifieke datum of tijd (op de seconde) met behulp van logboekback-ups. Azure Backup bepaalt automatisch de juiste keten van volledige back-ups, differentiële back-ups en logboekback-ups die nodig zijn voor het herstellen op basis van de geselecteerde tijd.
- Herstel naar een specifieke volledige of differentiële back-up om naar een specifiek herstelpunt te herstellen.
Als u een database wilt herstellen, gebruikt u de opdracht az restore restore-azurewl , waarvoor een herstelconfiguratieobject is vereist als een van de invoerwaarden. U kunt dit object genereren met behulp van de opdracht az backup recoveryconfig show . Het herstelconfiguratieobject bevat alle details voor het uitvoeren van een herstelbewerking. Een van deze is de herstelmodus : OriginalWorkloadRestore of AlternateWorkloadRestore.
Opmerking
OriginalWorkloadRestore: herstelt gegevens naar hetzelfde SQL-exemplaar als de oorspronkelijke bron. Met deze optie wordt de oorspronkelijke database overschreven. AlternateWorkloadRestore: hiermee herstelt u de database naar een alternatieve locatie en behoudt u de oorspronkelijke brondatabase.
Herstellen naar een alternatieve locatie
Als u een database wilt herstellen naar een alternatieve locatie, gebruikt u AlternateWorkloadRestore als herstelmodus. U moet vervolgens het herstelpunt kiezen. Dit kan een eerder tijdstip zijn of eventuele eerdere herstelpunten.
Laten we doorgaan met het herstellen naar een eerder herstelpunt. Bekijk de lijst met herstelpunten voor de database en kies het punt dat u wilt herstellen. Hier gaan we het herstelpunt gebruiken met de naam 7660777527047692711.
Maak met de bovenstaande naam van het herstelpunt en de herstelmodus het herstelconfiguratieobject met behulp van de opdracht az backup recoveryconfig show . Controleer de resterende parameters in deze opdracht:
- --target-item-name: de naam die moet worden gebruikt door de herstelde database. In dit scenario hebben we de naam restored_database gebruikt.
- --target-server-name: de naam van een SQL-server die is geregistreerd bij een Recovery Services-kluis en blijft dezelfde regio als de database die moet worden hersteld. Hier herstelt u de database naar dezelfde SQL-server die u hebt beveiligd, met de naam testSQLVM.
- --target-server-type: voor het herstellen van SQL-databases moet u SQLInstance gebruiken.
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
Het antwoord op de bovenstaande query is een herstelconfiguratieobject dat wordt weergegeven als:
{
"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": []
}
Voer nu de opdracht az restore-azurewl uit om de database te herstellen. Als u deze opdracht wilt gebruiken, voert u de bovenstaande JSON-uitvoer in die is opgeslagen in een bestand met de naam recoveryconfig.json.
az backup restore restore-azurewl --resource-group SQLResourceGroup \
--vault-name SQLVault \
--recovery-config recoveryconfig.json \
--output table
De uitvoer wordt weergegeven als:
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
Het antwoord geeft u de taaknaam. U kunt deze taaknaam gebruiken om de taakstatus bij te houden met behulp van de opdracht az backup job show .
Herstellen en overschrijven
Als u wilt herstellen naar de oorspronkelijke locatie, gebruikt u OriginalWorkloadRestore als de herstelmodus. Vervolgens moet u het herstelpunt kiezen. Dit kan een eerder tijdstip of een van de vorige herstelpunten zijn.
Laten we bijvoorbeeld het vorige tijdstip 28-11-2019-09:53:00 kiezen om te herstellen. U kunt dit herstelpunt opgeven in de volgende indelingen: dd-mm-jjjj, dd-mm-jjjj-uu:mm:ss. Als u een geldig tijdstip wilt kiezen om te herstellen, gebruikt u de opdracht az backup recoverypoint show-log-chain , waarin de intervallen van niet-verbroken back-ups van logboekketens worden vermeld.
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
Het antwoord op de bovenstaande query is een herstelconfiguratieobject dat wordt weergegeven als:
{
"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"
}
Voer nu de opdracht az restore-azurewl uit om de database te herstellen. Als u deze opdracht wilt gebruiken, voert u de bovenstaande JSON-uitvoer in die is opgeslagen in een bestand met de naam recoveryconfig.json.
az backup restore restore-azurewl --resource-group sqlResourceGroup \
--vault-name sqlVault \
--recovery-config recoveryconfig.json \
--output table
De uitvoer wordt weergegeven als:
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
Het antwoord geeft u de taaknaam. U kunt deze taaknaam gebruiken om de taakstatus bij te houden met behulp van de opdracht az backup job show .
Herstellen in een tweede regio
In de herstelconfiguratie geeft u een doelkluis en server op die zich in de secundaire regio bevinden als u een database naar de secundaire regio wilt herstellen.
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
Het antwoord is een herstelconfiguratieobject dat wordt weergegeven als:
{
"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": []
}
Gebruik deze herstelconfiguratie in de opdracht az restore-azurewl . Selecteer de --use-secondary-region vlag om de database te herstellen naar de secundaire regio.
az backup restore restore-azurewl --resource-group SQLResourceGroup \
--vault-name SQLVault \
--recovery-config recoveryconfig.json \
--use-secondary-region \
--output table
De uitvoer wordt weergegeven als:
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
Opmerking
De RPO voor de beschikbaarheid van back-upgegevens in de secundaire regio is 12 uur. Wanneer u CRR inschakelt, is de RPO voor de secundaire regio daarom 12 uur + duur van de logboekfrequentie (die kan worden ingesteld op minimaal 15 minuten).
Herstellen als bestanden
Als u de back-upgegevens wilt herstellen als bestanden in plaats van een database, gebruikt u RestoreAsFiles als de herstelmodus. Kies vervolgens het herstelpunt, dat een eerder tijdstip of één van de eerdere herstelpunten kan zijn. Zodra de bestanden naar een opgegeven pad zijn gedumpt, kunt u deze bestanden naar elke SQL-machine brengen waar u ze als database wilt herstellen. Omdat u deze bestanden naar een willekeurige machine kunt verplaatsen, kunt u de gegevens nu in abonnementen en regio's herstellen.
Kies het eerdere tijdstip 28-11-2019-09:53:00 om te herstellen en de locatie om back-upbestanden te dumpen zoals C:\restoreasfiles op dezelfde SQL-server. U kunt dit herstelpunt opgeven in een van de volgende indelingen: dd-mm-jjjj of dd-mm-jjjj-hh:mm:ss. Als u een geldig tijdstip wilt kiezen om te herstellen, gebruikt u de opdracht az backup recoverypoint show-log-chain , waarin de intervallen van niet-verbroken back-ups van logboekketens worden vermeld.
Maak met de bovenstaande naam van het herstelpunt en de herstelmodus het herstelconfiguratieobject met behulp van de opdracht az backup recoveryconfig show . Controleer elk van de resterende parameters in deze opdracht:
- --target-container-name: de naam van een SQL-server die is geregistreerd bij een Recovery Services-kluis en aanwezig is in dezelfde regio als de database die moet worden hersteld. Laten we de database als bestanden herstellen naar dezelfde SQL-server die je hebt beschermd, genaamd mssqlserver.
- --rp-name: Voor een herstel naar een bepaald tijdstip is de naam van het herstelpunt 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
Het antwoord op de bovenstaande query js een herstelconfiguratieobject dat wordt weergegeven als:
{
"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"
}
Als u de database nu wilt herstellen als bestanden, voert u de opdracht az restore restore-azurewl uit. Als u deze opdracht wilt gebruiken, voert u de JSON-uitvoer hierboven in die is opgeslagen in een bestand met de naam recoveryconfig.json.
az backup restore restore-azurewl --resource-group SQLResourceGroup \
--vault-name SQLVault \
--recovery-config recoveryconfig.json \
--output json
De uitvoer wordt weergegeven als:
{
"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"
}
Het antwoord geeft u de taaknaam. U kunt deze taaknaam gebruiken om de taakstatus bij te houden met behulp van de opdracht az backup job show .
Opmerking
Als u de hele keten niet wilt herstellen, maar alleen een subset van bestanden, volgt u de stappen die hier worden beschreven.
Herstel van abonnementenoverschrijding
Met CSR (Cross Subscription Restore) hebt u de flexibiliteit om te herstellen naar elk abonnement en elke gebruikerskluis onder uw tenant als er herstelauthorisaties beschikbaar zijn. CSR is standaard ingeschakeld voor alle Recovery Services-kluizen (bestaande en nieuw gemaakte kluizen).
Opmerking
- U kunt Cross Subscription Restore starten vanuit de Recovery Services-kluis.
- CSR wordt alleen ondersteund voor back-ups op basis van streaming en wordt niet ondersteund voor back-ups op basis van momentopnamen.
- CRR (Cross Regional Restore) met CSR wordt niet ondersteund.
az backup vault create
Voeg de parameter cross-subscription-restore-state toe waarmee u de CSR-status van de kluis kunt instellen tijdens het maken en het bijwerken van de kluis.
az backup recoveryconfig show
Voeg de parameter --target-subscription-id toe waarmee u het doelabonnement kunt opgeven als invoer tijdens het activeren van herstel tussen abonnementen voor SQL- of HANA-gegevensbronnen.
Voorbeeld:
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}
Herstel SQL-instantiesnapshots
De volgende voorbeelden gebruiken PowerShell-shellsyntaxis, niet Bash. Gebruik een Azure CLI-versie die de snapshot-opties uit dit artikel blootstelt. Bekijk de vereisten voor snapshotherstel en de ondersteuningsmatrix.
Vervang placeholders voor gebruik. Voltooi de gemeenschappelijke setup en kies alleen het vereiste herstelscenario. De volgende voorbeelden zijn alternatieven, geen script om volledig uit te voeren. Herstelcommando's kunnen gegevens overschrijven of schijfbijlagen wijzigen.
Stel snapshot-herstelvariabelen in
Gebruik het vaultabonnement voor $vaultSubscription. Bereid de doelresourcegroep en de door de gebruiker toegewezen beheerde identiteit voor met de vereiste rechten:
$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")
Kopieer exact de native container- en beschermde itemnamen uit de service-output. De hierboven genoemde bron- en bestemmingsopstelling gebruikt dezelfde vault. Voor herstel naar een alternatieve locatie, controleer of de doelinstantie ontdekbaar is:
az backup protectable-item show @vaultArgs --workload-type MSSQL `
--protectable-item-type SQLInstance --name $targetInstanceName --server-name $targetVm
De lange opties in deze voorbeelden ondersteunen ook de volgende kortere aliassen:
| Lange optie | 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 |
Herstelpunten voor querysnapshot
Vermeld alle gevraagde herstelpunttypes voor een tijdsvenster, alleen snapshots, of alleen de meest recente snapshot:
$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
Kies expliciet een herstelpunt; ga er niet van uit dat de volgorde van de lijst betekenis heeft. Haal de volledige details op om de opgenomen databases en bestandssysteeminformatie te inspecteren:
$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
Op snapshots gebaseerde logbereiken
Haal de instantieprotectedItemDataSourceId op. Deze ID is de basisdatabron voor logzoekopdrachten, niet de databron-ID van een individuele database.
$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
Selecteer een database-item dat overeenkomt met een van de opgenomen databases van de snapshot. Gebruik show-log-chain voor continue herstelstijdbereiken, in plaats van afzonderlijke herstelpunten als logbereiken te behandelen.
Herstel naar oorspronkelijke locatie van instantie
Genereer de configuratie voor herstel naar de oorspronkelijke locatie (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
Controleer voordat je het indient de volumetoewijzingen. Herstel naar de oorspronkelijke locatie kan de oorspronkelijke databases overschrijven.
Herstel van instance naar alternatieve locatie
Gebruik de bestemmingscontainer, server en SQL-instantie. Stel --target-item-name in op de vereiste doeldatabasenaam of een door de dienst ondersteund exemplaarnaampatroon:
$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
Point-in-time-herstel van instantie
Gebruik de geselecteerde instance snapshot en de basis datasource ID uit de eerdere queries. Herleid elke opgenomen database tot een uniek beschermd item en raadpleeg vervolgens de logbereiken boven die 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)."
}
}
Inspecteer de intervallen van een database en kies een UTC-tijd. Het volgende voorbeeld kiest de laatste eindtijd voor die database en verifieert vervolgens dat die tijd ook beschikbaar is voor elke inbegrepen database. Als de validatie mislukt, selecteer dan een tijd binnen de gemeenschappelijke beschikbare bereiken en voer de controle opnieuw uit:
$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")
Genereer de PITR-configuratie met behulp van de basissnapshot en de gevalideerde logherhalingstijd:
$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 zorgt ervoor dat databases niet worden hersteld voor volgende herstelstappen. Beoordeel of dat gedrag geschikt is voor je herstelplan.
Instantie herstellen als schijven
Gebruik SnapshotAttach voor herstellen als schijven (RAD), in plaats van snapshotkoppeling gevolgd door databaseherstel:
$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
Herstel een database die onder een instantie is beschermd
Selecteer de exacte native database-itemnaam uit de broncontainer. Voor herstelpunt-herstelbewerkingen, kies expliciet een databasesnapshot:
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
Herstel naar alternatieve databaselocatie
$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
Databaseherstel naar een bepaald tijdstip
Zoek beschikbare logbereiken op en kies een UTC-tijd binnen een teruggegeven bereik. Gebruik de notatie 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
De voorgaande voorbeelden van databaseherstel gebruiken --no-recovery-mode ook. Bekijk die instelling voordat je het indient.
Databaseherstel als schijven
$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
Database herstellen als schijven en logboeken als bestanden
Stel $pit in op een geldige UTC-tijd vanuit de databaselogbereiken, zoals in het database PITR-voorbeeld. Genereer de disk-attachment-configuratie en stel vervolgens de bestemming voor logbestanden in:
$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
Nadat bevestigd is dat configuratiegeneratie is geslaagd, bewerk je de gegenereerde mappings:
$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
Bekijk en dien een snapshotherstel in
Voor elk geselecteerd scenario bevestig je dat az backup recoveryconfig show slaagt voordat je de output gebruikt. Bekijk de gegenereerde bestands- en volume-mappings. Wijs alleen bronvolumes opnieuw toe die een ander doelpad vereisen. Vervang de voorbeeldletters van de drive door daadwerkelijke paden:
$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
De bovenstaande hertoewijzing is optioneel. Behoud de bedoelde mappings voor je gekozen scenario, inclusief eventuele configuratie van database-, schijf- en logbestanden.
Als het loskoppelen van schijven nodig is om een botsing met het bestandssysteem op te lossen, voeg dan alleen expliciet goedgekeurde schijf-ID's toe aan de gegenereerde configuratie:
$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
Het loskoppelen van bestaande schijven kan de workloads op het doelsysteem verstoren. Controleer elke schijf-ID en de volledige herstelconfiguratie voordat je de herstelbewerking indient. Gebruik het optionele voorbeeld van disk-detacheren niet tenzij de operatie vereist en goedgekeurd is.
Dien alleen het configuratiebestand in voor de gekozen bewerking:
az backup restore restore-azurewl @vaultArgs --recovery-config $configFile
Volg de teruggestuurde jobnaam met az backup job show. Voor stop-protection- en unregister-commando's, zie SQL-instantiesnapshotback-ups beheren.
Volgende stap
Verwante inhoud
- Maak een back-up van SQL Server-databases in Azure-VM's met behulp van Azure Backup via REST API.
- Herstel SQL Server-databases in Azure VMs met REST API.
- SQL Server-databases beheren in Azure-VM's met Azure Portal, Azure CLI, REST API.