Backup di SQL Server nell'URL

Articolo
10/18/2019

In questo argomento vengono presentati i concetti, i requisiti e i componenti necessari per usare il servizio di archiviazione BLOB di Azure come destinazione di backup. La funzionalità di backup e ripristino è uguale o simile a quella delle opzioni DISK e TAPE, con alcune differenze. Nell'argomento sono descritte le differenze e le eccezioni rilevanti e sono inclusi alcuni esempi di codice.

Requisiti, componenti e concetti

Contenuto della sezione:

Sicurezza

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

Quando si crea un contenitore per il servizio di archiviazione BLOB di Azure, è consigliabile impostare l'accesso a privato. In questo modo si limita l'accesso a utenti o account in grado di specificare le informazioni necessarie per l'autenticazione all'account di Azure.

Importante

SQL Server richiede l'archiviazione del nome e dell'autenticazione della chiave di accesso di Azure in un SQL Server credenziali. Queste informazioni vengono usate per eseguire l'autenticazione all'account Azure quando esegue operazioni di backup o ripristino.
All'account utente usato per eseguire i comandi BACKUP o RESTORE deve essere associato il ruolo del database db_backup operator con autorizzazioni Modifica qualsiasi credenziale .

Introduzione ai componenti e ai concetti chiave

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

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

mapping dell'account di archiviazione all'account di archiviazione di mapping delle credenziali sql

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 un account di archiviazione di Azure. Il nome dell'account di archiviazione e le relative proprietà 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 di Azure, è necessario creare almeno il contenitore radice.

BLOB: file di qualsiasi tipo e dimensioni. Esistono due tipi di BLOB che possono essere archiviati nel servizio di archiviazione BLOB di Azure: BLOB di 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>

Archiviazione BLOB di Azure

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

Per altre informazioni sui BLOB di pagine, vedere Informazioni sui BLOB in blocchi, sui BLOB di aggiunta e sui BLOB di pagine

Componenti di SQL Server

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

Avviso

Se si sceglie di copiare e caricare un file di backup nel servizio di archiviazione BLOB di Azure, usare BLOB di pagina come opzione di archiviazione. I ripristini dai BLOB in blocchi non sono supportati. Il ripristino da un BLOB in blocchi non viene completato e viene visualizzato un errore.

Ecco un valore URL di esempio: http[s]://ACCOUNTNAME.Blob.core.windows.net/< CONTAINER>/<FILENAME.bak>. Anche se non richiesto, è consigliabile utilizzare HTTPS.

Credenziali: Una credenziale SQL Server è un oggetto usato per archiviare le informazioni di autenticazione necessarie per connettersi a una risorsa all'esterno di SQL Server. In questo caso, SQL Server processi di backup e ripristino usano le credenziali per l'autenticazione al servizio di archiviazione BLOB di Azure. Nelle credenziali vengono archiviati il nome dell'account di archiviazione e i relativi valori della chiave di accesso . Una volta create, le credenziali devono essere specificate nell'opzione WITH CREDENTIAL durante l'esecuzione delle istruzioni BACKUP/RESTORE. Per altre informazioni su come visualizzare, copiare o rigenerare le access keysdell'account di archiviazione, vedere la pagina relativa alle chiavi di accesso dell'account di archiviazione.

Per istruzioni dettagliate su come creare una SQL Server credenziali, 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.

Limitazioni

Il backup in Archiviazione Premium non è supportato.
Le dimensioni massime di backup supportate sono 1 TB.
È possibile eseguire istruzioni di backup o ripristino tramite TSQL, SMO o cmdlet di PowerShell. Un backup in o il ripristino dal servizio di archiviazione BLOB di Azure usando SQL Server Management Studio Backup o Ripristino guidato non è attualmente abilitato.
La creazione di un nome di dispositivo logico non è supportata. Di conseguenza, non è supportata neanche l'aggiunta di un URL come dispositivo di backup tramite sp_dumpdevice o SQL Server Management Studio.
L'accodamento ai BLOB di backup esistenti non è supportato. I backup in un BLOB esistente possono solo essere sovrascritti tramite l'opzione WITH FORMAT.

Il backup in più BLOB effettuato con una singola operazione non è supportato. Ad esempio, se si esegue l'operazione riportata di seguito viene restituito 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 delle dimensioni del blocco con BACKUP non è supportata.
La specifica di MAXTRANSFERSIZE non è supportata.
La specifica delle opzioni del set di backup, RETAINDAYS e EXPIREDATE, non è supportata.
In SQL Server è previsto un limite massimo di 259 caratteri per il nome di un dispositivo di backup. BACKUP TO URL utilizza 36 caratteri per gli elementi necessari usati per specificare l'URL (https://.blob.core.windows.net//.bak ) lasciando 223 caratteri per i nomi dell'account, del contenitore e del BLOB.

