Ripristinare i database SQL in una macchina virtuale di Azure tramite l'interfaccia della riga di comando di Azure

L'interfaccia della riga di comando di Azure consente di creare e gestire le risorse di Azure dalla riga di comando o tramite script. Questo articolo spiega come ripristinare un database SQL sottoposto a backup in una macchina virtuale di Azure tramite l'interfaccia della riga di comando di Azure. È anche possibile eseguire queste procedure tramite il portale di Azure.

Usare Azure Cloud Shell per eseguire i comandi dell'interfaccia della riga di comando.

Questo articolo presuppone che tu abbia un database SQL in esecuzione su una VM Azure e di cui viene eseguito il backup tramite Backup di Azure. Se è stata usata l'esercitazione Eseguire il backup di un database SQL in Azure tramite l'interfaccia della riga di comando per eseguire il backup del database SQL, sono in uso le risorse seguenti:

• Gruppo di risorse denominato SQLResourceGroup.
• Insieme di credenziali denominato SQLVault.
• Contenitore protetto denominato VMAppContainer;Compute;SQLResourceGroup;testSQLVM.
• Un database/elemento di cui è stato eseguito il backup chiamato sqldatabase;mssqlserver;testdb.
• Risorse nell'area westus.

Per visualizzare gli scenari di backup e ripristino attualmente supportati, vedere la matrice di supporto. Per domande comuni, vedere le domande frequenti.

Visualizzare i punti di ripristino per un database sottoposto a backup

Per visualizzare l'elenco di tutti i punti di ripristino per un database, usare il comando az backup recoverypoint list come indicato di seguito:

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

Viene visualizzato un elenco dei punti di recupero simile al seguente:

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

L'elenco precedente contiene tre punti di ripristino: uno per il backup completo, uno per il backup differenziale e uno per il backup del log.

Prerequisiti per il ripristino di un database

Prima di ripristinare un database, verificare che siano soddisfatti i prerequisiti seguenti:

• È possibile ripristinare il database solo in un'istanza SQL nella stessa regione o in una regione diversa se il Ripristino tra Regioni è abilitato nella cassetta di sicurezza.
• L'istanza di destinazione deve essere registrata con lo stesso insieme di credenziali dell'origine, tranne durante il ripristino tra regioni e il ripristino tra sottoscrizioni. .

Ripristinare un database

Backup di Azure può ripristinare database SQL in esecuzione nelle macchine virtuali di Azure seguendo questa procedura:

• Ripristinare una data specifica o un'ora (al secondo), usando i backup del log. In base ai tempi di ripristino specificati, Backup di Azure determina automaticamente i backup completi, differenziali e la catena di backup del log necessari per ripristinare in base all'ora selezionata.
• Ripristinare un backup completo o differenziale specifico per il ripristino a un punto di ripristino specifico.

Per ripristinare un database, usare il comando az restore restore-azurewl, che richiede un oggetto configurazione di ripristino come uno degli input. È possibile generare questo oggetto usando il comando az backup recoveryconfig show. L'oggetto configurazione di ripristino contiene tutti i dettagli per eseguire un ripristino. Uno di essi è la modalità di ripristino, ovvero OriginalWorkloadRestore o AlternateWorkloadRestore.

Ripristinare in un percorso alternativo

Per ripristinare un database in un percorso alternativo, usare AlternateWorkloadRestore come modalità di ripristino. È quindi necessario scegliere il punto di ripristino, che può corrispondere a un punto precedente specifico nel tempo o a uno dei punti di ripristino precedenti.

In questo caso verrà ripristinato un punto di ripristino precedente. Visualizzare l'elenco dei punti di ripristino per il database e scegliere il punto in cui si desidera eseguire il ripristino. In questo caso si userà il punto di ripristino con il nome 7660777527047692711.

