SQL Server-Sicherung über URLs

In diesem Thema werden die Konzepte, Anforderungen und Komponenten vorgestellt, die für die Verwendung des Azure Blob Storage-Diensts als Sicherungsziel erforderlich sind. Die Sicherungs- und Wiederherstellungsfunktion sind gleich oder ähnlich wie beim Verwenden von DISK oder TAPE, mit wenigen Unterschieden. Die Unterschiede und alle wichtigen Ausnahmen sowie einige Codebeispiele werden in diesem Thema erörtert.

Anforderungen, Komponenten und Konzepte

In diesem Abschnitt:

• Security

• Einführung in die wichtigsten Komponenten und Konzepte

• Azure Blob Storage-Dienst

• SQL Server Komponenten

• Einschränkungen

• Unterstützung für Sicherungs-/Wiederherstellungsanweisungen

• Verwenden des Sicherungstasks in SQL Server Management Studio

• SQL Server-Sicherung über URLs mithilfe des Wartungsplanungs-Assistenten

• Wiederherstellen aus Azure Storage mithilfe von SQL Server Management Studio

Sicherheit

Im Folgenden sind Sicherheitsüberlegungen und Anforderungen beim Sichern oder Wiederherstellen von Azure Blob Storage-Diensten aufgeführt.

• Beim Erstellen eines Containers für den Azure Blob Storage-Dienst wird empfohlen, den Zugriff auf privat festzulegen. Dadurch wird der Zugriff auf Benutzer oder Konten beschränkt, die über die erforderlichen Anmeldeinformationen zur Authentifizierung beim Azure-Konto verfügen.

  Wichtig

  SQL Server müssen der Azure-Kontoname und die Zugriffsschlüsselauthentifizierung in einer SQL Server Anmeldeinformationen gespeichert werden. Diese Informationen werden verwendet, um sich beim Azure-Konto zu authentifizieren, wenn Sicherungs- oder Wiederherstellungsvorgänge ausgeführt werden.

• Das zum Ausgeben von BACKUP- oder RESTORE-Befehlen verwendete Benutzerkonto sollte Mitglied der Datenbankrolle db_backup operator sein und über Berechtigungen zum Ändern beliebiger Anmeldeinformationen verfügen.

Einführung in die wichtigsten Komponenten und Konzepte

In den folgenden beiden Abschnitten werden der Azure Blob Storage-Dienst und die SQL Server Komponenten vorgestellt, die beim Sichern oder Wiederherstellen des Azure Blob Storage-Diensts verwendet werden. Es ist wichtig, die Komponenten und die Interaktion zwischen ihnen zu verstehen, um eine Sicherung oder Wiederherstellung aus dem Azure Blob Storage-Dienst durchzuführen.

Das Erstellen eines Azure-Kontos ist der erste Schritt zu diesem Prozess. SQL Server verwendet den Namen des Azure-Speicherkontos und seine Zugriffsschlüsselwerte, um Blobs zu authentifizieren und zu schreiben und in den Speicherdienst zu lesen. Diese Authentifizierungsinformationen werden in den SQL Server-Anmeldeinformationen gespeichert und für Sicherungs- oder Wiederherstellungsvorgänge verwendet. Eine vollständige exemplarische Vorgehensweise zum Erstellen eines Speicherkontos und durchführen einer einfachen Wiederherstellung finden Sie unter Tutorial Using Azure Storage Service for SQL Server Backup and Restore .

Azure Blob Storage-Dienst

Speicherkonto: Das Speicherkonto ist der Ausgangspunkt für alle Speicherdienste. Um auf den Azure Blob Storage-Dienst zuzugreifen, erstellen Sie zuerst ein Azure-Speicherkonto. Der Speicherkontoname und die zugehörigen Zugriffsschlüsseleigenschaften sind erforderlich, um sich beim Azure Blob Storage Dienst und seinen Komponenten zu authentifizieren.

