Återställa SQL-databaser på en virtuell Azure-dator med Hjälp av Azure CLI

Azure CLI används för att skapa och hantera Azure-resurser från kommandoraden eller via skript. Den här artikeln beskriver hur du återställer en säkerhetskopierad SQL-databas på en virtuell Azure-dator med Hjälp av Azure CLI. Du kan också utföra dessa åtgärder med hjälp av Azure Portal.

Använd Azure Cloud Shell för att köra CLI-kommandon.

Den här artikeln förutsätter att du har en SQL-databas som körs på Azure VM och som säkerhetskopieras med Azure Backup. Om du har använt Säkerhetskopiera en SQL-databas i Azure med CLI för att säkerhetskopiera din SQL-databas använder du följande resurser:

  • En resursgrupp med namnet SQLResourceGroup.
  • Ett valv med namnet SQLVault.
  • Skyddad container med namnet VMAppContainer;Compute;SQLResourceGroup;testSQLVM.
  • En säkerhetskopierad databas/post med namnet sqldatabase;mssqlserver;testdb.
  • Resurser i westus regionen.

Information om hur du visar de säkerhetskopierings- och återställningsscenarier som vi stöder i dag finns i supportmatrisen. Vanliga frågor finns i vanliga frågor och svar.

Visa återställningspunkter för en säkerhetskopierad databas

Om du vill visa listan över alla återställningspunkter för en databas använder du kommandot az backup recoverypoint list som:

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

Listan över återställningspunkter visas som:

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

Listan ovan innehåller tre återställningspunkter: var och en för fullständig, differentiell och loggsäkerhetskopiering.

Kommentar

Du kan också visa start- och slutpunkterna för varje obruten serie av loggsäkerhetskopior med kommandot az backup recoverypoint show-log-chain.

Förutsättningar för att återställa en databas

Kontrollera att följande krav uppfylls innan du återställer en databas:

  • Du kan bara återställa databasen till en SQL-instans i samma region eller till en annan region om återställning mellan regioner är aktiverat i valvet.
  • Målinstansen måste vara registrerad med samma säkerhetsvalv som källan, utom under återställning mellan regioner och återställning mellan prenumerationer. .

Återställ en databas

Azure Backup kan återställa SQL-databaser som körs på virtuella Azure-datorer som:

  • Återställ till ett specifikt datum eller tid (till sekunden) med hjälp av loggsäkerhetskopior. Azure Backup avgör automatiskt lämpliga fullständiga differentiella säkerhetskopior och kedjan med loggsäkerhetskopior som krävs för återställning baserat på den valda tiden.
  • Återställ till en specifik fullständig eller differentiell säkerhetskopia för att återställa till en specifik återställningspunkt.

Om du vill återställa en databas använder du kommandot az restore restore-azurewl , som kräver ett återställningskonfigurationsobjekt som en av indata. Du kan generera det här objektet med kommandot az backup recoveryconfig show . Återställningskonfigurationsobjektet innehåller all information för att utföra en återställning. En av dem är återställningsläget – OriginalWorkloadRestore eller AlternateWorkloadRestore.

Kommentar

OriginalWorkloadRestore: Återställer data till samma SQL-instans som den ursprungliga källan. Det här alternativet skriver över den ursprungliga databasen. AlternateWorkloadRestore: Återställer databasen till en alternativ plats och behåller den ursprungliga källdatabasen.

Återställa till en annan plats

Om du vill återställa en databas till en annan plats använder du AlternateWorkloadRestore som återställningsläge. Du måste sedan välja återställningspunkten, som kan vara en tidigare tidpunkt eller eventuella tidigare återställningspunkter.

Vi fortsätter med att återställa till en tidigare återställningspunkt. Visa listan över återställningspunkter för databasen och välj den punkt som du vill återställa. Här ska vi använda återställningspunkten med namnet 7660777527047692711.

