Wiederherstellen von SQL-Datenbanken in einer Azure-VM über die Azure CLI

Die Azure CLI dient zum Erstellen und Verwalten von Azure-Ressourcen über die Befehlszeile oder mit Skripts. In diesem Artikel wird beschrieben, wie Sie mit der Azure CLI eine gesicherte SQL-Datenbank auf einer Azure-VM wiederherstellen. Sie können diese Schritte auch im Azure-Portal ausführen.

Verwenden Sie Azure Cloud Shell, um die CLI-Befehle auszuführen.

Dieser Artikel geht davon aus, dass Sie eine SQL-Datenbank auf einer Azure VM laufen lassen, die mit Azure Backup gesichert ist. Falls Sie die Anleitung unter Sichern einer SQL-Datenbank in Azure mit der CLI befolgt haben, um Ihre SQL-Datenbank zu sichern, nutzen Sie die folgenden Ressourcen:

Eine Ressourcengruppe namens SQLResourceGroup.
Ein Tresor namens SQLVault.
Ein geschützter Container namens VMAppContainer;Compute;SQLResourceGroup;testSQLVM.
Eine Sicherungskopie-Datenbank/-Element mit dem Namen sqldatabase;mssqlserver;testdb.
Ressourcen in der Region westus.

Informationen zu den derzeit von uns unterstützten Sicherungs- und Wiederherstellungsszenarien finden Sie in der Support-Matrix. Allgemeine Fragen finden Sie in den häufig gestellten Fragen.

Anzeigen von Wiederherstellungspunkten für eine gesicherte Datenbank

Um die Liste aller Wiederherstellungspunkte für eine Datenbank anzuzeigen, verwenden Sie den Befehl az backup recoverypoint list wie folgt:

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

Die Liste der Wiederherstellungspunkte wird wie folgt angezeigt:

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

Die obige Liste enthält drei Wiederherstellungspunkte: jeweils einen für die vollständige, differenzielle und Protokollsicherung.

Hinweis

Sie können auch die Start- und Endpunkte für alle ununterbrochenen Protokollsicherungsketten anzeigen, indem Sie dem Befehl az backup recoverypoint show-log-chain ausführen.

Voraussetzungen für die Wiederherstellung einer Datenbank

Stellen Sie vor dem Wiederherstellen einer Datenbank sicher, dass die folgenden Voraussetzungen erfüllt sind:

Sie können die Datenbank nur in einer SQL-Instanz in derselben Region oder in einer anderen Region wiederherstellen, wenn Cross Region Restore im Tresor aktiviert ist.
Die Zielinstanz muss mit demselben Tresor wie die Quelle registriert werden, mit Ausnahme der Wiederherstellung über Regionen hinweg und der Wiederherstellung über Abonnements hinweg. .

Wiederherstellen einer Datenbank

Azure Backup kann auf Azure-VMs ausgeführte SQL-Datenbanken wie folgt wiederherstellen:

Wiederherstellung eines bestimmten Datums oder einer bestimmten Uhrzeit (sekundengenau) mithilfe von Protokollsicherungen. Azure Backup ermittelt automatisch die geeigneten vollständigen und differentiellen Sicherungen sowie die Kette von Protokollsicherungen, die für die Wiederherstellung benötigt werden, auf Grundlage des ausgewählten Zeitpunkts.
Wiederherstellung einer bestimmten vollständigen oder differenziellen Sicherung, um die Daten eines bestimmten Wiederherstellungspunkts wiederherzustellen.

Führen Sie zum Wiederherstellen einer Datenbank den Befehl az restore restore-azurewl aus. Hierfür ist als eine der Eingaben ein Objekt für die Wiederherstellungskonfiguration erforderlich. Sie können dieses Objekt mit dem Befehl az backup recoveryconfig show generieren. Das Objekt für die Wiederherstellungskonfiguration enthält alle Details zur Durchführung einer Wiederherstellung. Eines davon ist der Wiederherstellungsmodus: OriginalWorkloadRestore oder AlternateWorkloadRestore.

Hinweis

OriginalWorkloadRestore: Stellt die Daten in derselben SQL-Instanz wie die ursprüngliche Quelle wieder her. Bei dieser Option wird die ursprüngliche Datenbank überschrieben. AlternateWorkloadRestore: Die Datenbank wird an einem alternativen Speicherort wiederhergestellt, und die ursprüngliche Quelldatenbank bleibt erhalten.

Wiederherstellen an einem alternativen Speicherort