Supporto per le istruzioni di backup/ripristino


Istruzione di backup/ripristino	Supportato	Eccezioni	Commenti
BACKUP	✓	BLOCKSIZE e MAXTRANSFERSIZE non sono supportate.	Richiede la specifica di WITH CREDENTIAL
RESTORE	✓		Richiede la specifica di WITH CREDENTIAL
RESTORE FILELISTONLY	✓		Richiede la specifica di WITH CREDENTIAL
RESTORE HEADERONLY	✓		Richiede la specifica di WITH CREDENTIAL
RESTORE LABELONLY	✓		Richiede la specifica di WITH CREDENTIAL
RESTORE VERIFYONLY	✓		Richiede la specifica di WITH CREDENTIAL
RESTORE REWINDONLY	✓

Per la sintassi e informazioni generali sulle istruzioni di backup, vedere BACKUP (Transact-SQL).For syntax and general information about backup statements, see BACKUP (Transact-SQL).

Per la sintassi e informazioni generali sulle istruzioni di ripristino, vedere RESTORE (Transact-SQL).For syntax and general information about restore statements, see RESTORE (Transact-SQL).

Supporto per gli argomenti dell'istruzione BACKUP


Argomento	Supportato	Eccezione	Commenti
DATABASE	✓
LOG	✓

TO (URL)	✓	Diversamente da DISK e TAPE, l'URL non supporta la specifica o la creazione di un nome logico.	Questo argomento viene utilizzato per specificare il percorso URL del file di backup.
MIRROR TO	✓
OPZIONI WITH:
CREDENTIAL	✓		WITH CREDENTIAL è supportato solo quando si usa l'opzione BACKUP TO URL per eseguire il backup nel servizio di archiviazione BLOB di Azure.
DIFFERENTIAL	✓
COPY_ONLY	✓
COMPRESSION\|NO_COMPRESSION	✓
DESCRIZIONE	✓
NOME	✓
EXPIREDATE \| RETAINDAYS	✓
NOINIT \| INIT	✓		Se utilizzata, questa opzione è ignorata. L'accodamento ai BLOB non è consentito. Per sovrascrivere un backup, utilizzare l'argomento FORMAT.
NOSKIP \| SKIP	✓
NOFORMAT \| FORMAT	✓		Se utilizzata, questa opzione è ignorata. Un backup eseguito in un BLOB esistente non viene completato a meno che non venga specificato WITH FORMAT. Il BLOB esistente viene sovrascritto quando viene specificato WITH FORMAT.
MEDIADESCRIPTION	✓
MEDIANAME	✓
BLOCKSIZE	✓
BUFFERCOUNT	✓
MAXTRANSFERSIZE	✓
NO_CHECKSUM \| CHECKSUM	✓
STOP_ON_ERROR \| CONTINUE_AFTER_ERROR	✓
STATS (Statistiche)	✓
REWIND \| NOREWIND	✓
UNLOAD \| NOUNLOAD	✓
NORECOVERY \| STANDBY	✓
NO_TRUNCATE	✓

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

Supporto per gli argomenti dell'istruzione RESTORE


Argomento	Supportato	Eccezioni	Commenti
DATABASE	✓
LOG	✓
FROM (URL)	✓		L'argomento FROM URL viene utilizzato per specificare il percorso URL del file di backup.
WITH Options:
CREDENTIAL	✓		WITH CREDENTIAL è supportato solo quando si usa l'opzione RESTORE FROM URL per eseguire il ripristino da Archiviazione BLOB di Azure servizio.
PARTIAL	✓
RECOVERY \| NORECOVERY \| STANDBY	✓
LOADHISTORY	✓
MOVE	✓
REPLACE	✓
RESTART	✓
RESTRICTED_USER	✓
FILE	✓
PASSWORD	✓
MEDIANAME	✓
MEDIAPASSWORD	✓
BLOCKSIZE	✓
BUFFERCOUNT	✓
MAXTRANSFERSIZE	✓
CHECKSUM \| NO_CHECKSUM	✓
STOP_ON_ERROR \| CONTINUE_AFTER_ERROR	✓
FILESTREAM	✓
STATS (Statistiche)	✓
REWIND \| NOREWIND	✓
UNLOAD \| NOUNLOAD	✓
KEEP_REPLICATION	✓
KEEP_CDC	✓
ENABLE_BROKER \| ERROR_BROKER_CONVERSATIONS \| NEW_BROKER	✓
STOPAT \| STOPATMARK \| STOPBEFOREMARK	✓