Med namnet på återställningspunkten ovan och återställningsläget skapar du återställningskonfigurationsobjektet med kommandot az backup recoveryconfig show . Kontrollera de återstående parametrarna i det här kommandot:

  • --target-item-name: Namnet som ska användas av den återställde databasen. I det här scenariot använde vi namnet restored_database.
  • --target-server-name: Namnet på en SQL-server som har registrerats till ett Recovery Services-valv och förblir samma region som för den databas som ska återställas. Här återställer du databasen till samma SQL-server som du har skyddat med namnet testSQLVM.
  • --target-server-type: För återställning av SQL-databaser måste du använda 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

Svaret på ovanstående fråga är ett återställningskonfigurationsobjekt som visas som:

{
  "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": []
}

Nu, för att återställa databasen, kör kommandot az restore restore-azurewl. Om du vill använda det här kommandot anger du ovanstående JSON-utdata som sparas i en fil med namnet recoveryconfig.json.

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

Utdata visas som:

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

Svaret ger dig jobbnamnet. Du kan använda det här jobbnamnet för att spåra jobbstatusen med kommandot az backup job show .

Återställa och skriva över

Om du vill återställa till den ursprungliga platsen använder du OriginalWorkloadRestore som återställningsläge. Du måste sedan välja återställningspunkten, som kan vara en tidigare tidpunkt eller någon av de tidigare återställningspunkterna.

Vi kan till exempel välja den tidigare tidpunkten "28-11-2019-09:53:00" att återställa till. Du kan ange den här återställningspunkten i följande format: dd-mm-åååå, dd-mm-åååå-hh:mm:ss. Om du vill välja en giltig tidpunkt för återställning använder du kommandot az backup recoverypoint show-log-chain , som visar intervallen för obrutna säkerhetskopior av loggkedjan.

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

Svaret på ovanstående fråga är ett återställningskonfigurationsobjekt som visas som:

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

Nu, för att återställa databasen, kör kommandot az restore restore-azurewl. Om du vill använda det här kommandot anger du ovanstående JSON-utdata som sparas i en fil med namnet recoveryconfig.json.

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

Utdata visas som:

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

Svaret ger dig jobbnamnet. Du kan använda det här jobbnamnet för att spåra jobbstatusen med kommandot az backup job show .

Återställa till en sekundär region

Om du vill återställa en databas till den sekundära regionen anger du ett målvalv och en server som finns i den sekundära regionen i återställningskonfigurationen.

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

Svaret är ett återställningskonfigurationsobjekt som visas som:

 {
  "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": []
}

Använd den här återställningskonfigurationen i kommandot az restore restore-azurewl . --use-secondary-region Välj flaggan för att återställa databasen till den sekundära regionen.

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

Utdata visas som:

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

Kommentar

RPO för säkerhetskopieringsdatan som ska vara tillgänglig i den sekundära regionen är 12 timmar. När du aktiverar CRR är därför RPO för den sekundära regionen 12 timmar + loggfrekvensvaraktighet (som kan anges till minst 15 minuter).

Återställa som filer

Om du vill återställa säkerhetskopierade data som filer i stället för en databas använder du RestoreAsFiles som återställningsläge. Välj sedan återställningspunkten, som kan vara en tidigare tidpunkt eller eventuella tidigare återställningspunkter. När filerna har dumpats till en angiven sökväg kan du ta filerna till valfri SQL-dator där du vill återställa dem som en databas. Eftersom du kan flytta dessa filer till valfri dator kan du nu återställa data mellan prenumerationer och regioner.

Välj föregående tidpunkt 28-11-2019-09:53:00 för återställning och platsen för att dumpa backupfiler som C:\restoreasfiles på samma SQL-server. Du kan ange den här återställningspunkten i något av följande format: dd-mm-åååå ellerdd-mm-åååå-hh:mm:ss. Om du vill välja en giltig tidpunkt för återställning använder du kommandot az backup recoverypoint show-log-chain , som visar intervallen för obrutna säkerhetskopior av loggkedjan.

