Restaurar bancos de dados SQL em uma VM do Azure usando a CLI do Azure

A CLI do Azure é usada para criar e gerenciar recursos do Azure a partir da Linha de Comando ou por meio de scripts. Este artigo descreve como restaurar um banco de dados SQL de backup em uma VM do Azure usando a CLI do Azure. Você também pode executar essas ações usando o portal do Azure.

Use o Azure Cloud Shell para executar comandos da CLI.

Este artigo assume que tens uma base de dados SQL a correr numa VM do Azure que tem cópia de segurança através do Azure Backup. Se você usou Fazer backup de um banco de dados SQL no Azure usando a CLI para fazer backup do banco de dados SQL, está usando os seguintes recursos:

• Um grupo de recursos chamado SQLResourceGroup.
• Um cofre chamado SQLVault.
• Contêiner protegido chamado VMAppContainer;Compute;SQLResourceGroup;testSQLVM.
• Uma base de dados/item com backup chamado sqldatabase;mssqlserver;testdb.
• Recursos na westus região.

Para visualizar os cenários de backup e restauração aos quais damos suporte atualmente, consulte a matriz de suporte. Para perguntas comuns, consulte as perguntas frequentes.

Exibir pontos de restauração para um banco de dados de backup

Para exibir a lista de todos os pontos de recuperação de um banco de dados, use o comando az backup recoverypoint list como:

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

A lista de pontos de recuperação aparece como:

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

A lista acima contém três pontos de recuperação: cada um para backup completo, diferencial e de log.

Note

Você também pode visualizar os pontos de início e de término de cada cadeia de backup de log ininterrupta, usando o comando az backup recoverypoint show-log-chain.

Pré-requisitos para restaurar um banco de dados

Certifique-se de que os seguintes pré-requisitos sejam atendidos antes de restaurar um banco de dados:

• Você pode restaurar o banco de dados somente para uma instância SQL na mesma região ou para uma região diferente se a Cross Region Restore estiver ativada no cofre.
• A instância de destino deve estar registada no mesmo cofre que a origem, exceto durante a Cross Region Restore e a Cross Subscription Restore. .

Restaurar uma base de dados

O Backup do Azure pode restaurar bancos de dados SQL que estão sendo executados em VMs do Azure como:

• Restaure para uma data ou hora específica (ao segundo) usando cópias de segurança de log. O Backup do Azure determina automaticamente os backups completos e diferenciais apropriados e a cadeia de backups de log que são necessários para restaurar com base no tempo selecionado.
• Restaure a partir de um backup completo ou diferencial para um ponto de recuperação específico.

Para restaurar um banco de dados, use o comando az restore restore-azurewl , que requer um objeto de configuração de recuperação como uma das entradas. Você pode gerar esse objeto usando o comando az backup recoveryconfig show . O objeto de configuração de recuperação contém todos os detalhes para executar uma restauração. Um deles é o modo de restauração – OriginalWorkloadRestore ou AlternateWorkloadRestore.

Note

OriginalWorkloadRestore: Restaura dados para a mesma instância SQL que a fonte original. Esta opção substitui o banco de dados original. AlternateWorkloadRestore: restaura o banco de dados para um local alternativo e mantém o banco de dados de origem original.

Restaurar para local alternativo

Para restaurar um banco de dados para um local alternativo, use AlternateWorkloadRestore como o modo de restauração. Em seguida, deve escolher o ponto de restauração, que pode ser um momento específico anterior ou quaisquer pontos de restauração anteriores.

Vamos prosseguir para restaurar para um ponto de restauração anterior. Exiba a lista de pontos de restauração para o banco de dados e escolha o ponto que deseja restaurar. Aqui, vamos usar o ponto de restauração com o nome 7660777527047692711.

Com o nome do ponto de restauração acima e o modo de restauração, crie o objeto de configuração de recuperação usando o comando az backup recoveryconfig show . Verifique os parâmetros restantes neste comando:

• --target-item-name: O nome a ser usado pelo banco de dados restaurado. Nesse cenário, usamos o nome restored_database.
• --target-server-name: o nome de um servidor SQL que é registrado com êxito em um cofre dos Serviços de Recuperação e permanece na mesma região de acordo com o banco de dados a ser restaurado. Aqui, você está restaurando o banco de dados para o mesmo servidor SQL que você protegeu, chamado testSQLVM.
• --target-server-type: Para a restauração de bancos de dados SQL, você deve usar 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

A resposta à consulta acima é um objeto de configuração de recuperação que aparece como:

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

Agora, para restaurar o banco de dados, execute o comando az restore restore-azurewl . Para usar esse comando, insira a saída JSON acima salva em um arquivo chamado recoveryconfig.json.

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

A saída aparece como:

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

A resposta fornece o nome do trabalho. Você pode usar esse nome de trabalho para acompanhar o status do trabalho usando o comando az backup job show .

Restaurar e sobrescrever

Para restaurar para o local original, use OriginalWorkloadRestore como o modo de restauração. Em seguida, deverá escolher o ponto de restauração, que pode ser um momento anterior ou quaisquer dos pontos de restauração anteriores.

Como exemplo, vamos escolher o point-in-time anterior "28-11-2019-09:53:00" para restaurar. Você pode fornecer esse ponto de restauração nos seguintes formatos: dd-mm-aaaa, dd-mm-aaaa-hh:mm:ss. Para escolher um momento específico válido para restaurar, use o comando az backup recoverypoint show-log-chain, que lista os intervalos de backups ininterruptos da cadeia de registos.

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

A resposta à consulta acima é um objeto de configuração de recuperação que aparece como:

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

Agora, para restaurar o banco de dados, execute o comando az restore restore-azurewl . Para usar esse comando, insira a saída JSON acima salva em um arquivo chamado recoveryconfig.json.

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

A saída aparece como:

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

A resposta fornece o nome do trabalho. Você pode usar esse nome de trabalho para acompanhar o status do trabalho usando o comando az backup job show .

Restaurar para uma região secundária

Para restaurar um banco de dados na região secundária, especifique o cofre de destino e o servidor localizado nessa região, na configuração de restauração.

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

A resposta é um objeto de configuração de recuperação que aparece como:

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

Use a configuração de recuperação no comando az restore restore-azurewl. Selecione o --use-secondary-region sinalizador para restaurar o banco de dados para a região secundária.

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

A saída aparece como:

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

Note

O RPO para que os dados de backup estejam disponíveis na região secundária é de 12 horas. Portanto, quando você ativa a CRR, o RPO para a região secundária é de 12 horas + duração da frequência de log (que pode ser definida para um mínimo de 15 minutos).

Restaurar como ficheiros

Para restaurar os dados de backup como arquivos em vez de um banco de dados, use RestoreAsFiles como o modo de restauração. Em seguida, escolha o ponto de restauração, que pode ser um ponto no tempo anterior ou qualquer ponto de restauração anterior. Depois que os arquivos são despejados para um caminho especificado, você pode levar esses arquivos para qualquer máquina SQL onde você deseja restaurá-los como um banco de dados. Como você pode mover esses arquivos para qualquer máquina, agora pode restaurar os dados entre assinaturas e regiões.

Escolhe o ponto no tempo 28-11-2019-09:53:00 anterior para restaurar e o local para despejar ficheiros de backup como C:\restoreasfiles no mesmo servidor SQL. Você pode fornecer esse ponto de restauração em um dos seguintes formatos: dd-mm-aaaa ou dd-mm-aa-hh:mm:ss. Para escolher um momento específico válido para restaurar, use o comando az backup recoverypoint show-log-chain, que lista os intervalos de backups ininterruptos da cadeia de registos.

Com o nome do ponto de restauração acima e o modo de restauração, crie o objeto de configuração de recuperação usando o comando az backup recoveryconfig show . Verifique cada um dos parâmetros restantes neste comando:

• --target-container-name: o nome de um servidor SQL registado com sucesso num cofre do Serviços de Recuperação e presente na mesma região que o banco de dados a ser restaurado. Vamos restaurar a base de dados para ficheiros no mesmo servidor SQL que protegeu, chamado mssqlserver.
• --rp-name: Para uma restauração point-in-time, o nome do ponto de restauração é 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

A resposta à consulta acima é um objeto de configuração de recuperação que aparece como:

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

Agora, para restaurar o banco de dados como arquivos, execute o comando az restore restore-azurewl . Para usar esse comando, insira a saída JSON acima salva em um arquivo chamado recoveryconfig.json.

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

A saída aparece como:

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

A resposta fornece o nome do trabalho. Você pode usar esse nome de trabalho para acompanhar o status do trabalho usando o comando az backup job show .

Note

Se você não quiser restaurar toda a cadeia, mas apenas um subconjunto de arquivos, siga as etapas conforme documentado aqui.

Restauração de assinatura cruzada

Com o Cross Subscription Restore (CSR), você tem a flexibilidade de restaurar para qualquer assinatura e qualquer cofre sob seu locatário se as permissões de restauração estiverem disponíveis. Por padrão, o CSR está habilitado em todos os cofres dos Serviços de Recuperação (cofres existentes e recém-criados).

Note

• Você pode acionar a restauração entre diferentes assinaturas a partir do cofre de Serviços de Recuperação.
• O CSR é suportado apenas para backup baseado em streaming e não é suportado para backup baseado em instantâneo.
• Não há suporte para CRR (Cross Regional Restore) com CSR.

az backup vault create

Adicione o parâmetro cross-subscription-restore-state que permite definir o estado CSR do vault durante a criação e atualização do vault.

az backup recoveryconfig show

Adicione o parâmetro --target-subscription-id que permite fornecer a assinatura de destino como entrada ao acionar a restauração entre assinaturas para fontes de dados SQL ou HANA.

Example:

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

Restaurar snapshots de instância SQL

Os exemplos seguintes usam a sintaxe shell do PowerShell, não o Bash. Use uma versão do CLI do Azure que exponha as opções de snapshot apresentadas neste artigo. Revise os pré-requisitos de restauro de instantâneo e a matriz de suporte.

Substitua os placeholders antes da utilização. Complete a configuração comum e escolha apenas o cenário de restauro necessário. Os exemplos seguintes são alternativas, não um script para executar na íntegra. Os comandos de restauro podem sobrescrever dados ou alterar anexações de disco.

Configurar variáveis de restauro de instantâneo

Utilize a subscrição do vault para $vaultSubscription. Prepare o grupo de recursos alvo e a identidade gerida atribuída pelo utilizador com as permissões necessárias:

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

Copie os nomes exatos dos contentores nativos e dos itens protegidos a partir da saída do serviço. A configuração de origem e destino acima usa o mesmo cofre. Para restaurações em locais alternativos, verifique se a instância alvo é descobrível:

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

As opções longas nestes exemplos também suportam os seguintes aliases mais curtos:

Opção longa	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

Consulta de pontos de recuperação de instantâneos

Liste todos os tipos de pontos de recuperação solicitados para uma janela temporal, apenas snapshots ou apenas o snapshot mais recente:

$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

Escolha explicitamente um ponto de recuperação; não assuma a ordem das listas. Recupere os detalhes completos para inspecionar as bases de dados incluídas e a informação do sistema de ficheiros:

$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

Consultar intervalos de registos baseados em instantâneos

Recupera o da instânciaprotectedItemDataSourceId. Este ID é a origem de dados base para consultas de registo, não o ID da origem de dados de uma base de dados individual.

$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

Selecione um item da base de dados que corresponda a uma das bases de dados incluídas no snapshot. Utilize show-log-chain para intervalos de tempo de recuperação contínuos, em vez de tratar pontos individuais de recuperação como intervalos de registo.

Restauro da localização original da instância

Gerar a configuração de restauro para a localização original (OLR).

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

