SQL Server-Sicherung auf URL

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 Wiederherstellungsfunktionen sind bei Verwendung von DISK oder TAPE mit einigen Unterschieden identisch oder ähnlich. Die Unterschiede sowie alle wichtigen Ausnahmen und einige Codebeispiele sind in diesem Thema enthalten.

Anforderungen, Komponenten und Konzepte

In diesem Abschnitt:

Sicherheit

Im Folgenden finden Sie Sicherheitsüberlegungen und Anforderungen beim Sichern oder Wiederherstellen von Azure Blob Storage-Diensten.

Beim Erstellen eines Containers für den Azure Blob Storage-Dienst wird empfohlen, den Zugriff auf "Privat" festzulegen. Das Festlegen des Zugriffs auf "Privat" schränkt den Zugriff auf Benutzer oder Konten ein, die die erforderlichen Informationen für die Authentifizierung beim Azure-Konto bereitstellen können.

Von Bedeutung

SQL Server erfordert, dass der Azure-Kontoname und der Zugriffsschlüssel zur Authentifizierung in einem SQL Server-Anmeldedatensatz gespeichert werden. Diese Informationen werden verwendet, um sich beim Azure-Konto zu authentifizieren, wenn sie Sicherungs- oder Wiederherstellungsvorgänge ausführt.
Das Benutzerkonto, das zum Ausgeben von Sicherungs- oder Wiederherstellungsbefehlen verwendet wird, sollte sich in der Datenbankrolle db_backup operator befinden, mit den Berechtigungen Anmeldeinformationen ändern.

Einführung in wichtige Komponenten und Konzepte

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

Das Erstellen eines Azure-Kontos ist der erste Schritt zu diesem Prozess. SQL Server verwendet den Namen des Azure-Speicherkontos und seine Zugriffsschlüsselwerte zum Authentifizieren und Schreiben und Lesen von Blobs in den Speicherdienst. 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 zum Ausführen einer einfachen Wiederherstellung finden Sie im Lernprogramm "Verwenden des Azure Storage Service für SQL Server Backup and Restore".

Zuordnung eines Speicherkontos zu SQL-Anmeldeinformationen

Azure Blob Storage Service

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 Name des Speicherkontos und seine 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 einer beliebigen Größe. Es gibt zwei Arten von Blobs, die im Azure Blob Storage-Dienst gespeichert werden können: Block- und Seiten-Blobs. Die SQL Server-Sicherung verwendet Seitenblobs als Blob-Typ. Blobs können mithilfe des folgenden URL-Formats adressiert werden: https://< storage account.blob.core.windows.net/>< container>/<blob>

Azure Blob Storage

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. Die URL wird verwendet, um den Speicherort und den Namen der SQL Server-Sicherungsdatei anzugeben. In dieser Implementierung ist die einzige gültige URL eine, die auf ein Seiten-BLOB in einem Azure-Speicherkonto verweist. Die URL muss auf einen tatsächlichen Blob verweisen, nicht nur auf einen Container. Wenn das Blob nicht vorhanden ist, wird es erstellt. Wenn ein vorhandenes Blob angegeben ist, schlägt BACKUP fehl, es sei denn, die Option "WITH FORMAT" ist angegeben.

Warnung

Wenn Sie eine Sicherungsdatei in den Azure Blob Storage-Dienst kopieren und hochladen möchten, verwenden Sie den Seitenblob als Speicheroption. Wiederherstellungen von Blockblobs werden nicht unterstützt. Die Ausführung von RESTORE für ein Blockblob verursacht einen Fehler.

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

Berechtigungsnachweis: Eine SQL Server-Anmeldeinformation ist ein Objekt, das zum Speichern von Authentifizierungsinformationen verwendet wird, die zum Herstellen einer 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. Die Anmeldeinformationen speichern den Namen des Speicherkontos und die Schlüsselwerte für den Zugriff auf das Speicherkonto. Nachdem die Anmeldeinformationen erstellt wurden, muss sie beim Ausgeben der BACKUP/RESTORE-Anweisungen in der OPTION WITH CREDENTIAL angegeben werden. Weitere Informationen zum Anzeigen, Kopieren oder Generieren von Zugriffstasten für Speicherkonten finden Sie unter Zugriffstasten für Speicherkonten.

Schritt-für-Schritt-Anleitungen zum Erstellen einer SQL Server-Anmeldeinformation finden Sie weiter unten in diesem Thema unter Erstellen einer Anmeldeinformation.

Allgemeine Informationen zu 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