Med namnet på återställningspunkten ovan och återställningsläget skapar du återställningskonfigurationsobjektet med kommandot az backup recoveryconfig show . Kontrollera var och en av de återstående parametrarna i det här kommandot:

  • --target-container-name: Namnet på en SQL-server som har registrerats till ett Recovery Services-valv och som finns i samma region som för databasen som ska återställas. Låt oss återställa databasen med namnet mssqlserver som filer till samma SQL-server som du skyddade.
  • --rp-name: För en återställning till en viss tidpunkt är namnet på återställningspunkten 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

Svaret på frågan ovan är ett återställningskonfigurationsobjekt som visas som:

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

För att återställa databasen som filer, kör kommandot az restore restore-azurewl. Om du vill använda det här kommandot anger du JSON-utdata ovan som sparas i en fil med namnet recoveryconfig.json.

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

Utdata visas som:

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

Svaret ger dig jobbnamnet. Du kan använda det här jobbnamnet för att spåra jobbstatusen med kommandot az backup job show .

Kommentar

Om du inte vill återställa hela kedjan utan bara en delmängd filer följer du stegen som beskrivs här.

Återställning mellan prenumerationer

Med Cross Subscription Restore (CSR) har du flexibiliteten att återställa till vilken prenumeration och vilket säkerhetsvalv som helst under din hyresgäst, förutsatt att återställningsbehörigheter finns tillgängliga. Som standard är CSR aktiverat på alla Recovery Services-valv (befintliga och nyligen skapade valv).

Kommentar

  • Du kan utlösa återställning mellan olika prenumerationer från Recovery Services valvet.
  • CSR stöds endast för direktuppspelningsbaserad säkerhetskopiering och stöds inte för ögonblicksbildsbaserad säkerhetskopiering.
  • Cross Regional Restore (CRR) med CSR stöds inte.
az backup vault create

Lägg till parametern cross-subscription-restore-state som gör att du kan ange CSR-tillståndet för valvet när valvet skapas och uppdateras.

az backup recoveryconfig show

Lägg till parametern --target-subscription-id som gör att du kan ange målprenumerationen som indata när du utlöser återställning mellan prenumerationer för SQL- eller HANA-datakällor.

Exempel:

   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}

Återställ snapshots för SQL-instanser

Följande exempel använder PowerShell-shellsyntax, inte Bash. Använd en Azure CLI-version som visar snapshot-alternativen som visas i denna artikel. Gå igenom förutsättningarna för snapshotåterställning och supportmatrisen.

Byt ut platshållare innan användning. Slutför den gemensamma installationen och välj endast det nödvändiga återställningsscenariot. Följande exempel är alternativ, inte ett skript att köra i sin helhet. Återställningskommandon kan skriva över data eller ändra diskanslutningar.

Konfigurera variabler för återställning av snapshots

Använd prenumerationen för vault för $vaultSubscription. Förbered målresursgruppen och användartilldelad hanterad identitet med de nödvändiga behörigheterna:

$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")

Kopiera exakt nativa container- och namn på skyddade objekt från tjänstens utdata. Källa- och destinationsuppsättningen ovan använder samma vault. För återställningar till alternativ plats, kontrollera att målinstansen är upptäckbar:

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

De långa alternativen i dessa exempel stöder också följande kortare alias:

Långt alternativ 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

Fråga återställningspunkter för ögonblicksbild

Lista alla begärda typer av återställningspunkter för ett tidsfönster, endast snapshots eller endast den senaste snapshoten:

$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

Välj en återställningspunkt explicit; anta inte listordning. Hämta dess fullständiga detaljer för att granska inkluderade databaser och filsysteminformation:

$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

Sök i snapshot-baserade loggintervall

Hämta instansensprotectedItemDataSourceId. Detta ID är ID:t för basdatakällan för loggfrågor, inte datakälls-ID:t för en enskild databas.

