SQL Server backup nell'URL

Questo argomento presenta i concetti, i requisiti e i componenti necessari per usare il servizio di archiviazione BLOB Azure come destinazione di backup. La funzionalità di backup e ripristino è uguale o simile a quando si usa DISK o TAPE, con alcune differenze. Le differenze sono e tutte le eccezioni rilevanti e alcuni esempi di codice sono inclusi in questo argomento.

Requisiti, componenti e concetti

Contenuto della sezione:

• Security

• Introduzione a componenti e concetti chiave

• servizio Archiviazione BLOB di Azure

• componenti SQL Server

• Limitazioni

• Supporto per istruzioni di backup/ripristino

• Uso dell'attività backup in SQL Server Management Studio

• SQL Server backup nell'URL tramite la Creazione guidata piano di manutenzione

• Ripristino dall'archiviazione di Azure tramite SQL Server Management Studio

Security

Di seguito sono riportate considerazioni sulla sicurezza e requisiti per il backup o il ripristino dai servizi di archiviazione BLOB Azure.

• Quando si crea un contenitore per il servizio di archiviazione BLOB Azure, è consigliabile impostare l'accesso su privato. L'impostazione dell'accesso a privato limita l'accesso a utenti o account in grado di fornire le informazioni necessarie per l'autenticazione all'account Azure.

  Importante

  SQL Server richiede Azure nome dell'account e l'autenticazione della chiave di accesso da archiviare in una credenziale SQL Server. Queste informazioni vengono usate per eseguire l'autenticazione all'account Azure quando esegue operazioni di backup o ripristino.

• L'account utente usato per eseguire BACKUP o RESTORE i comandi deve trovarsi nel ruolo di operatore db_backup con permessi Alter any credential.

Introduzione a componenti e concetti chiave

Le due sezioni seguenti illustrano il servizio di archiviazione BLOB Azure e i componenti SQL Server usati durante il backup o il ripristino dal servizio di archiviazione BLOB Azure. È importante comprendere i componenti e l'interazione tra di essi per eseguire un backup o eseguire il ripristino dal servizio di archiviazione BLOB Azure.

La creazione di un account Azure è il primo passaggio per questo processo. SQL Server usa il nome dell'account di archiviazione Azure e i relativi valori delle chiavi di accesso per autenticare e scrivere e leggere BLOB nel servizio di archiviazione. Le credenziali SQL Server archivia queste informazioni di autenticazione e vengono usate durante le operazioni di backup o ripristino. Per una procedura dettagliata completa sulla creazione di un account di archiviazione e sull'esecuzione di un ripristino semplice, vedere Esercitazione sull'uso del servizio Archiviazione di Azure per il backup e il ripristino di SQL Server.

servizio Archiviazione BLOB di Azure

Account di archiviazione: L'account di archiviazione è il punto di partenza per tutti i servizi di archiviazione. Per accedere al servizio Archiviazione BLOB di Azure, creare prima di tutto un account di archiviazione Azure. Il nome dell'account di archiviazione e le relative proprietà della chiave di accesso sono necessari per eseguire l'autenticazione al servizio Archiviazione BLOB di Azure e ai relativi componenti.

Contenitore: Un contenitore fornisce un raggruppamento di un set di BLOB e può archiviare un numero illimitato di BLOB. Per scrivere un backup SQL Server nel servizio BLOB Azure, è necessario avere almeno il contenitore radice creato.

Blob: File di qualsiasi tipo e dimensione. Esistono due tipi di BLOB che possono essere archiviati nel servizio di archiviazione BLOB Azure: BLOB in blocchi e pagine. SQL Server backup usa BLOB di pagine come tipo di BLOB. I BLOB sono indirizzabili usando il formato URL seguente: https://< storage account.blob.core.windows.net/>< container>/<blob>

Per altre informazioni sul servizio Azure Blob storage, vedere Come usare il servizio Archiviazione BLOB di Azure

Per ulteriori informazioni sui BLOB di pagine, vedere Comprendere i BLOB in blocchi e i BLOB di pagine

componenti SQL Server

URL: Un URL specifica un URI (Uniform Resource Identifier) in un file di backup univoco. L'URL viene usato per specificare il percorso e il nome del file di backup SQL Server. In questa implementazione, l'unico URL valido è uno che punta a un BLOB di pagine in un account di archiviazione Azure. L'URL deve puntare a un BLOB effettivo, non solo a un contenitore. Se il BLOB non esiste, viene creato. Se viene specificato un BLOB esistente, BACKUP ha esito negativo, a meno che non venga specificata l'opzione "WITH FORMAT".

Ecco un valore URL di esempio: http[s]://ACCOUNTNAME.Blob.core.windows.net/< CONTAINER>/<FILENAME.bak>. HTTPS non è obbligatorio, ma è consigliato.