Die Sicherung auf Premiumspeicher wird nicht unterstützt.
Die maximal unterstützte Sicherungsgröße beträgt 1 TB.
Sie können Sicherungs- oder Wiederherstellungsanweisungen mithilfe von TSQL-, SMO- oder PowerShell-Cmdlets ausstellen. Eine Sicherung des Azure Blob Storage-Diensts mithilfe des SQL Server Management Studio-Sicherungs- oder Wiederherstellungs-Assistenten ist derzeit nicht aktiviert.
Das Erstellen eines logischen Gerätenamens wird nicht unterstützt. Das Hinzufügen von URL als Sicherungsgerät mit sp_dumpdevice oder über SQL Server Management Studio wird daher nicht unterstützt.
Das Anhängen an bestehende Sicherungsblobs wird nicht unterstützt. Sicherungen in einem vorhandenen Blob können nur mithilfe der WITH FORMAT-Option überschrieben werden.

Die Sicherung auf mehrere Blobs in einem einzigen Sicherungsvorgang wird nicht unterstützt. So wird beispielsweise ein Fehler zurückgegeben:

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.
Die Angabe MAXTRANSFERSIZE wird nicht unterstützt.
Angeben von Backupset-Optionen – RETAINDAYS und EXPIREDATE werden 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 Sicherungs-/Wiederherstellungsanweisungen


Backup/Restore-Anweisung	Unterstützt	Ausnahmen	Kommentare
SICHERUNGSKOPIE	✓	BLOCKSIZE und MAXTRANSFERSIZE werden nicht unterstützt.	Erfordert die Angabe von ANMELDEINFORMATIONEN
WIEDERHERSTELLEN	✓		Erfordert, dass ANMELDEINFORMATIONEN angegeben werden
FILELISTONLY WIEDERHERSTELLEN	✓		Erfordert MIT ANMELDEINFORMATIONEN angegeben
HEADERONLY WIEDERHERSTELLEN	✓		Erfordert, dass Anmeldeinformationen angegeben werden
LABELONLY WIEDERHERSTELLEN	✓		Erfordert die Angabe von Anmeldedaten
VERIFYONLY WIEDERHERSTELLEN	✓		Erfordert MIT ANGABE DER ANMELDEINFORMATIONEN
RÜCKSPULEN WIEDERHERSTELLEN	✓

Syntax und allgemeine Informationen zu Sicherungsanweisungen finden Sie unter BACKUP (Transact-SQL).

Syntax und allgemeine Informationen zu Wiederherstellungsanweisungen finden Sie unter RESTORE (Transact-SQL).

Unterstützung für Sicherungsargumente


Streitpunkt	Unterstützt	Ausnahme	Kommentare
DATENBANK	✓
Logdatei	✓

ZU (URL)	✓	Im Gegensatz zu DISK und TAPE unterstützt DIE URL das Angeben oder Erstellen eines logischen Namens nicht.	Dieses Argument wird verwendet, um den URL-Pfad für die Sicherungsdatei anzugeben.
SPIEGELN AUF	✓
MIT OPTIONEN:
BERECHTIGUNGSNACHWEIS	✓		MIT ANMELDEINFORMATIONEN wird nur bei Verwendung der BACKUP-TO-URL-Option unterstützt, um ein Backup zum Azure Blob Storage-Dienst zu erstellen.
Differential	✓
Nur kopieren	✓
KOMPRIMIERUNG\|KEINE_KOMPRIMIERUNG	✓
BESCHREIBUNG	✓
NAME	✓
ABLAUFDATUM \| AUFBEWAHRUNGSTAGE	✓
NOINIT \| INIT	✓		Diese Option wird bei Verwendung ignoriert. Das Anfügen an Blobs ist nicht möglich. Verwenden Sie das FORMAT-Argument, um eine Sicherung zu überschreiben.
NOSKIP \| HÜPFEN	✓
NOFORMAT \| FORMAT	✓		Diese Option wird bei Verwendung ignoriert. Eine Sicherung, die in einem vorhandenen Blob erstellt wurde, schlägt fehl, es sei denn, WITH FORMAT ist angegeben. Das vorhandene Blob wird überschrieben, wenn WITH FORMAT angegeben wird.
MEDIENBESCHREIBUNG	✓
MEDIANAME	✓
Blockgröße	✓
BUFFERCOUNT	✓
MAXTRANSFERSIZE	✓
NO_CHECKSUM \| PRÜFSUMME	✓
BEI_FEHLER_STOPPEN \| WEITERMACHEN_NACH_FEHLER	✓
STATISTIKEN	✓
RÜCKSPULEN \| NOREWIND	✓
ENTLADEN \| NICHT ENTLADEN	✓
NORECOVERY \| BEREITSCHAFT	✓
NO_TRUNCATE	✓

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