Container: Ein Container stellt eine Gruppierung einer Gruppe von Blobs bereit und kann eine unbegrenzte Anzahl von Blobs speichern. Um eine SQL Server Sicherung in den Azure Blob-Dienst zu schreiben, müssen Sie mindestens den Stammcontainer erstellt haben.

BLOB: Eine Datei eines beliebigen Typs und beliebiger Größe. Es gibt zwei Arten von Blobs, die im Azure Blob Storage-Dienst gespeichert werden können: Block- und Seitenblobs. SQL Server Sicherung verwendet Seitenblobs als Blobtyp. Blobs können mit dem folgenden URL-Format adressiert werden: https://< storage account.blob.core.windows.net/>< container>/<blob>

Weitere Informationen zum Azure Blob Storage-Dienst finden Sie unter Verwenden des Azure Blob Storage-Diensts.

Weitere Informationen über Seitenblobs finden Sie unter Grundlegendes zu Block- und Seitenblobs

SQL Server-Komponenten

URL: Eine URL gibt einen URI (Uniform Resource Identifier) für eine eindeutige Sicherungsdatei an. Mit der URL werden Speicherort und Name der SQL Server -Sicherungsdatei angegeben. In dieser Implementierung ist die einzige gültige URL eine URL, die auf ein Seitenblob in einem Azure-Speicherkonto verweist. Die URL muss auf ein tatsächliches BLOB, nicht nur auf einen Container verweisen. Wenn das BLOB nicht vorhanden ist, wird es erstellt. Wenn ein vorhandenes Blob angegeben wird, schlägt BACKUP fehl, es sei denn, die Option "WITH FORMAT" ist angegeben.

Hier ist ein Beispiel-URL-Wert: http[s]://ACCOUNTNAME.Blob.core.windows.net/< CONTAINER>/<FILENAME.bak>. HTTPS ist zwar nicht erforderlich, aber empfehlenswert.

Anmeldeinformationen: SQL Server-Anmeldeinformationen sind ein Objekt zum Speichern von Authentifizierungsinformationen, die für die Verbindung mit einer Ressource außerhalb von SQL Server erforderlich sind. Hier verwenden SQL Server Sicherungs- und Wiederherstellungsprozesse Anmeldeinformationen, um sich beim Azure Blob Storage-Dienst zu authentifizieren. In den Anmeldeinformationen werden der Name des Speicherkontos und der Zugriffsschlüssel des Speicherkontos gespeichert. Sobald die Anmeldeinformationen erstellt wurden, müssen sie beim Ausgeben der BACKUP-/RESTORE-Anweisungen in der WITH CREDENTIAL-Option angegeben werden. Weitere Informationen zum Anzeigen, Kopieren oder erneuten Generieren von access keysfür Speicherkonten finden Sie unter Zugriffsschlüssel für Speicherkonten.

Eine schrittweise Anleitung zum Erstellen eines SQL Server Anmeldeinformationen finden Sie weiter unten in diesem Thema unter Erstellen eines Anmeldeinformationsbeispiels.

Weitere allgemeine Informationen über Anmeldeinformationen finden Sie unter Anmeldeinformationen.

Weitere Informationen zu anderen Beispielen, in denen Anmeldeinformationen verwendet werden, finden Sie unter Erstellen eines SQL Server-Agent Proxys.

Einschränkungen

• Das Sichern auf Premium-Speicher wird nicht unterstützt.

• Die maximal unterstützte Größe für Sicherungen beträgt 1 TB.

• Sie können BACKUP- und RESTORE-Anweisungen mithilfe von TSQL-, SMO- oder PowerShell-Cmdlets ausgeben. Eine Sicherung oder Wiederherstellung aus dem Azure Blob Storage-Dienst mithilfe SQL Server Management Studio Assistenten zum Sichern oder Wiederherstellen ist derzeit nicht aktiviert.