Credential: Una credenziale SQL Server è un oggetto usato per archiviare le informazioni di autenticazione necessarie per connettersi a una risorsa al di fuori di SQL Server. In questo caso, SQL Server processi di backup e ripristino usano le credenziali per eseguire l'autenticazione al servizio di archiviazione BLOB Azure. Le credenziali archivia il nome dell'account di archiviazione e i valori della chiave di accesso dell'account di archiviazione. Dopo aver creato la credenziale, è necessario specificarla nell'opzione WITH CREDENTIAL quando si emettono le BACKUPistruzioni /RESTORE . Per altre informazioni su come visualizzare, copiare o rigenerare le chiavi di accesso dell'account di archiviazione, vedere Chiavi di accesso dell'account di archiviazione.

Per istruzioni dettagliate su come creare una credenziale SQL Server, vedere Creare un esempio di credenziali più avanti in questo argomento.

Per informazioni generali sulle credenziali, vedere Credenziali

Per informazioni su altri esempi in cui vengono usate le credenziali, vedere Creare un proxy SQL Server Agent.

Limitations

• Il backup nell'archiviazione Premium non è supportato.

• La dimensione massima supportata per il backup è di 1 TB.

• È possibile eseguire istruzioni di backup o ripristino usando cmdlet TSQL, SMO o PowerShell. Un backup in o ripristino dal servizio di archiviazione BLOB Azure tramite SQL Server Management Studio backup o ripristino guidato non è attualmente abilitato.

• La creazione di un nome di dispositivo logico non è supportata. L'aggiunta di URL come dispositivo di backup tramite sp_dumpdevice o tramite SQL Server Management Studio non è quindi supportata.

• L'aggiunta a BLOB di backup esistenti non è supportata. I backup in un BLOB esistente possono essere sovrascritti solo usando l'opzione WITH FORMAT.

• Il backup in più BLOB in una singola operazione di backup non è supportato. Ad esempio, il codice seguente restituisce un errore:

  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
  

• La specifica di una dimensione del blocco con BACKUP non è supportata.

• La specifica non MAXTRANSFERSIZE è supportata.

• Specifica delle opzioni RETAINDAYS del set di backup e EXPIREDATE non sono supportate.

• SQL Server ha un limite massimo di 259 caratteri per un nome di dispositivo di backup. L'URL BACKUP TO utilizza 36 caratteri per gli elementi necessari usati per specificare l'URL , 'https://.blob.core.windows.net//.bak', lasciando 223 caratteri per i nomi di account, contenitore e BLOB messi insieme.

Supporto per istruzioni di backup/ripristino

Per informazioni generali sulla sintassi e sulle istruzioni di backup, vedere BACKUP (Transact-SQL).

Per informazioni generali sulla sintassi e sulle istruzioni di ripristino, vedere RESTORE (Transact-SQL).

Supporto per argomenti di backup

Per altre informazioni sugli argomenti di backup, vedere BACKUP (Transact-SQL).

Supporto per gli argomenti di ripristino

Per altre informazioni sugli argomenti di ripristino, vedere RESTORE Argomenti (Transact-SQL).

Uso dell'attività backup in SQL Server Management Studio

L'attività Backup in SQL Server Management Studio è stata migliorata per includere l'URL come una delle opzioni di destinazione e altri oggetti di supporto necessari per eseguire il backup in Azure archiviazione, ad esempio le credenziali SQL.

I passaggi seguenti descrivono le modifiche apportate all'attività Backup database per consentire il backup in Azure archiviazione:

1. Avviare SQL Server Management Studio e connettersi all'istanza di SQL Server. Selezionare un database di cui si vuole eseguire il backup e fare clic con il pulsante destro del mouse su Attività e selezionare Backup.. Verrà visualizzata la finestra di dialogo Backup database .

2. Nella pagina generale viene usata l'opzione URL per creare un backup per Azure archiviazione. Quando si seleziona questa opzione, vengono visualizzate altre opzioni abilitate in questa pagina:

   1. Nome file: Nome del file di backup.

   2. Credenziali SQL: È possibile specificare una credenziale SQL Server esistente oppure crearne una nuova facendo clic sulla casella Crea accanto alla casella Credenziali SQL.

      Importante

      La finestra di dialogo visualizzata quando si fa clic su Crea richiede un certificato di gestione o il profilo di pubblicazione per la sottoscrizione. SQL Server supporta attualmente la versione del profilo di pubblicazione 2.0. Per scaricare la versione supportata del profilo di pubblicazione, vedere Download del profilo di pubblicazione 2.0.

      Se non si ha accesso al certificato di gestione o al profilo di pubblicazione, è possibile creare credenziali SQL specificando il nome dell'account di archiviazione e le informazioni sulla chiave di accesso usando Transact-SQL o SQL Server Management Studio. Vedere il codice di esempio nella sezione Creare credenziali per creare credenziali usando Transact-SQL. In alternativa, usando SQL Server Management Studio, nell'istanza del motore di database fare clic con il pulsante destro del mouse su Sicurezza, selezionare Nuovo e selezionare Credenziali. Specificare il nome dell'account di archiviazione per Identity e la chiave di accesso nel campo Password .

   3. Azure contenitore di archiviazione: Nome del contenitore di archiviazione Azure per archiviare i file di backup.

   4. Prefisso URL: Questa operazione viene compilata automaticamente usando le informazioni specificate nei campi descritti nei passaggi precedenti. Se si modifica questo valore manualmente, assicurarsi che corrisponda alle altre informazioni fornite in precedenza. Ad esempio, se si modifica l'URL di archiviazione, assicurarsi che le credenziali SQL siano impostate per l'autenticazione nello stesso account di archiviazione.