Unterstützung für Wiederherstellungsargumente


Streitpunkt	Unterstützt	Ausnahmen	Kommentare
DATENBANK	✓
Protokoll	✓
VON (URL)	✓		Das FROM-URL-Argument wird verwendet, um den URL-Pfad für die Sicherungsdatei anzugeben.
WITH-Optionen:
BERECHTIGUNGSNACHWEIS	✓		MIT ANMELDEINFORMATIONEN wird nur unterstützt, wenn Sie die Option RESTORE FROM URL verwenden, um von Azure Blob Storage-Dienst wiederherzustellen.
TEILWEISE	✓
WIEDERHERSTELLUNG \| KEINE WIEDERHERSTELLUNG \| BEREITSCHAFT	✓
Ladeverlauf	✓
Verschieben	✓
ERSETZEN	✓
NEUSTARTEN	✓
EINGESCHRÄNKTER_NUTZER	✓
DATEI	✓
KENNWORT	✓
MEDIANAME	✓
MEDIAPASSWORD	✓
Blockgröße	✓
BUFFERCOUNT	✓
MAXTRANSFERSIZE	✓
PRÜFSUMME \| KEINE PRÜFSUMME	✓
BEI_FEHLER_STOPPEN \| NACH_FEHLER_FORTFAHREN	✓
FILESTREAM	✓
STATISTIKEN	✓
RÜCKSPULEn \| NOREWIND	✓
ENTLADEN \| NICHT ENTLADEN	✓
REPLIKATION_BEIBEHALTEN	✓
KEEP_CDC	✓
ENABLE_BROKER \| ERROR_BROKER_CONVERSATIONS \| NEW_BROKER	✓
STOPAT \| STOPATMARK \| STOPBEFOREMARK	✓

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

Verwenden der Sicherungsaufgabe in SQL Server Management Studio

Die Sicherungsaufgabe in SQL Server Management Studio wurde erweitert, um die URL als eine der Zieloptionen und andere unterstützende Objekte einzuschließen, die zum Sichern auf Azure-Speicher wie die SQL-Anmeldeinformationen erforderlich sind.

In den folgenden Schritten werden die Änderungen beschrieben, die an der Aufgabe "Datenbank sichern" vorgenommen wurden, um die Sicherung in Azure Storage zu ermöglichen.

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, und klicken Sie mit der rechten Maustaste auf "Aufgaben", und wählen Sie " Sichern". Dadurch wird das Dialogfeld "Datenbank sichern" geöffnet.
Auf der allgemeinen Seite wird die URL-Option verwendet, um eine Sicherung für Azure Storage zu erstellen. Wenn Sie diese Option auswählen, werden auf dieser Seite weitere Optionen aktiviert:
1. Dateiname: Name der Sicherungsdatei.
2. SQL-Anmeldeinformationen: Sie können entweder eine vorhandene SQL Server-Anmeldeinformation angeben oder eine neue erstellen, indem Sie auf das Feld " Erstellen " neben dem Feld "SQL-Anmeldeinformationen" klicken.
  
  Von Bedeutung
  
  Das Dialogfeld, das geöffnet wird, wenn Sie auf "Erstellen" klicken, erfordert ein Verwaltungszertifikat oder das Veröffentlichungsprofil für das Abonnement. SQL Server unterstützt derzeit die Veröffentlichungsprofilversion 2.0. Informationen zum Herunterladen der unterstützten Version des Veröffentlichungsprofils finden Sie unter Download Publishing Profile 2.0.
  
  Wenn Sie keinen Zugriff auf das Verwaltungszertifikat oder das Veröffentlichungsprofil haben, können Sie eine SQL-Anmeldeinformation erstellen, indem Sie den Namen des Speicherkontos und die Zugriffstasteninformationen mithilfe von Transact-SQL oder SQL Server Management Studio angeben. Sehen Sie sich den Beispielcode im Abschnitt " Erstellen einer Anmeldeinformation " an, um mithilfe von Transact-SQL eine Anmeldeinformation zu erstellen. Alternativ können Sie in SQL Server Management Studio in der Datenbank-Engine-Instanz mit der rechten Maustaste auf Sicherheit klicken, Neu auswählen und Anmeldung auswählen. Geben Sie den Namen des Speicherkontos für Identität und den Zugriffsschlüssel im Feld "Kennwort " an.