$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

Välj ett databasobjekt som motsvarar en av snapshotens inkluderade databaser. Använd show-log-chain för kontinuerliga återhämtningstidsintervall, istället för att behandla enskilda återhämtningspunkter som loggintervall.

Återställ instansen till ursprunglig plats

Generera konfigurationen för återställning till ursprunglig plats (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

Innan du skickar in, inspektera volymmappningarna. Återställning till ursprunglig plats kan skriva över de ursprungliga databaserna.

Återställning av instans till alternativ plats

Använd destinationscontainern, servern och SQL-instansen. Ställ --target-item-name in på det önskade måldatabasnamnet eller ett instansnamnsmönster som stöds av tjänsten:

$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

Instansåterställning till en viss tidpunkt

Använd den valda instanssnapshoten och dess bas-datakälls-ID från de tidigare frågningarna. Matcha varje inkluderad databas till ett unikt skyddat objekt och hämta sedan dess loggintervall ovanför den ögonblicksbilden:

$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)."
  }
}

Inspektera databasens intervall och välj en UTC-tid. Följande exempel väljer den senaste sluttiden för databasen och verifierar sedan att tiden också är tillgänglig för varje inkluderad databas. Om valideringen misslyckas, välj en tid inom de vanliga tillgängliga intervallen och kör kontrollen igen:

$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")

Generera PITR-konfigurationen med bassnapshoten och den validerade logguppspelningstiden:

$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 begär att databaser förblir inte återställda för efterföljande återställningssteg. Granska om det beteendet är lämpligt för din återhämtningsplan.

Återställ instans som diskar

Använd SnapshotAttach för att återställa som diskar (RAD), istället för snapshot-bilaga följt av databasåterställning:

$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

Återställ en databas som skyddas av en instans

Välj det exakta namnet på det interna databasobjektet från källcontainern. För återställningar från återställningspunkter, välj en databassnapshot uttryckligen:

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

Återställning av databas till alternativ plats

$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

Återställning av databas till en viss tidpunkt

Sök i tillgängliga loggintervall och välj en UTC-tid inom ett returnerat intervall. Använd formatet 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 föregående exemplen på databasåterställning använder också --no-recovery-mode. Granska inställningen innan du skickar in.

Databasåterställning som enheter

$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

Återställ databas som diskar med loggar som filer

Sätt $pit till en giltig UTC-tid från intervallen i databasloggarna, som i databasens PITR-exempel. Generera konfigurationen för diskanslutning och sätt sedan destinationen för loggfiler:

$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

Efter att ha bekräftat att konfigurationsgenereringen lyckades, redigera de genererade mappningarna:

$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

Granska och skicka in en återställning av en snapshot

För varje valt scenario, bekräfta att az backup recoveryconfig show lyckas innan du använder dess utdata. Inspektera de genererade fil- och volymmappningarna. Mappa om endast källvolymer som kräver en annan målväg. Ersätt exempel på drivbokstäver med faktiska vägar:

$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

Den föregående ommappningen är valfri. Bevara de avsedda mappningarna för ditt valda scenario, inklusive eventuell konfiguration av databasdiskar och loggfiler.

Om diskavkoppling krävs för att lösa en filsystemkrock, lägg endast till uttryckligen godkända disk-ID till den genererade konfigurationen:

$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

Varning

Att koppla bort befintliga diskar kan störa arbetsbelastningar på målet. Verifiera varje disk-ID och den fullständiga återställningskonfigurationen innan du startar återställningen. Använd inte det valfria exemplet för att koppla från en disk om inte operationen krävs och godkänns.

Skicka endast konfigurationsfilen för den valda operationen:

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

Spåra det returnerade jobbnamnet med az backup job show. För stopp-skydd och avregistreringskommandon, se Hantera SQL-instanssnapshot-backups.

Gå vidare