Usando il nome del punto di ripristino e la modalità di ripristino precedenti, verrà creato l'oggetto configurazione di ripristino usando il comando az backup recoveryconfig show. Controllare i parametri rimanenti in questo comando:

• --target-item-name: nome che deve essere usato dal database ripristinato. In questo scenario, è stato usato il nome restored_database.
• --target-server-name: nome di un server SQL registrato correttamente in un insieme di credenziali di Servizi di ripristino e che risiede nella stessa area del database da ripristinare. In questo caso si sta ripristinando il database nello stesso server SQL protetto, denominato testSQLVM.
• --target-server-type: per il ripristino dei database SQL, è necessario usare 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 risposta alla query precedente è un oggetto configurazione di ripristino simile al seguente:

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

A questo punto, per ripristinare il database, eseguire il comando az restore restore-azurewl. Per usare questo comando, immettere l'output JSON precedente salvato in un file denominato recoveryconfig.json.

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

L'output viene visualizzato come segue:

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 risposta fornisce il nome del processo. È possibile usare questo nome per tenere traccia dello stato del processo usando il comando az backup job show.

Ripristinare e sovrascrivere

Per eseguire il ripristino nel percorso originale, usare la modalità di ripristino OriginalWorkloadRestore. È quindi necessario scegliere il punto di ripristino, che può corrispondere a un punto precedente specifico nel tempo o a uno dei punti di ripristino precedenti.

Come esempio, in questo caso viene scelto il punto precedente nel tempo "28-11-2019-09:53:00" in cui eseguire il ripristino. È possibile specificare questo punto di ripristino nei formati seguenti: gg-mm-aaaa, gg-mm-aaaa-hh: mm:ss. Per scegliere un ripristino temporizzato valido, usare il comando az backup recoverypoint show-log-chain, che elenca gli intervalli di backup della catena di log non interrotti.

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 risposta alla query precedente è un oggetto configurazione di ripristino simile al seguente:

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

A questo punto, per ripristinare il database, eseguire il comando az restore restore-azurewl. Per usare questo comando, immettere l'output JSON precedente salvato in un file denominato recoveryconfig.json.

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

L'output viene visualizzato come segue:

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 risposta fornisce il nome del processo. È possibile usare questo nome per tenere traccia dello stato del processo usando il comando az backup job show.

Eseguire il ripristino in un'area secondaria

Per ripristinare un database nell'area secondaria, nella configurazione di ripristino specificare un insieme di credenziali di destinazione e un server che si trova nell'area secondaria.

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 risposta è un oggetto di configurazione di ripristino simile al seguente:

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

Usare questa configurazione di ripristino nel comando az restore restore-azurewl. Selezionare il flag --use-secondary-region per ripristinare il database nell'area secondaria.

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

L'output viene visualizzato come segue:

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

Ripristinare come file

Per ripristinare i dati di backup come file anziché come database, usare la modalità di ripristino RestoreAsFiles. Scegliere quindi il punto di ripristino, che può corrispondere a un punto precedente specifico nel tempo o a uno dei punti di ripristino precedenti. Dopo aver eseguito il dump dei file in un percorso specificato, è possibile spostare questi file in qualsiasi computer SQL in cui si intende ripristinarli come database. Dal momento che è possibile spostare questi file in qualsiasi computer, è ora possibile ripristinare i dati tra sottoscrizioni e aree diverse.

Scegli il precedente momento 28-11-2019-09:53:00 di ripristino e la posizione per salvare i file di backup come C:\restoreasfiles sullo stesso server SQL. È possibile specificare questo punto di ripristino in uno dei formati seguenti: gg-mm-aaaa o gg-mm-aaaa-hh: mm:ss. Per scegliere un ripristino temporizzato valido, usare il comando az backup recoverypoint show-log-chain, che elenca gli intervalli di backup della catena di log non interrotti.

Usando il nome del punto di ripristino e la modalità di ripristino precedenti, verrà creato l'oggetto configurazione di ripristino usando il comando az backup recoveryconfig show. Controllare i parametri rimanenti in questo comando:

• --target-container-name: nome di un server SQL registrato correttamente in un insieme di credenziali di Servizi di ripristino e che risiede nella stessa area del database da ripristinare. Ripristiniamo il database come insieme di file sullo stesso server SQL che hai protetto, chiamato mssqlserver.
• --rp-name: per un ripristino temporizzato il nome del punto di ripristino è 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 risposta alla query precedente è un oggetto configurazione di ripristino simile al seguente:

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

A questo punto, per ripristinare il database come file, eseguire il comando az restore restore-azurewl. Per usare questo comando, immettere l'output JSON precedente salvato in un file denominato recoveryconfig.json.

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

L'output viene visualizzato come segue:

{
  "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 risposta fornisce il nome del processo. È possibile usare questo nome per tenere traccia dello stato del processo usando il comando az backup job show.

Ripristino tra sottoscrizioni

Con il ripristino tra sottoscrizioni è possibile eseguire il ripristino in qualsiasi sottoscrizione e in qualsiasi insieme di credenziali nel tenant, se sono disponibili le autorizzazioni di ripristino. Per impostazione predefinita, il ripristino tra sottoscrizioni è abilitato in tutti gli insiemi di credenziali di Servizi di ripristino (insiemi di credenziali esistenti e appena creati).

az backup vault create

Aggiungere il parametro cross-subscription-restore-state che consente di impostare lo stato del ripristino tra sottoscrizioni dell'insieme di credenziali durante la creazione e l'aggiornamento dell'insieme di credenziali.

az backup recoveryconfig show

Aggiungere il parametro --target-subscription-id che consente di specificare la sottoscrizione di destinazione come input durante l'attivazione del ripristino tra sottoscrizioni per le origini dati SQL o 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}

Ripristina snapshot di istanza SQL

I seguenti esempi utilizzano la sintassi shell di PowerShell, non Bash. Usa una versione interfaccia della riga di comando di Azure che esponga le opzioni snapshot mostrate in questo articolo. Rivedi i prerequisiti per il ripristino snapshot e la matrice di supporto.

Sostituisci i segnaposto prima di usarli. Completa la configurazione comune e scegli solo lo scenario di ripristino richiesto. I seguenti esempi sono alternative, non uno script da eseguire per intero. I comandi di ripristino possono sovrascrivere i dati o modificare i collegamenti dei dischi.

Imposta le variabili di ripristino snapshot

Usa l'abbonamento del vault per $vaultSubscription. Preparare il gruppo di risorse target e l'identità gestita assegnata dall'utente con i permessi richiesti:

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

Copia i nomi esatti del container nativo e i nomi degli elementi protetti dall'output del servizio. La configurazione sorgente e destinazione sopra utilizza lo stesso vault. Per ripristini in posizioni alternative, verifica che l'istanza target sia rilevabile:

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

Le opzioni lunghe in questi esempi supportano anche i seguenti alias più brevi:

Punti di ripristino snapshot della query

Elencare tutti i tipi di punti di recupero richiesti per una finestra temporale, solo gli snapshot o solo l'ultimo 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

Scegli esplicitamente un punto di recupero; non dare per scontato l’ordine dell’elenco. Recupera i suoi dettagli completi per ispezionare i database inclusi e le informazioni sul file system:

$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

Consulta gli intervalli di log basati su snapshot

Recupera il dell'istanzaprotectedItemDataSourceId. Questo ID è la fonte base dei dati per le query di log, non l'ID della fonte dati di un singolo 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

Seleziona un elemento del database che corrisponda a uno dei database inclusi nello snapshot. Usare show-log-chain per intervalli di tempo di recupero continui, invece di trattare i singoli punti di recupero come intervalli logarithmi.

Ripristino della posizione originale dell'istanza

Genera la configurazione di ripristino della posizione originale (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

Prima di inviare, ispeziona le mappature dei volumi. Il ripristino della posizione originale può sovrascrivere i database originali.

Ripristino di posizione alternativa dell'istanza

Usa il container di destinazione, il server e l'istanza SQL. Imposta --target-item-name sul nome del database di destinazione richiesto o su un modello di denominazione delle istanze supportato dal servizio:

$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

Ripristino dell'istanza a un momento specifico

Usa l'istantanea dell'istanza selezionata e il relativo ID della sorgente dati di base dalle query precedenti. Risolvi ogni database incluso in un elemento protetto univoco, poi consulta i suoi intervalli di log sopra quell'istantaneo:

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

Ispeziona gli intervalli di un database e scegli un orario UTC. L'esempio seguente sceglie l'ultimo orario di fine per quel database, quindi verifica che l'ora sia disponibile anche per ogni database incluso. Se la validazione fallisce, selezionare un orario all'interno degli intervalli comuni disponibili e rieseguire il controllo:

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

Genera la configurazione PITR usando lo snapshot base e il tempo di riproduzione del log validato:

$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 richiede che i database rimangano non recuperati per i successivi passaggi di recupero. Valuta se quel comportamento è appropriato per il tuo piano di recupero.

Ripristino di istanze come dischi

Usa SnapshotAttach per il ripristino come dischi (RAD), anziché il collegamento dello snapshot seguito dal ripristino del database:

$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

Ripristina un database protetto in un'istanza

Seleziona il nome esatto nativo dell'elemento del database dal contenitore di origine. Per i ripristini dei punti di recupero, scegli esplicitamente uno snapshot del database:

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

Ripristino del database in un percorso alternativo

$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

Ripristino del database a un momento specifico nel tempo

Consulta gli intervalli di log disponibili e scegli un orario UTC all'interno di un intervallo restituito. Usa il dd-MM-yyyy-HH:mm:ss formato:

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

Anche gli esempi precedenti di ripristino del database utilizzano --no-recovery-mode. Rivedi quell'impostazione prima di inviare.

Ripristino del database su disco

$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

Ripristino del database con i dati su dischi e i log come file

Imposta $pit su un'ora UTC valida dagli intervalli di log del database, come nell'esempio di PITR del database. Genera la configurazione di collegamento del disco, poi imposta la destinazione per i file di log:

$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

Dopo aver confermato che la generazione della configurazione sia andata bene, modificare le mappature generate:

$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

Rivedi e invia un ripristino da snapshot

Per ogni scenario selezionato, confermare che az backup recoveryconfig show abbia avuto successo prima di utilizzare il suo output. Ispeziona il file generato e le mappature dei volumi. Rimappa solo i volumi di sorgente che richiedono un percorso target diverso. Sostituisci le lettere di unità di esempio con percorsi reali:

$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

La rimappatura precedente è opzionale. Conserva le mappature desiderate per lo scenario selezionato, inclusa qualsiasi configurazione di disco e file di log del database.

Se è necessario un distacco del disco per risolvere un conflitto nel file system, aggiungere solo ID disco esplicitamente approvati alla configurazione generata:

$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

Invia solo il file di configurazione per l'operazione scelta:

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

Traccia il nome del lavoro restituito con az backup job show. Per i comandi stop-protection e disregistrazione, vedi Gestisci backup snapshot di istanza SQL.

Passo successivo

• Gestire i database SQL di cui è stato eseguito il backup con l'interfaccia della riga di comando di Azure.

Contenuti correlati

• Eseguire il backup di database di SQL Server in macchine virtuali di Azure usando Backup di Azure tramite l'API REST.
• Ripristinare i database di SQL Server nelle macchine virtuali di Azure con l'API REST.
• Gestire i database di SQL Server in macchine virtuali di Azure con il portale di Azure, l'interfaccia della riga di comando di Azure, l'API REST.