Antes de enviar, verifique os mapeamentos de volume. A restauração da localização original pode sobrescrever as bases de dados originais.

Restauro de localização alternativa da instância

Utilize o contentor de destino, o servidor e a instância SQL. Defina --target-item-name como o nome da base de dados de destino necessário ou um padrão de nomenclatura de instância suportado pelo serviço:

$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

Restauro da instância num ponto específico no tempo

Utilize o snapshot da instância selecionada e o respetivo ID base da fonte de dados das consultas anteriores. Resolva todas as bases de dados incluídas para um único item protegido, depois consulte os seus intervalos de registo acima desse instantâneo:

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

Inspecionar os intervalos de uma base de dados e escolher uma hora UTC. O exemplo seguinte escolhe a hora de fim mais recente para essa base de dados e verifica se a hora também está disponível para todas as bases de dados incluídas. Se a validação falhar, selecione uma hora dentro dos intervalos comuns disponíveis e execute novamente a verificação:

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

Gera a configuração PITR usando o snapshot base e o tempo validado de replay log:

$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 solicita que as bases de dados permaneçam não recuperadas para passos subsequentes de recuperação. Verifique se esse comportamento é adequado para o seu plano de recuperação.

Restaurar instância a partir de discos

Utilize SnapshotAttach para restaurar como discos (RAD), em vez de anexação de snapshot seguida de recuperação da base de dados:

$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

Restaurar uma base de dados protegida numa instância

Selecione o nome exato do item nativo da base de dados a partir do contentor de origem. Para restaurações de pontos de recuperação, escolha explicitamente um snapshot da base de dados:

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

Restauração de localização alternativa da base de dados

$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

Restauro pontual de uma base de dados

Consulta os intervalos de registos disponíveis e escolha uma hora UTC dentro de um intervalo devolvido. Utilize o formato 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

Os exemplos anteriores de restauração de bases de dados também utilizam --no-recovery-mode. Reveja esta definição antes de submeter.

Restauração da base de dados enquanto discos

$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

Restaurar base de dados como discos com registos como ficheiros

Defina $pit para uma hora UTC válida a partir dos intervalos de registos da base de dados, como no exemplo de PITR da base de dados. Gera a configuração de ligação ao disco e depois defina o destino para ficheiros de 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

Após confirmar que a geração de configuração foi bem-sucedida, edite os mapeamentos gerados:

$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

Rever e submeter um restauro de snapshot

Para cada cenário selecionado, confirme que az backup recoveryconfig show é bem-sucedido antes de usar a sua saída. Inspecione o ficheiro gerado e os mapeamentos de volume. Remapeia apenas volumes de origem que requerem um caminho de destino diferente. Substitua as letras de unidade de exemplo por caminhos reais:

$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

O remapeamento anterior é opcional. Mantenha os mapeamentos pretendidos para o cenário selecionado, incluindo qualquer configuração dos ficheiros de disco e de registo da base de dados.

Se for necessário o destacamento do disco para resolver um conflito no sistema de ficheiros, adicione apenas IDs de disco explicitamente aprovados à configuração gerada:

$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

Desanexar discos existentes pode perturbar as cargas de trabalho de destino. Verifique todos os IDs do disco e a configuração completa da recuperação antes de submeter a restauração. Não apliquem o exemplo opcional do desacoplamento do disco a menos que a operação seja exigida e aprovada.

Submeta apenas o ficheiro de configuração para a operação escolhida:

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

Acompanhe o nome da tarefa devolvida com az backup job show. Para comandos de desativação da proteção e desregisto, veja Gerir backups de instantâneos de instância SQL.

Próximo passo

• Gerencie bancos de dados SQL cujo backup é feito usando a CLI do Azure.

Conteúdo relacionado

• Faça backup de bancos de dados do SQL Server em VMs do Azure usando o Backup do Azure via API REST.
• Restaure bancos de dados do SQL Server em VMs do Azure com a API REST.
• Gerencie bancos de dados do SQL Server em VMs do Azure com o portal do Azure, CLI do Azure, API REST.