Verwenden Sie AlternateWorkloadRestore als Wiederherstellungsmodus, wenn Sie eine Datenbank an einem anderen Speicherort wiederherstellen möchten. Anschließend müssen Sie den Wiederherstellungspunkt auswählen. Dies kann entweder ein früherer Zeitpunkt oder einer der vorherigen Wiederherstellungspunkte sein.

Fahren wir mit der Wiederherstellung eines vorherigen Wiederherstellungspunkts fort. Zeigen Sie die Liste mit den Wiederherstellungspunkten für die Datenbank an, und wählen Sie den Wiederherstellungspunkt aus. Hier wählen wir den Wiederherstellungspunkt mit dem Namen 7660777527047692711.

Unter Verwendung des obigen Wiederherstellungspunktnamens und des Wiederherstellungsmodus erstellen Sie mit dem Befehl az backup recoveryconfig show das Objekt für die Wiederherstellungskonfiguration. Überprüfen Sie die restlichen Parameter in diesem Befehl:

--target-item-name: der für die wiederhergestellte Datenbank zu verwendende Name. In diesem Szenario haben wir den Namen restored_database genutzt.
--target-server-name: Der Name eines SQL Servers, der erfolgreich in einem Recovery Services-Tresor registriert wurde und sich in derselben Region wie die wiederherzustellende Datenbank befindet. Hier stellen Sie die Datenbank in derselben SQL Server-Instanz wieder her, die Sie geschützt haben und testSQLVM heißt.
--target-server-type: Für die Wiederherstellung von SQL-Datenbanken müssen Sie SQLInstance verwenden.


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

Die Antwort auf die obige Abfrage ist ein Wiederherstellungskonfigurationsobjekt, das wie folgt aussieht:

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

Führen Sie nun zum Wiederherstellen der Datenbank den Befehl az restore restore-azurewl aus. Für diesen Befehl geben wir die obige JSON-Ausgabe ein, die in einer Datei mit dem Namen recoveryconfig.json gespeichert wurde.

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

Die Ausgabe sieht wie folgt aus:

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

Die Antwort liefert Ihnen den Jobnamen. Dieser Auftragsname kann zum Nachverfolgen des Auftragsstatus mit dem Befehl az backup job show verwendet werden.

Wiederherstellen und Überschreiben

Verwenden Sie OrignialWorkloadRestore als Wiederherstellungsmodus für die Wiederherstellung am ursprünglichen Speicherort. Anschließend müssen Sie den Wiederherstellungspunkt auswählen. Dies kann ein früherer Zeitpunkt oder einer der vorherigen Wiederherstellungspunkte sein.

Als Beispiel wählen wir den vorherigen Zeitpunkt 28-11-2019-09:53:00 für die Wiederherstellung. Sie können diesen Wiederherstellungspunkt in den folgenden Formaten angeben: tt-mm-jjjj, „tt-mm-jjjj-hh:mm:ss. Verwenden Sie den Befehl az backup recoverypoint show-log-chain, um einen gültigen Zeitpunkt für die Wiederherstellung auszuwählen. Hiermit werden die Intervalle ununterbrochener Protokollkettensicherungen aufgelistet.

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

Die Antwort auf die obige Abfrage ist ein Wiederherstellungskonfigurationsobjekt, das wie folgt aussieht:

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

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

Die Ausgabe sieht wie folgt aus:

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

Die Antwort liefert Ihnen den Jobnamen. Dieser Auftragsname kann zum Nachverfolgen des Auftragsstatus mit dem Befehl az backup job show verwendet werden.

Wiederherstellung in einer sekundären Region

Um eine Datenbank in der sekundären Region wiederherzustellen, geben Sie in der Wiederherstellungskonfiguration einen Zieldatenspeicher und einen Server in der sekundären Region an.

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

Die Antwort ist ein Objekt für die Wiederherstellungskonfiguration, das wie folgt angezeigt wird:

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

Verwenden Sie diese Wiederherstellungskonfiguration im Befehl az restore restore-azurewl. Wählen Sie das Kennzeichen --use-secondary-region, um die Datenbank in der sekundären Region wiederherzustellen.

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

Die Ausgabe sieht wie folgt aus:

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

Hinweis

Der RPO-Wert für die Verfügbarkeit der Sicherungsdaten in der sekundären Region beträgt 12 Stunden. Wenn Sie CRR aktivieren, beträgt das RPO für die sekundäre Region daher 12 Stunden + Protokollhäufigkeitsdauer (die auf mindestens 15 Minuten festgelegt werden kann).

Wiederherstellen als Dateien