Quando si seleziona URL come destinazione, alcune opzioni nella pagina Opzioni multimediali sono disabilitate. Negli argomenti seguenti sono disponibili altre informazioni sulla finestra di dialogo Backup database:

Backup database (pagina Generale)

Backup del database (pagina Opzioni supporto)

Backup database (pagina Opzioni di backup)

Crea credenziali - Eseguire l'autenticazione per Archiviazione di Azure

SQL Server backup nell'URL tramite la Creazione guidata piano di manutenzione

Analogamente all'attività di backup descritta in precedenza, la Creazione guidata piano di manutenzione in SQL Server Management Studio è stata migliorata per includere l'URL come una delle opzioni di destinazione e altri oggetti di supporto necessari per eseguire il backup in Azure archiviazione, ad esempio le credenziali SQL. Per altre informazioni, vedere la sezione Definire le attività di backup in Uso della Creazione guidata piano di manutenzione.

Ripristino dall'archiviazione di Azure tramite SQL Server Management Studio

Se si ripristina un database, l'URL viene incluso come dispositivo da cui eseguire il ripristino. I passaggi seguenti descrivono le modifiche nell'attività Ripristina per consentire il ripristino da Azure archiviazione:

1. Quando si seleziona Dispositivi nella pagina Generale dell'attività Ripristina in SQL Server Management Studio, viene visualizzata la finestra di dialogo Seleziona dispositivi di backup che include l'URL come tipo di supporto di backup.

2. Quando si seleziona URL e si fa clic su Aggiungi, si apre la finestra di dialogo Connetti a Azure archiviazione. Specificare le informazioni sulle credenziali SQL da autenticare per Azure archiviazione.

3. SQL Server quindi si connette all'archiviazione Azure usando le informazioni sulle credenziali SQL fornite e apre la finestra di dialogo Individua file di backup in Azure. I file di backup che risiedono nella risorsa di archiviazione vengono visualizzati in questa pagina. Selezionare il file da usare per ripristinare e fare clic su OK. Verrà visualizzata nuovamente la finestra di dialogo Seleziona dispositivi di backup e facendo clic su OK in questa finestra di dialogo verrà visualizzata nuovamente la finestra di dialogo Principale ripristino in cui sarà possibile completare il ripristino. Per altre informazioni, vedere gli argomenti seguenti:

   Ripristina il database (pagina generale)

   Ripristina database (pagina File)

   Ripristina database (pagina Opzioni)

Esempi di codice

In questa sezione sono disponibili gli esempi riportati di seguito.

• Creare credenziali

• Backup di un database completo

• Backup del database e del log

• Creazione di un backup completo del filegroup primario

• Creazione di un backup differenziale dei filegroup primari

• Ripristino di un database e spostamento dei file

• Ripristino temporizzato tramite STOPAT

Creare una credenziale

Nell'esempio seguente viene creata una credenziale che archivia le informazioni di autenticazione Archiviazione di Azure.

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

Backup di un database completo

Nell'esempio seguente viene eseguito il backup del database AdventureWorks2012 nel servizio di archiviazione BLOB Azure.

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

Backup del database e del log

Nell'esempio seguente viene eseguito il backup del database di esempio AdventureWorks2012, che usa il modello di recupero con registrazione minima per impostazione predefinita. Per supportare i backup del log, il database AdventureWorks2012 viene modificato in modo da usare il modello di recupero con registrazione completa. L'esempio crea quindi un backup completo del database per Azure BLOB e, dopo un periodo di attività di aggiornamento, esegue il backup del log. In questo esempio viene creato un nome file di backup con un indicatore datetime.

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

Creazione di un backup completo del filegroup primario

Nell'esempio seguente viene creato un backup completo del filegroup primario.

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

Creazione di un backup differenziale del filegroup primario

Nell'esempio seguente viene creato un backup differenziale del filegroup primario.

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

Ripristinare un database e spostare i file

Per ripristinare un backup completo del database e spostare il database ripristinato in C:\Programmi\Microsoft SQL Server\MSSQL12. La directory MSSQLSERVER\MSSQL\Data seguire questa procedura.

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

Ripristino in un momento specifico tramite STOPAT

Nell'esempio seguente viene ripristinato lo stato di un database a un punto nel tempo e viene visualizzata un'operazione di ripristino.

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

Vedere anche

Procedure consigliate e risoluzione dei problemi per il backup di SQL Server nell'URL
Backup e ripristino di database di sistema (SQL Server)