3. Azure-Speichercontainer: Der Name des Azure-Speichercontainers zum Speichern der Sicherungsdateien.
4. URL-Präfix: Dies wird automatisch mithilfe der informationen erstellt, die in den in den vorherigen Schritten beschriebenen Feldern angegeben sind. Wenn Sie diesen Wert manuell bearbeiten, stellen Sie sicher, dass er mit den anderen Informationen übereinstimmt, die Sie zuvor angegeben haben. Wenn Sie beispielsweise die Speicher-URL ändern, stellen Sie sicher, dass die SQL-Anmeldeinformationen für die Authentifizierung beimselben Speicherkonto festgelegt sind.

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

Datenbank sichern (Allgemeine Seite)

Datenbank sichern (Seite "Medienoptionen")

Datenbank sichern (Seite "Sicherungsoptionen")

Erstellen von Anmeldeinformationen – Authentifizieren bei Azure Storage

SQL Server-Sicherung auf URL mit dem Wartungsplan-Assistenten

Ähnlich wie die zuvor beschriebene Sicherungsaufgabe wurde der Wartungsplan-Assistent in SQL Server Management Studio erweitert, um die URL als eine der Zieloptionen und andere unterstützende Objekte einzuschließen, die zum Sichern in Azure Storage wie die SQL-Anmeldeinformationen erforderlich sind. Weitere Informationen finden Sie im Abschnitt Sicherungsaufgaben definieren des Assistenten für Wartungspläne.

Wiederherstellen von Azure-Speicher mit SQL Server Management Studio

Wenn Sie eine Datenbank wiederherstellen, wird die URL als Gerät für die Wiederherstellung einbezogen. In den folgenden Schritten werden die Änderungen der Wiederherstellungsaufgabe beschrieben, um das Wiederherstellen von Azure Storage zu ermöglichen:

Wenn Sie " Geräte" auf der Seite "Allgemein " der Aufgabe "Wiederherstellen" in SQL Server Management Studio auswählen, gelangen Sie zum Dialogfeld " Sicherungsgeräte auswählen ", das die URL als Sicherungsmedientyp enthält.
Wenn Sie die URL auswählen und auf "Hinzufügen" klicken, wird das Dialogfeld "Mit Azure-Speicher verbinden " geöffnet. Geben Sie die SQL-Anmeldeinformationen an, die bei Azure Storage authentifiziert werden sollen.
SQL Server stellt dann mithilfe der von Ihnen bereitgestellten SQL-Anmeldeinformationen eine Verbindung mit Azure Storage her und öffnet das Dialogfeld "Sicherungsdatei im Azure-Speicher". Die Sicherungsdateien, die sich im Speicher 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 Hauptdialogfeld " Wiederherstellen ", 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 einer Anmeldeinformation
Komplettsicherung einer vollständigen Datenbank
Sichern der Datenbank und der Logdatei
Erstellen einer vollständigen Dateisicherung der primären Dateigruppe
Erstellen einer differenziellen Dateisicherung der primären Dateigruppen
Wiederherstellen einer Datenbank und Verschieben von Dateien
Wiederherstellung zu einem bestimmten Zeitpunkt mithilfe von STOPAT

Zugangsdaten erstellen

Im folgenden Beispiel wird eine Anmeldeinformation erstellt, die die Azure Storage-Authentifizierungsinformationen speichert.

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 der Logdatei

Im folgenden Beispiel wird die AdventureWorks2012-Beispieldatenbank gesichert, die standardmäßig das einfache Wiederherstellungsmodell verwendet. Zur Unterstützung von Protokollsicherungen wird die AdventureWorks2012-Datenbank so geändert, dass das vollständige Wiederherstellungsmodell verwendet wird. Das Beispiel erstellt dann eine vollständige Datenbanksicherung auf Azure Blob und sichert nach einer Phase von Aktualisierungsaktivitäten das Protokoll. In diesem Beispiel wird ein Sicherungsdateiname mit einem Datumsstempel 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

Um eine vollständige Datenbanksicherung wiederherzustellen und die wiederhergestellte Datenbank in C:\Programme\Microsoft SQL Server\MSSQL12 zu verschieben. Verwenden Sie die folgenden Schritte: MSSQLSERVER\MSSQL\Data directory.

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

Wiederherstellung zu einem bestimmten Zeitpunkt mithilfe von STOPAT

Im folgenden Beispiel wird eine Datenbank in ihrem Zustand zu einem Zeitpunkt wiederhergestellt, und es wird ein Wiederherstellungsvorgang angezeigt.

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 Backup auf URL: Best Practices und Fehlersuche
Sichern und Wiederherstellen von Systemdatenbanken (SQL Server)

Last updated on 2019-10-18

Freigeben über