Per altre informazioni sugli argomenti Restore, vedere Argomenti RESTORE (Transact-SQL).For more information about Restore arguments, see RESTORE Arguments (Transact-SQL).

Utilizzo dell'attività di 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 nell'archiviazione di Azure, ad esempio le credenziali SQL.

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

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 scegliere Backup.. Verrà visualizzata la finestra di dialogo Backup database .
Nella pagina generale viene usata l'opzione URL per creare un backup in Archiviazione di Azure. Quando si seleziona questa opzione, nella pagina verranno abilitate altre opzioni:
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 dispone dell'accesso al certificato di gestione o al profilo di pubblicazione, è possibile creare le credenziali di SQL specificando il nome dell'account di archiviazione e le informazioni sulla chiave di accesso tramite Transact-SQL o SQL Server Management Studio. Vedere il codice di esempio nella sezione Creare credenziali per creare le credenziali tramite Transact-SQL. In alternativa, utilizzando SQL Server Management Studio, dall'istanza del motore di database, fare clic con il pulsante destro del mouse su Sicurezza, scegliere Nuovoe selezionare Credenziale. Specificare il nome dell'account di archiviazione per Identity e la chiave di accesso nel campo Password .
3. Contenitore di archiviazione di Azure: Nome del contenitore di archiviazione di Azure in cui archiviare i file di backup.
4. Prefisso URL: viene compilato automaticamente utilizzando le informazioni specificate nei campi descritti nei passaggi precedenti. Se si modifica questo valore manualmente, assicurarsi che corrisponda alle altre informazioni fornite in precedenza. Se ad esempio si modifica l'URL di archiviazione, assicurarsi che le credenziali SQL siano impostate per l'autenticazione dello stesso account di archiviazione.

Quando si seleziona un URL come destinazione, alcune opzioni nella pagina Opzioni supporti vengono disabilitate. Negli argomenti seguenti vengono fornite ulteriori informazioni sulla finestra di dialogo Backup database:

Backup database (pagina Generale)

Backup database (pagina Opzioni multimediali)

Backup database (pagina Opzioni di backup)

Creare le credenziali - Eseguire l'autenticazione nel servizio di archiviazione Azure

Backup di SQL Server 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 nell'archiviazione di Azure, ad esempio le credenziali SQL. Per altre informazioni, vedere la sezione Definire le attività di backup in Utilizzo guidato del piano di manutenzione.

Ripristino da Archiviazione di Azure mediante 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 Archiviazione di Azure:

Quando si seleziona Dispositivi nella pagina Generale dell'attività di ripristino in SQL Server Management Studio, viene visualizzata la finestra di dialogo Seleziona dispositivi di backup che include URL come tipo di supporti di backup.
Quando si seleziona URL e si fa clic su Aggiungi, viene visualizzata la finestra di dialogo Connessione a Servizio di archiviazione Windows Azure . Specificare le informazioni sulle credenziali SQL per l'autenticazione in Archiviazione di Azure.
SQL Server quindi si connette ad Archiviazione di Azure usando le informazioni sulle credenziali SQL fornite e apre la finestra di dialogo Individua file di backup in Azure. In questa pagina vengono visualizzati i file di backup che si trovano nello spazio di archiviazione. Selezionare il file che si desidera ripristinare, quindi 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 ulteriori informazioni, vedere gli argomenti seguenti:

Ripristina 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 di file completo del filegroup primario
Creazione di un backup di file differenziale dei filegroup primari
Ripristino di un database e spostamento dei file
Ripristino temporizzato tramite STOPAT

Create a Credential

L'esempio seguente crea una credenziale che archivia le informazioni di autenticazione di 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 di 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 riportato di seguito viene eseguito il backup del database di esempio AdventureWorks2012 per il quale viene utilizzato, per impostazione predefinita, il modello di recupero con registrazione minima. Per consentire il backup del log, il database AdventureWorks2012 viene modificato per l'utilizzo del modello di recupero con registrazione completa. L'esempio crea quindi un backup completo del database nel BLOB di Azure e dopo un periodo di attività di aggiornamento, esegue il backup del log. In questo esempio viene creato il nome di un 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 di file completo del filegroup primario

Nell'esempio seguente viene creato un backup di file 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 di file differenziale del filegroup primario

Nell'esempio seguente viene creato un backup di file 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 nella directory C:\Program Files\Microsoft SQL Server\MSSQL12.MSSQLSERVER\MSSQL\Data, attenersi ai passaggi riportati di seguito.

-- 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 temporizzato tramite STOPAT

Nell'esempio seguente viene ripristinato lo stato di un database in un momento preciso e viene illustrata 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)

Condividi tramite