• Das Erstellen von Namen für logische Geräte wird nicht unterstützt. Folglich ist es nicht möglich, eine URL mithilfe von sp_dumpdevice oder über SQL Server Management Studio als Sicherungsmedium hinzuzufügen.

• Das Anfügen an vorhandene Sicherungs-BLOBs wird nicht unterstützt. Sicherungen auf einem vorhandenen BLOB können nur unter Verwendung der WITH FORMAT-Option überschrieben werden.

• Sicherungen auf mehreren BLOBS in einem einzelnen Sicherungsvorgang werden nicht unterstützt. So gibt der folgende Code z. B. einen Fehler zurück:

  BACKUP DATABASE AdventureWorks2012
  TO URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_1.bak'
     URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_2.bak'
        WITH CREDENTIAL = 'mycredential'
       ,STATS = 5;  
  GO
  

• Das Angeben einer Blockgröße mit BACKUP wird nicht unterstützt.

• Das Angeben von MAXTRANSFERSIZE wird nicht unterstützt.

• Das Angeben von Optionen für Sicherungssätze, wie RETAINDAYS und EXPIREDATE, wird nicht unterstützt.

• SQL Server auf 259 Zeichen begrenzt. Da BACKUP TO URL 36 Zeichen für die erforderlichen Elemente zur Angabe der URL (https://.blob.core.windows.net//.bak ) beansprucht, verbleiben insgesamt noch 223 Zeichen für Konto-, Container- und Blobnamen.

Unterstützung für BACKUP-/RESTORE-Anweisungen

Allgemeine und Syntaxinformationen zu BACKUP-Anweisungen finden Sie unter BACKUP (Transact-SQL).

Allgemeine und Syntaxinformationen zu RESTORE-Anweisungen finden Sie unter RESTORE (Transact-SQL).

Unterstützung für BACKUP-Argumente

Weitere Informationen zu BACKUP-Argumenten finden Sie unter BACKUP (Transact-SQL).

Unterstützung für RESTORE-Argumente

Weitere Informationen zu RESTORE-Argumenten finden Sie unter RESTORE- Argumente (Transact-SQL).

Verwenden des Sicherungstasks in SQL Server Management Studio

Der Sicherungstask in SQL Server Management Studio wurde erweitert, um die URL als eine der Zieloptionen und andere unterstützende Objekte zu enthalten, die für die Sicherung im Azure-Speicher erforderlich sind, z. B. die SQL-Anmeldeinformationen.

In den folgenden Schritten werden die Änderungen beschrieben, die am Task Datenbank sichern vorgenommen wurden, um die Sicherung in Azure Storage zu ermöglichen:

1. Starten Sie SQL Server Management Studio, und stellen Sie eine Verbindung mit der SQL Server-Instanz her. Wählen Sie eine Datenbank aus, die Sie sichern möchten, klicken Sie mit der rechten Maustaste auf Aufgaben, und wählen Sie Sichern aus. Dadurch wird das Dialogfeld Datenbank sichern geöffnet.

2. Auf der Allgemeinen Seite wird die URL-Option verwendet, um eine Sicherung in Azure Storage zu erstellen. Wenn Sie diese Option auswählen, werden weitere Optionen auf dieser Seite aktiviert:

   1. Dateiname: Name der Sicherungsdatei.

   2. SQL-Anmeldeinformationen: Sie können entweder vorhandene SQL Server-Anmeldeinformationen angeben oder neue erstellen, indem Sie neben dem Feld für die SQL-Anmeldeinformationen auf Erstellen klicken.

      Wichtig

      Das Dialogfeld, das beim Klicken auf Erstellen geöffnet wird, erfordert ein Verwaltungszertifikat oder das Veröffentlichungsprofil für das Abonnement. SQL Server unterstützt derzeit die Version 2.0 des Veröffentlichungsprofils. Weitere Informationen zum Herunterladen der unterstützten Version des Veröffentlichungsprofils finden Sie unter Herunterladen des Veröffentlichungsprofils 2.0.

      Wenn Sie keinen Zugriff auf das Verwaltungszertifikat oder Veröffentlichungsprofil haben, können Sie SQL-Anmeldeinformationen erstellen, indem Sie den Namen des Speicherkontos und die Informationen zum Zugriffsschlüssel mithilfe von Transact-SQL oder SQL Server Management Studio angeben. Der Beispielcode im Abschnitt Erstellen von Anmeldeinformationen veranschaulicht das Erstellen von Anmeldeinformationen mithilfe von Transact-SQL. Alternativ können Sie auf der Datenbank-Engine-Instanz in SQL Server Management Studio mit der rechten Maustaste auf Sicherheitklicken und Neusowie Anmeldeinformationenauswählen. Geben Sie im Feld Identität den Namen des Speicherkontos und im Feld Kennwort den Zugriffsschlüssel an.

   3. Azure-Speichercontainer: Der Name des Azure-Speichercontainers zum Speichern der Sicherungsdateien.

   4. URL-Präfix: Dieses wird automatisch mit den Informationen erstellt, die in den Feldern angegeben werden, die in den vorherigen Schritten beschrieben wurden. Wenn Sie diesen Wert manuell bearbeiten, stellen Sie sicher, dass er mit den anderen Informationen übereinstimmt, die Sie zuvor bereitgestellt haben. Wenn Sie beispielsweise die Speicher-URL ändern, sollten Sie sicherstellen, dass die SQL-Anmeldeinformationen für die Authentifizierung beim gleichen Speicherkonto festgelegt wurden.

Wenn Sie eine URL als Ziel auswählen, sind bestimmte Optionen auf der Seite Medienoptionen deaktiviert. Die folgenden Themen enthalten weitere Informationen zum Dialogfeld Datenbank sichern:

Datenbank sichern (Seite Allgemein)

Datenbank sichern (Seite 'Medienoptionen')

Datenbank sichern (Seite 'Sicherungsoptionen')

Erstellen von Anmeldeinformationen – Authentifizieren beim Azure-Speicher

SQL Server-Sicherung über URLs mithilfe des Wartungsplanungs-Assistenten

Ähnlich wie der zuvor beschriebene Sicherungstask wurde der Wartungsplan-Assistent in SQL Server Management Studio erweitert, um die URL als eine der Zieloptionen und andere unterstützende Objekte, die für die Sicherung im Azure-Speicher erforderlich sind, wie die SQL-Anmeldeinformationen, einzubeziehen. Weitere Informationen finden Sie im Abschnitt Definieren von Sicherungsaufgaben im Assistenten für Wartungspläne.

Wiederherstellen aus Azure Storage mithilfe von SQL Server Management Studio

Wenn Sie eine Datenbank wiederherstellen, wird URL als Gerät für die Wiederherstellung eingeschlossen. In den folgenden Schritten werden die Änderungen im Wiederherstellungstask beschrieben, um die Wiederherstellung aus Azure Storage zu ermöglichen:

1. Wenn Sie in SQL Server Management Studio auf der Seite Allgemein des Wiederherstellungstasks die Option Geräte auswählen, wird das Dialogfeld Sicherungsmedien auswählen geöffnet, das URL als Sicherungsmediumtyp enthält.

2. Wenn Sie URL auswählen und auf Hinzufügenklicken, wird das Dialogfeld Mit Azure-Speicher verbinden geöffnet. Geben Sie die SQL-Anmeldeinformationen an, die bei Azure Storage authentifiziert werden sollen.

3. SQL Server dann mithilfe der von Ihnen bereitgestellten SQL-Anmeldeinformationen eine Verbindung mit Azure Storage herstellen und das Dialogfeld Sicherungsdatei in Azure suchen öffnen. Die Sicherungsdateien, die sich im Arbeitsspeicher befinden, werden auf dieser Seite angezeigt. Wählen Sie die Datei aus, die Sie zum Wiederherstellen verwenden möchten, und klicken Sie auf OK. Dadurch gelangen Sie zurück zum Dialogfeld Sicherungsgeräte auswählen, und wenn Sie in diesem Dialogfeld auf OK klicken, gelangen Sie zurück zum Dialogfeld Standard Wiederherstellung, in dem Sie die Wiederherstellung abschließen können. Weitere Informationen finden Sie in den folgenden Themen:

   Datenbank wiederherstellen (Seite „Allgemein“)

   Datenbank wiederherstellen (Seite Dateien)

   Datenbank wiederherstellen (Seite Optionen)

Codebeispiele

Dieser Abschnitt enthält die folgenden Beispiele.

• Erstellen von Anmeldeinformationen

• Sichern einer vollständigen Datenbank

• Sichern der Datenbank und des Protokolls

• Erstellen einer vollständigen Dateisicherung der primären Dateigruppe

• Erstellen einer differenziellen Dateisicherung der primären Dateigruppen

• Wiederherstellen einer Datenbank und Verschieben von Dateien

• Wiederherstellen eines bestimmten Zeitpunkts mithilfe von STOPAT

Create a Credential

Im folgenden Beispiel werden Anmeldeinformationen erstellt, in denen die Azure Storage-Authentifizierungsinformationen gespeichert werden.

IF NOT EXISTS  
(SELECT * FROM sys.credentials   
WHERE credential_identity = 'mycredential')  
CREATE CREDENTIAL mycredential WITH IDENTITY = 'mystorageaccount'  
,SECRET = '<storage access key>' ;  

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  
string secret = "<storage access key>";  

// Create a Credential  
string credentialName = "mycredential";  
Credential credential = new Credential(server, credentialName);  
credential.Create(identity, secret);  

# create variables  
$storageAccount = "mystorageaccount"  
$storageKey = "<storage access key>"  
$secureString = ConvertTo-SecureString $storageKey  -asplaintext -force  
$credentialName = "mycredential"  

$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# Create a credential  
New-SqlCredential -Name $credentialName -Path $srvpath -Identity $storageAccount -Secret $secureString

Sichern einer vollständigen Datenbank

Im folgenden Beispiel wird die AdventureWorks2012-Datenbank im Azure Blob Storage-Dienst gesichert.

BACKUP DATABASE AdventureWorks2012   
TO URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012.bak'   
      WITH CREDENTIAL = 'mycredential'   
      ,COMPRESSION  
      ,STATS = 5;  
GO

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string url = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.CompressionOption = BackupCompressionOptions.On;  
backup.Devices.AddDevice(url, DeviceType.Url);  
backup.SqlBackup(server);  

# create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"   
# for default instance, the $srvpath varilable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to SQL Server Instance  
CD $srvPath   
$backupFile = $backupUrlContainer + "AdventureWorks2012" +  ".bak"  
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On

Sichern der Datenbank und des Protokolls

Im folgenden Beispiel wird die AdventureWorks2012-Beispieldatenbank gesichert, in der standardmäßig das einfache Wiederherstellungsmodell verwendet wird. Zur Unterstützung von Protokollsicherungen wird die AdventureWorks2012-Datenbank geändert, sodass sie das vollständige Wiederherstellungsmodell verwendet. Im Beispiel wird dann eine vollständige Datenbanksicherung in Azure Blob erstellt, und nach einer Zeit der Aktualisierungsaktivität wird das Protokoll gesichert. In diesem Beispiel wird für eine Sicherungsdatei ein Name mit einem Datums-/Zeitstempel erstellt.

-- To permit log backups, before the full database backup, modify the database   
-- to use the full recovery model.  
USE master;  
GO  
ALTER DATABASE AdventureWorks2012  
   SET RECOVERY FULL;  
GO  

-- Back up the full AdventureWorks2012 database.  
       -- First create a file name for the backup file with DateTime stamp  

DECLARE @Full_Filename AS VARCHAR (300);  
SET @Full_Filename = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_Full_'+   
REPLACE (REPLACE (REPLACE (CONVERT (VARCHAR (40), GETDATE (), 120), '-','_'),':', '_'),' ', '_') + '.bak';   
--Back up Adventureworks2012 database  

BACKUP DATABASE AdventureWorks2012  
TO URL =  @Full_Filename  
WITH CREDENTIAL = 'mycredential';  
,COMPRESSION  
GO  
-- Back up the AdventureWorks2012 log.  
DECLARE @Log_Filename AS VARCHAR (300);  
SET @Log_Filename = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_Log_'+   
REPLACE (REPLACE (REPLACE (CONVERT (VARCHAR (40), GETDATE (), 120), '-','_'),':', '_'),' ', '_') + '.trn';  
BACKUP LOG AdventureWorks2012  
 TO URL = @Log_Filename  
 WITH CREDENTIAL = 'mycredential'  
 ,COMPRESSION;  
GO  

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url for data backup  
string urlDataBackup = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}_Data-{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup Database to Url  
Backup backupData = new Backup();  
backupData.CredentialName = credentialName;  
backupData.Database = dbName;  
backup.CompressionOption = BackupCompressionOptions.On;  
backupData.Devices.AddDevice(urlDataBackup, DeviceType.Url);  
backupData.SqlBackup(server);  

// Generate Unique Url for data backup  
string urlLogBackup = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}_Log-{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup Database Log to Url  
Backup backupLog = new Backup();  
backupLog.CredentialName = credentialName;  
backupLog.Database = dbName;  
backup.CompressionOption = BackupCompressionOptions.On;  
backupLog.Devices.AddDevice(urlLogBackup, DeviceType.Url);  
backupLog.Action = BackupActionType.Log;  
backupLog.SqlBackup(server);  

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to theSQL Server Instance
CD $srvPath   
#Create a unique file name for the full database backup  
$backupFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bak"  

#Backup Database to URL
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On -BackupAction Database    

#Create a unique file name for log backup  

$backupFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".trn"  

#Backup Log to URL
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On -BackupAction Log

Erstellen einer vollständigen Dateisicherung der primären Dateigruppe

Im folgenden Beispiel wird eine vollständige Dateisicherung der primären Dateigruppe erstellt.

--Back up the files in Primary:  
BACKUP DATABASE AdventureWorks2012  
    FILEGROUP = 'Primary'  
    TO URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012files.bck'  
    WITH CREDENTIAL = 'mycredential'  
    ,COMPRESSION;  
GO  

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string url = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-{3}.bck",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.Action = BackupActionType.Files;  
backup.DatabaseFileGroups.Add("PRIMARY");  
backup.CompressionOption = BackupCompressionOptions.On;  
backup.Devices.AddDevice(url, DeviceType.Url);  
backup.SqlBackup(server);

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to the SQL Server Instance  

CD $srvPath   
#Create a unique file name for the file backup  
$backupFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bck"  

#Backup Primary File Group to URL  

Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On -BackupAction Files -DatabaseFileGroup Primary

Erstellen einer differenziellen Dateisicherung der primären Dateigruppe

Im folgenden Beispiel wird eine differenzielle Dateisicherung der primären Dateigruppe erstellt.

--Back up the files in Primary:  
BACKUP DATABASE AdventureWorks2012  
    FILEGROUP = 'Primary'  
    TO URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012filesdiff.bck'  
    WITH   
       CREDENTIAL = 'mycredential'  
       ,COMPRESSION  
   ,DIFFERENTIAL;  
GO

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string url = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.Action = BackupActionType.Files;  
backup.DatabaseFileGroups.Add("PRIMARY");  
backup.Incremental = true;  
backup.CompressionOption = BackupCompressionOptions.On;  
backup.Devices.AddDevice(url, DeviceType.Url);  
backup.SqlBackup(server); 

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to SQL Server Instance
CD $srvPath   

#create a unique file name for the full backup  
$backupdbFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bak"  

#Create a differential backup of the primary filegroup
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On -BackupAction Files -DatabaseFileGroup Primary -Incremental

Wiederherstellen einer Datenbank und Verschieben von Dateien

Zum Wiederherstellen einer vollständigen Datenbanksicherung und Verschieben der wiederhergestellten Datenbank in das Verzeichnis C:\Programme\Microsoft SQL Server\MSSQL12.MSSQLSERVER\MSSQL\Data führen Sie die folgenden Schritte aus.

-- Backup the tail of the log first
DECLARE @Log_Filename AS VARCHAR (300);  
SET @Log_Filename = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_Log_'+   
REPLACE (REPLACE (REPLACE (CONVERT (VARCHAR (40), GETDATE (), 120), '-','_'),':', '_'),' ', '_') + '.trn';  
BACKUP LOG AdventureWorks2012  
 TO URL = @Log_Filename  
 WITH CREDENTIAL = 'mycredential'  
 ,NORECOVERY;  
GO  

RESTORE DATABASE AdventureWorks2012 FROM URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012.bak'  
WITH CREDENTIAL = 'mycredential'  
 ,MOVE 'AdventureWorks2012_data' to 'C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.mdf'  
 ,MOVE 'AdventureWorks2012_log' to 'C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.ldf'  
 ,STATS = 5

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string urlBackupData = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-Data{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.Devices.AddDevice(urlBackupData, DeviceType.Url);  
backup.SqlBackup(server);  

// Generate Unique Url for tail log backup  
string urlTailLogBackup = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-TailLog{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup Tail Log to Url  
Backup backupTailLog = new Backup();  
backupTailLog.CredentialName = credentialName;  
backupTailLog.Database = dbName;  
backupTailLog.Action = BackupActionType.Log;  
backupTailLog.NoRecovery = true;  
backupTailLog.Devices.AddDevice(urlTailLogBackup, DeviceType.Url);  
backupTailLog.SqlBackup(server);  

// Restore a database and move files  
string newDataFilePath = server.MasterDBLogPath  + @"\" + dbName + DateTime.Now.ToString("s").Replace(":", "-") + ".mdf";  
string newLogFilePath = server.MasterDBLogPath  + @"\" + dbName + DateTime.Now.ToString("s").Replace(":", "-") + ".ldf";  

Restore restore = new Restore();  
restore.CredentialName = credentialName;  
restore.Database = dbName;  
restore.ReplaceDatabase = true;  
restore.Devices.AddDevice(urlBackupData, DeviceType.Url);  
restore.RelocateFiles.Add(new RelocateFile(dbName, newDataFilePath));  
restore.RelocateFiles.Add(new RelocateFile(dbName+ "_Log", newLogFilePath));  
restore.SqlRestore(server);

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTNACENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to SQL Server Instance
CD $srvPath   

#create a unique file name for the full backup  
$backupdbFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bak"  

# Full database backup to URL  
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupdbFile  -SqlCredential $credentialName -CompressionOption On      

#Create a unique file name for the tail log backup  
$backuplogFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".trn"  

#Backup tail log to URL
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName  -BackupAction Log -NoRecovery    

# Restore Database and move files
$newDataFilePath = New-Object Microsoft.SqlServer.Management.Smo.RelocateFile ("AdventureWorks_Data","C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.mdf")  
$newLogFilePath = New-Object Microsoft.SqlServer.Management.Smo.RelocateFile("AdventureWorks_Log","C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.ldf")  

Restore-SqlDatabase -Database AdventureWorks2012 -SqlCredential $credentialName -BackupFile $backupdbFile -RelocateFile @($newDataFilePath,$newLogFilePath)

Wiederherstellen eines bestimmten Zeitpunkts mithilfe von STOPAT

Im folgenden Beispiel wird der Zustand einer Datenbank zu einem bestimmten Zeitpunkt wiederhergestellt und ein Wiederherstellungsvorgang veranschaulicht.

RESTORE DATABASE AdventureWorks FROM URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012.bak'   
WITH   
  CREDENTIAL = 'mycredential'  
 ,MOVE 'AdventureWorks2012_data' to 'C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.mdf'  
 ,Move 'AdventureWorks2012_log' to 'C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.ldf'  
 ,NORECOVERY  
 --,REPLACE  
 ,STATS = 5;  
GO   

RESTORE LOG AdventureWorks FROM URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012.trn'   
WITH CREDENTIAL = 'mycredential'  
 ,RECOVERY   
 ,STOPAT = 'Oct 23, 2012 5:00 PM'   
GO  

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string urlBackupData = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-Data{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.Devices.AddDevice(urlBackupData, DeviceType.Url);  
backup.SqlBackup(server);  

// Generate Unique Url for Tail Log backup  
string urlTailLogBackup = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-TailLog{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup Tail Log to Url  
Backup backupTailLog = new Backup();  
backupTailLog.CredentialName = credentialName;  
backupTailLog.Database = dbName;  
backupTailLog.Action = BackupActionType.Log;  
backupTailLog.NoRecovery = true;  
backupTailLog.Devices.AddDevice(urlTailLogBackup, DeviceType.Url);  
backupTailLog.SqlBackup(server);  

// Restore a database and move files  
string newDataFilePath = server.MasterDBLogPath + @"\" + dbName + DateTime.Now.ToString("s").Replace(":", "-") + ".mdf";  
string newLogFilePath = server.MasterDBLogPath + @"\" + dbName + DateTime.Now.ToString("s").Replace(":", "-") + ".ldf";  

Restore restore = new Restore();  
restore.CredentialName = credentialName;  
restore.Database = dbName;  
restore.ReplaceDatabase = true;  
restore.NoRecovery = true;  
restore.Devices.AddDevice(urlBackupData, DeviceType.Url);  
restore.RelocateFiles.Add(new RelocateFile(dbName, newDataFilePath));  
restore.RelocateFiles.Add(new RelocateFile(dbName + "_Log", newLogFilePath));  
restore.SqlRestore(server);  
   
// Restore transaction Log with stop at   
Restore restoreLog = new Restore();  
restoreLog.CredentialName = credentialName;  
restoreLog.Database = dbName;  
restoreLog.Action = RestoreActionType.Log;  
restoreLog.Devices.AddDevice(urlBackupData, DeviceType.Url);  
restoreLog.ToPointInTime = DateTime.Now.ToString();   
restoreLog.SqlRestore(server);

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# Navigate to SQL Server Instance Directory
CD $srvPath   

#create a unique file name for the full backup  
$backupdbFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bak"  

# Full database backup to URL  
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupdbFile  -SqlCredential $credentialName -CompressionOption On     

#Create a unique file name for the tail log backup  
$backuplogFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".trn"  

#Backup tail log to URL
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName  -BackupAction Log -NoRecovery     

# Restore Database and move files
$newDataFilePath = New-Object Microsoft.SqlServer.Management.Smo.RelocateFile ("AdventureWorks_Data","C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.mdf")  
$newLogFilePath = New-Object Microsoft.SqlServer.Management.Smo.RelocateFile("AdventureWorks_Log","C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.ldf")  

Restore-SqlDatabase -Database AdventureWorks2012 -SqlCredential $credentialName -BackupFile $backupdbFile -RelocateFile @($newDataFilePath,$newLogFilePath) -NoRecovery    

# Restore Transaction log with Stop At:  
Restore-SqlDatabase -Database AdventureWorks2012 -SqlCredential $credentialName -BackupFile $backuplogFile  -ToPointInTime (Get-Date).ToString()

Siehe auch

SQL Server-Sicherung über URLs – bewährte Methoden und Problembehandlung
Sichern und Wiederherstellen von Systemdatenbanken (SQL Server)