Um die Sicherungsdaten als Dateien anstatt als Datenbank wiederherzustellen, wählen wir als Wiederherstellungsmodus RestoreAsFiles. Wählen Sie anschließend den Wiederherstellungspunkt. Dies kann entweder ein früherer Zeitpunkt oder einer der vorherigen Wiederherstellungspunkte sein. Sobald die Dateien an einen angegebenen Pfad ausgegeben wurden, können Sie diese Dateien auf jede SQL-Maschine bringen, auf der Sie sie als Datenbank restaurieren möchten. Da Sie diese Dateien auf einen beliebigen Computer verschieben können, können Sie nun die Daten über Abonnements und Regionen hinweg wiederherstellen.

Wählen Sie den vorherigen Zeitpunkt 28-11-2019-09:53:00 für die Wiederherstellung und den Speicherort für Sicherungsdateikopien als C:\restoreasfiles in derselben SQL Server-Instanz aus. Sie können diesen Wiederherstellungspunkt in einem der folgenden Formate angeben: tt-mm-jjjj oder tt-mm-jjjj-hh:mm:ss. Verwenden Sie den Befehl az backup recoverypoint show-log-chain, um einen gültigen Zeitpunkt für die Wiederherstellung auszuwählen. Hiermit werden die Intervalle ununterbrochener Protokollkettensicherungen aufgelistet.

--target-container-name: der Name eines SQL Server, der erfolgreich in einem Recovery Services-Tresor registriert wurde und sich in derselben Region wie die wiederherzustellende Datenbank befindet. Lassen Sie uns die Datenbank als Dateien auf denselben SQL-Server wiederherstellen, den Sie geschützt haben, genannt mssqlserver.
--rp-name: Für eine Wiederherstellung zu einem bestimmten Zeitpunkt lautet der Wiederherstellungspunktname 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

Die Antwort auf die obige Abfrage ist ein Objekt für die Wiederherstellungskonfiguration, das wie folgt aussieht:

{
  "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ühren Sie nun zum Wiederherstellen der Datenbank als Dateien den Befehl az restore restore-azurewl aus. Für diesen Befehl geben wir die obige JSON-Ausgabe ein, die in einer Datei mit dem Namen recoveryconfig.json gespeichert wurde.

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

Die Ausgabe sieht wie folgt aus:

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

Die Antwort liefert Ihnen den Jobnamen. Dieser Auftragsname kann zum Nachverfolgen des Auftragsstatus mit dem Befehl az backup job show verwendet werden.

Hinweis

Wenn Sie nicht die gesamte Kette, sondern nur eine Teilmenge von Dateien wiederherstellen möchten, befolgen Sie die Schritte, die hier dokumentiert sind.

Abonnementübergreifende Wiederherstellung

Mit abonnementübergreifender Wiederherstellung (Cross Subscription Restore, CSR) haben Sie die Flexibilität, jedes Abonnement und jeden Tresor unter Ihrem Mandanten wiederherzustellen, wenn Wiederherstellungsberechtigungen verfügbar sind. Standardmäßig ist CSR für alle Recovery Services-Tresore (vorhandene und neu erstellte Tresore) aktiviert.

Hinweis

Sie können die abonnementübergreifende Wiederherstellung aus dem Recovery Services-Vault auslösen.
CSR wird nur für streamingbasierte Sicherungen und nicht für Momentaufnahme-basierte Sicherungen unterstützt.
Cross Regional Restore (CRR) mit CSR wird nicht unterstützt.

az backup vault create

Fügen Sie den Parameter „cross-subscription-restore-state“ hinzu, mit dem Sie den CSR-Status des Tresors während der Erstellung und Aktualisierung des Tresors festlegen können.

az backup recoveryconfig show

Fügen Sie den Parameter „--target-subscription-id“ hinzu, mit dem Sie das Zielabonnement als Eingabe beim Auslösen von Cross Subscription Restore für SQL- oder HANA-Datenquellen angeben können.

Beispiel:

   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}

Wiederherstellen von SQL-Instanz-Snapshots

Die folgenden Beispiele verwenden PowerShell-Shell-Syntax, nicht Bash. Verwenden Sie eine Azure CLI-Version, die die in diesem Artikel gezeigten Snapshot-Optionen offenlegt. Überprüfen Sie die Voraussetzungen für die Snapshot-Wiederherstellung und die Support-Matrix.

Ersetzen Sie Platzhalter vor der Benutzung. Schließen Sie die gemeinsame Einrichtung ab und wählen Sie nur das erforderliche Wiederherstellungsszenario aus. Die folgenden Beispiele sind Alternativen, kein Skript, das vollständig ausgeführt werden soll. Wiederherstellungsbefehle können Daten überschreiben oder Datenträgerzuordnungen ändern.

Snapshot-Wiederherstellungsvariablen einrichten

Verwenden Sie das Abonnement von Tresor für $vaultSubscription. Bereiten Sie die Zielressourcengruppe und die vom Benutzer zugewiesene verwaltete Identität mit den erforderlichen Berechtigungen vor:

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

Kopiere exakte native Container- und geschützte Artikelnamen aus der Serviceausgabe. Die oben beschriebene Quell- und Zielkonfiguration verwendet denselben Vault. Für alternative Standortwiederherstellungen überprüfen Sie, ob die Zielinstanz auffindbar ist:

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

Die langen Optionen in diesen Beispielen unterstützen auch die folgenden kürzeren Aliase:

Lange Option	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`

Abfragemomentaufnahmen-Wiederherstellungspunkte

Liste alle angeforderten Wiederherstellungspunkttypen für ein Zeitfenster auf, nur Schnappschüsse oder nur den neuesten Schnappschuss:

$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

Wähle explizit einen Wiederherstellungspunkt; gehe nicht von der Reihenfolge der Listen aus. Rufen Sie alle Details ab, um die enthaltenen Datenbanken und Dateisysteminformationen zu überprüfen:

$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

Abfrage snapshot-basierter Logbereiche

Die InstanzenprotectedItemDataSourceId abrufen. Diese ID ist die Basisdatenquelle für Logabfragen, nicht die Datenquellen-ID einer einzelnen Datenbank.

$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

Wählen Sie ein Datenbankelement aus, das einer der im Snapshot enthaltenen Datenbanken entspricht. Verwenden Sie show-log-chain für kontinuierliche Wiederherstellungszeitbereiche, anstatt einzelne Wiederherstellungspunkte als Protokollbereiche zu behandeln.

Wiederherstellen des ursprünglichen Instanzspeicherorts

Generiere die Konfiguration für die Wiederherstellung am ursprünglichen Speicherort (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

Überprüfen Sie vor der Einreichung die Volumenzuordnungen. Die Wiederherstellung am ursprünglichen Speicherort kann die ursprünglichen Datenbanken überschreiben.

Wiederherstellung der Instanz an einem alternativen Speicherort

Verwenden Sie den Zielcontainer, den Server und die SQL-Instanz. Setzen Sie --target-item-name auf den erforderlichen Zieldatenbanknamen oder ein dienstunterstütztes Instanznamensmuster:

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

Point-in-Time-Wiederherstellung der Instanz

Verwenden Sie den ausgewählten Instanz-Snapshot und seine Basis-Datenquellen-ID aus den früheren Abfragen. Lösen Sie jede enthaltene Datenbank in ein eindeutig geschütztes Objekt auf und fragen Sie dann deren Protokollbereiche oberhalb dieses Snapshots ab:

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

Überprüfen Sie die Bereiche einer Datenbank und wählen Sie eine UTC-Zeit. Das folgende Beispiel wählt die letzte Endzeit für diese Datenbank und überprüft dann, dass diese Zeit auch für jede enthaltene Datenbank verfügbar ist. Wenn die Validierung fehlschlägt, wählen Sie eine Zeit innerhalb der gemeinsamen verfügbaren Zeitfenster aus und führen Sie die Prüfung erneut durch:

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

Erstellen Sie die PITR-Konfiguration mithilfe des Basis-Snapshots und der validierten Log-Wiedergabezeit:

$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 fordert an, dass Datenbanken für nachfolgende Wiederherstellungsschritte nicht wiederhergestellt bleiben. Überprüfe, ob dieses Verhalten für deinen Wiederherstellungsplan geeignet ist.

Wiederherstellen der Instanz als Datenträger

Verwenden Sie SnapshotAttach für die Wiederherstellung als Festplatten (RAD) anstatt eines Snapshot-Anhangs mit anschließender Datenbankwiederherstellung:

$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

Wiederherstellen Sie eine unter einer Instanz geschützte Datenbank

Wählen Sie den genauen Namen des nativen Datenbankelements aus dem Quellcontainer aus. Für Wiederherstellungspunkt-Wiederherstellungen wählen Sie explizit einen Datenbank-Snapshot:

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

Wiederherstellen der Datenbank über alternative Speicherorte

$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

Point-in-Time-Wiederherstellung der Datenbank

Abfragen Sie verfügbare Logbereiche und wählen Sie eine UTC-Zeit innerhalb eines zurückgegebenen Bereichs aus. Verwenden Sie das Format dd-MM-yyyy-HH:mm:ss :

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

Die vorangegangenen Datenbankwiederherstellungsbeispiele verwenden --no-recovery-modeebenfalls . Überprüfen Sie diese Einstellung vor dem Absenden.

Wiederherstellen der Datenbank als Datenträger

$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

Datenbankwiederherstellung mit Datenträgern und Protokollen als Dateien

Setzen Sie $pit auf eine gültige UTC-Zeit aus den Datenbanklogbereichen, wie im Beispiel der Datenbank-PITR. Generiere die Datenträgerzuordnungskonfiguration und setze dann das Ziel für die Logdateien:

$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

Nachdem bestätigt wurde, dass die Konfigurationsgenerierung erfolgreich war, bearbeiten Sie die generierten Zuordnungen:

$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

Überprüfen und senden Sie einen Snapshot-Wiederherstellungsvorgang

Für jedes ausgewählte Szenario sollten Sie bestätigen, dass az backup recoveryconfig show erfolgreich ist, bevor Sie die Ausgabe verwenden. Überprüfen Sie die generierten Datei- und Volumenzuordnungen. Nur Quellvolumen, die einen anderen Zielpfad benötigen, neu zuweisen. Ersetzen Sie die Beispiel-Laufwerksbuchstaben durch tatsächliche Pfade:

$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

Die oben beschriebene Neuabbildung ist optional. Bewahren Sie die vorgesehenen Zuordnungen für Ihr ausgewähltes Szenario, einschließlich jeglicher Konfiguration der Datenbank-Daten- und Protokolldateien.

Wenn eine Festplattenabtrennung erforderlich ist, um einen Dateisystemkonflikt zu lösen, fügen Sie der generierten Konfiguration nur explizit genehmigte Festplatten-IDs hinzu:

$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

Das Abkoppeln bestehender Festplatten kann die Workloads am Ziel stören. Überprüfe jede Festplatten-ID und die vollständige Wiederherstellungskonfiguration, bevor du die Wiederherstellung einreichst. Wenden Sie das optionale Disk-Detach-Beispiel nur an, wenn die Operation erforderlich und genehmigt ist.

Reichen Sie nur die Konfigurationsdatei für den gewählten Vorgang ein:

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

Verfolgen Sie den zurückgegebenen Jobnamen mit az backup job show. Für Stop-Protection- und Unregister-Befehle siehe Manage SQL Instance Snapshot Backups.

Nächster Schritt

Verwalten von mit der Azure CLI gesicherten SQL-Datenbanken

Sichern Sie SQL Server-Datenbanken in Azure-VMs mithilfe von Azure Backup über DIE REST-API.
Wiederherstellen von SQL Server-Datenbanken in Azure-VMs mit REST-API.
Verwalten von SQL Server-Datenbanken in Azure-VMs mit Azure-Portal, Azure CLI, REST-API.

Feedback

War diese Seite hilfreich?

Zuletzt aktualisiert um 2026-11-09

Wiederherstellen von SQL-Datenbanken in einer Azure-VM über die Azure CLI

Anzeigen von Wiederherstellungspunkten für eine gesicherte Datenbank

Voraussetzungen für die Wiederherstellung einer Datenbank

Wiederherstellen einer Datenbank

Wiederherstellen an einem alternativen Speicherort

Wiederherstellen und Überschreiben

Wiederherstellung in einer sekundären Region

Wiederherstellen als Dateien

Abonnementübergreifende Wiederherstellung

Wiederherstellen von SQL-Instanz-Snapshots

Snapshot-Wiederherstellungsvariablen einrichten

Abfragemomentaufnahmen-Wiederherstellungspunkte

Abfrage snapshot-basierter Logbereiche

Wiederherstellen des ursprünglichen Instanzspeicherorts

Wiederherstellung der Instanz an einem alternativen Speicherort

Point-in-Time-Wiederherstellung der Instanz

Wiederherstellen der Instanz als Datenträger

Wiederherstellen Sie eine unter einer Instanz geschützte Datenbank

Wiederherstellen der Datenbank über alternative Speicherorte

Point-in-Time-Wiederherstellung der Datenbank

Wiederherstellen der Datenbank als Datenträger

Datenbankwiederherstellung mit Datenträgern und Protokollen als Dateien

Überprüfen und senden Sie einen Snapshot-Wiederherstellungsvorgang

Nächster Schritt

Verwandte Inhalte

Feedback

Zusätzliche Ressourcen