Sauvegarde SQL Server vers une URL
Cette rubrique présente les concepts, les exigences et les composants nécessaires pour utiliser le service stockage Blob Azure comme destination de sauvegarde. Les fonctionnalités de sauvegarde et de restauration sont identiques ou similaires à l'utilisation de l'option DISK ou TAPE, à quelques différences près. Les différences, les exceptions notables et des exemples de code sont inclus dans cette rubrique.
Configuration requise, composants et concepts
Dans cette section :
Utilisation de la tâche de sauvegarde dans SQL Server Management Studio
Sauvegarde SQL Server vers une URL à l'aide de l'Assistant Plan de maintenance
Restauration à partir du stockage Azure à l’aide de SQL Server Management Studio
Sécurité
Vous trouverez ci-dessous des considérations et des exigences en matière de sécurité lors de la sauvegarde ou de la restauration à partir des services de stockage Blob Azure.
Lorsque vous créez un conteneur pour le service de stockage Blob Azure, nous vous recommandons de définir l’accès sur privé. La définition d’un accès privé limite l’accès aux seuls utilisateurs ou comptes capables de fournir les informations nécessaires pour s’authentifier auprès du compte Azure.
Important
SQL Server nécessite que l’authentification par le nom du compte Azure et la clé d’accès soient stockées dans des informations d’identification SQL Server. Ces informations sont utilisées pour s’authentifier auprès du compte Azure lorsqu’il effectue des opérations de sauvegarde ou de restauration.
Le compte d’utilisateur utilisé pour émettre les commandes BACKUP (sauvegarder) ou RESTORE (restaurer) doit figurer dans le rôle de base de données db_backup operator avec les autorisations Modifier des informations d’identification .
Présentation des principaux éléments et concepts
Les deux sections suivantes présentent le service stockage Blob Azure et les composants SQL Server utilisés lors de la sauvegarde ou de la restauration à partir du service de stockage Blob Azure. Il est important de comprendre les composants et l’interaction entre eux pour effectuer une sauvegarde ou une restauration à partir du service de stockage Blob Azure.
La création d’un compte Azure est la première étape de ce processus. SQL Server utilise le nom du compte de stockage Azure et ses valeurs de clé d’accès pour authentifier, écrire et lire des objets blob sur le service de stockage. Les informations d’identification SQL Server stockent ces informations d’authentification et les utilisent durant les opérations de sauvegarde ou de restauration. Pour obtenir une procédure pas à pas complète de création d’un compte de stockage et d’exécution d’une restauration simple, consultez Tutoriel sur l’utilisation du service de stockage Azure pour la sauvegarde et la restauration SQL Server.
Stockage Blob Azure Service
Compte de stockage : Le compte de stockage constitue le point de départ de tous les services de stockage. Pour accéder au service Stockage Blob Azure, commencez par créer un compte de stockage Azure. Le nom du compte de stockage et ses propriétés de clé d’accès sont requis pour s’authentifier auprès du service Stockage Blob Azure et de ses composants.
Conteneur: Un conteneur fournit un regroupement d’un ensemble d’objets blob et peut stocker un nombre illimité d’objets blob. Pour écrire une sauvegarde SQL Server dans le service Blob Azure, vous devez avoir au moins le conteneur racine créé.
Objet blob : Fichier de tout type et de toute taille. Il existe deux types d’objets blob qui peuvent être stockés dans le service de stockage Blob Azure : les objets blob de blocs et les objets blob de pages. SQL Server sauvegarde utilise des objets blob de pages comme type d’objet blob. Les objets blob sont adressables au format d’URL suivant : https://< compte> de stockage.blob.core.windows.net/< container>/<blob>
Pour plus d’informations sur le service stockage Blob Azure, consultez Guide pratique pour utiliser le service Stockage Blob Azure
Pour plus d’informations sur les blobs, consultez Présentation des objets blob de blocs et des objets blob de pages
Composants SQL Server
URL : Une URL spécifie un URI (Uniform Resource Identifier) pour un fichier de sauvegarde unique. L'URL est utilisée pour indiquer l'emplacement et le nom du fichier de sauvegarde de SQL Server . Dans cette implémentation, la seule URL valide est celle qui pointe vers un objet blob de page dans un compte de stockage Azure. L'URL doit pointer vers un objet blob réel et pas un simple conteneur. Si l'objet blob n'existe pas, il est créé. Si un objet blob existant est spécifié, BACKUP échoue, sauf si l’option « WITH FORMAT » est spécifiée.
Avertissement
Si vous choisissez de copier et de charger un fichier de sauvegarde dans le service de stockage Blob Azure, utilisez l’objet blob de pages comme option de stockage. Les restaurations à partir d'objets blob de blocs ne sont pas prises en charge. Une restauration à partir d'un type d'objet blob de blocs échoue avec une erreur.
Voici un exemple de valeur d’URL : http[s]://ACCOUNTNAME.Blob.core.windows.net/< CONTAINER>/<FILENAME.bak>. HTTPS n'est pas obligatoire, mais est recommandé.
Informations d’identification : Les informations d'identification SQL Server sont des objets utilisés pour stocker les informations d'authentification requises pour la connexion à une ressource en dehors de SQL Server. Ici, SQL Server processus de sauvegarde et de restauration utilisent des informations d’identification pour s’authentifier auprès du service de stockage Blob Azure. Les informations d'identification contiennent le nom du compte de stockage et ses valeurs de clé d'accès . Une fois les informations d'identification créées, vous devez les spécifier dans l'option WITH CREDENTIAL lorsque vous publiez des instructions BACKUP/RESTORE. Pour plus d'informations sur l'affichage, la copie ou la régénération des access keysde compte de stockage, consultez Afficher, copier et régénérer les clés d'accès d'un compte de stockage Windows Azure.
Pour obtenir des instructions détaillées sur la création d’une SQL Server Credential, consultez l’exemple Créer des informations d’identification plus loin dans cette rubrique.
Pour plus d’informations sur les informations d’identification en général, consultez Informations d’identification.
Pour plus d’informations, sur d’autres exemples d’utilisation d’informations d’identification, consultez Créer un proxy SQL Server Agent.
Limites
La sauvegarde dans le stockage Premium n’est pas prise en charge.
La taille de sauvegarde maximale prise en charge est de 1 To.
Publiez des instructions de sauvegarde ou de restauration à l'aide de TSQL, de SMO ou d'applets de commande PowerShell. Une sauvegarde ou une restauration à partir du service de stockage Blob Azure à l’aide de SQL Server Management Studio’Assistant Sauvegarde ou restauration n’est pas activée actuellement.
La création d'un nom d'unité logique n'est pas prise en charge. Par conséquent, l'ajout d'une URL comme unité de sauvegarde à l'aide de sp_dumpdevice ou de SQL Server Management Studio n'est pas pris en charge.
L'ajout d'objets blob de sauvegarde existants n'est pas pris en charge. Les sauvegardes vers un objet blob existant peuvent uniquement être remplacées à l'aide de l'option WITH FORMAT.
La sauvegarde vers plusieurs objets blob dans le cadre d'une opération de sauvegarde n'est pas prise en charge. Par exemple, le code suivant retourne une erreur :
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; GOLa spécification d'une taille de bloc avec
BACKUPn'est pas prise en charge.La spécification de
MAXTRANSFERSIZEn'est pas prise en charge.La spécification des options backupset
RETAINDAYSetEXPIREDATEn'est pas prise en charge.SQL Server est soumis à une limite de 259 caractères pour le nom d'une unité de sauvegarde. BACKUP TO URL utilise 36 caractères pour les éléments requis utilisés pour spécifier l’URL « https://.blob.core.windows.net//.bak », ce qui laisse 223 caractères pour les noms de compte, de conteneur et d’objet blob réunis.
Prise en charge des instructions de sauvegarde/restauration
| Instruction de sauvegarde/restauration | Prise en charge | Exceptions | Commentaires |
| BACKUP | ✓ | BLOCKSIZE et MAXTRANSFERSIZE ne sont pas prises en charge. | Requiert la spécification de WITH CREDENTIAL |
| RESTORE | ✓ | Requiert la spécification de WITH CREDENTIAL | |
| RESTORE FILELISTONLY | ✓ | Requiert la spécification de WITH CREDENTIAL | |
| RESTORE HEADERONLY | ✓ | Requiert la spécification de WITH CREDENTIAL | |
| RESTORE LABELONLY | ✓ | Requiert la spécification de WITH CREDENTIAL | |
| RESTORE VERIFYONLY | ✓ | Requiert la spécification de WITH CREDENTIAL | |
| RESTORE REWINDONLY | ✓ |
Pour plus d’informations sur la syntaxe et les instructions de sauvegarde, consultez BACKUP (Transact-SQL).
Pour plus d’informations sur la syntaxe et les instructions de restauration, consultez RESTORE (Transact-SQL).
Prise en charge des arguments de sauvegarde
| Argument | Prise en charge | Exception | Commentaires |
| DATABASE | ✓ | ||
| LOG | ✓ | ||
| TO (URL) | ✓ | Contrairement à DISK et TAPE, URL ne prend pas en charge la spécification ou la création d'un nom logique. | Cet argument est utilisé pour spécifier le chemin d'accès de l'URL du fichier de sauvegarde. |
| MIRROR TO | ✓ | ||
| WITH OPTIONS : | |||
| CREDENTIAL | ✓ | WITH CREDENTIAL est uniquement pris en charge lors de l’utilisation de l’option BACKUP TO URL pour sauvegarder dans le service de stockage Blob Azure. | |
| DIFFERENTIAL | ✓ | ||
| COPY_ONLY | ✓ | ||
| COMPRESSION|NO_COMPRESSION | ✓ | ||
| Description | ✓ | ||
| NOM | ✓ | ||
| EXPIREDATE | RETAINDAYS | ✓ | ||
| NOINIT | INIT | ✓ | Cette option est ignorée si elle est utilisée. L'ajout aux objets blob n'est pas possible. Pour remplacer une sauvegarde, utilisez l'argument FORMAT. |
|
| NOSKIP | SKIP | ✓ | ||
| NOFORMAT | FORMAT | ✓ | Cette option est ignorée si elle est utilisée. Une sauvegarde effectuée sur un objet blob existant échoue à moins que WITH FORMAT ne soit spécifié. L'objet blob existant est remplacé lorsque WITH FORMAT est spécifié. |
|
| MEDIADESCRIPTION | ✓ | ||
| MEDIANAME | ✓ | ||
| BLOCKSIZE | ✓ | ||
| BUFFERCOUNT | ✓ | ||
| MAXTRANSFERSIZE | ✓ | ||
| NO_CHECKSUM | CHECKSUM | ✓ | ||
| STOP_ON_ERROR | CONTINUE_AFTER_ERROR | ✓ | ||
| STATS | ✓ | ||
| REWIND | NOREWIND | ✓ | ||
| UNLOAD | NOUNLOAD | ✓ | ||
| NORECOVERY | STANDBY | ✓ | ||
| NO_TRUNCATE | ✓ |
Pour plus d’informations sur les arguments de sauvegarde, consultez BACKUP (Transact-SQL).
Prise en charge des arguments de restauration
| Argument | Prise en charge | Exceptions | Commentaires |
| DATABASE | ✓ | ||
| LOG | ✓ | ||
| FROM (URL) | ✓ | L'argument FROM URL est utilisé pour spécifier le chemin d'accès de l'URL du fichier de sauvegarde. | |
| WITH Options: | |||
| CREDENTIAL | ✓ | WITH CREDENTIAL est uniquement pris en charge lors de l’utilisation de l’option RESTORE FROM URL pour effectuer une restauration à partir de Stockage Blob Azure service. | |
| 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 | ✓ | ||
| REWIND | NOREWIND | ✓ | ||
| UNLOAD | NOUNLOAD | ✓ | ||
| KEEP_REPLICATION | ✓ | ||
| KEEP_CDC | ✓ | ||
| ENABLE_BROKER | ERROR_BROKER_CONVERSATIONS | NEW_BROKER | ✓ | ||
| STOPAT | STOPATMARK | STOPBEFOREMARK | ✓ |
Pour plus d’informations sur les arguments de restauration, consultez Arguments RESTORE (Transact-SQL).
Utilisation de la tâche de sauvegarde dans SQL Server Management Studio
La tâche de sauvegarde dans SQL Server Management Studio a été améliorée pour inclure l’URL comme l’une des options de destination, ainsi que d’autres objets de prise en charge nécessaires à la sauvegarde dans le stockage Azure, comme les informations d’identification SQL.
Les étapes suivantes décrivent les modifications apportées à la tâche De sauvegarde de base de données pour permettre la sauvegarde dans le stockage Azure :
Démarrez SQL Server Management Studio et connectez-vous à une instance SQL Server. Sélectionnez une base de données que vous souhaitez sauvegarder, cliquez avec le bouton droit sur Tâches, puis sélectionnez Sauvegarder... La boîte de dialogue Sauvegarder la base de données s’ouvre.
Dans la page général, l’option URL est utilisée pour créer une sauvegarde dans le stockage Azure. Lorsque vous sélectionnez cette option, les autres options activées sur cette page s'affichent :
Nom du fichier : nom du fichier de sauvegarde.
Informations d'identification SQL : spécifiez des informations d'identification SQL Server existantes, ou pour en créer des nouvelles, cliquez sur Créer à côté de la zone Informations d'identification SQL.
Important
La boîte de dialogue qui s'ouvre lorsque vous cliquez sur Créer requiert un certificat de gestion ou le profil de publication de l'abonnement. SQL Server prend actuellement en charge la version 2.0 du profil de publication. Pour télécharger la version prise en charge du profil de publication, consultez Télécharger le profil de publication 2.0.
Si vous n'avez pas accès au certificat de gestion ou au profil de publication, vous pouvez créer des informations d'identification SQL en spécifiant le nom du compte de stockage et les informations de clé d'accès à l'aide de Transact-SQL ou de SQL Server Management Studio. Consultez l'exemple de code dans la section Créer des informations d'identification pour créer des informations d'identification à l'aide de Transact-SQL. Vous pouvez également utiliser SQL Server Management Studio, depuis l'instance du moteur de base de données, et cliquer avec le bouton droit sur Sécurité, puis sélectionner Nouveau, puis Informations d'identification. Spécifiez le nom du compte de stockage pour Identité et la clé d'accès dans le champ Mot de passe .
Conteneur de stockage Azure : Nom du conteneur de stockage Azure pour stocker les fichiers de sauvegarde.
Préfixe d'URL : ce préfixe est généré automatiquement en utilisant les informations spécifiées dans les champs décrits dans les étapes précédentes. Si vous modifiez manuellement cette valeur, assurez-vous qu'elle correspond aux autres informations spécifiées précédemment. Par exemple, si vous modifiez l'URL de stockage, vérifiez que les informations d'identification SQL sont définies pour l'authentification auprès du même compte de stockage.
Quand vous sélectionnez URL comme destination, certaines options de la page Options de support sont désactivées. Les rubriques suivantes contiennent d'autres informations sur la boîte de dialogue Sauvegarder la base de données :
Sauvegarder la base de données (page Général)
Sauvegarder la base de données (page Options de support)
Sauvegarder la base de données (page Options de sauvegarde)
Créer des informations d’identification - Authentification Azure Storage
Sauvegarde SQL Server vers une URL à l'aide de l'Assistant Plan de maintenance
À l’instar de la tâche de sauvegarde décrite précédemment, l’Assistant Plan de maintenance dans SQL Server Management Studio a été amélioré pour inclure l’URL comme l’une des options de destination et d’autres objets de prise en charge requis pour la sauvegarde dans le stockage Azure, comme les informations d’identification SQL. Pour plus d’informations, consultez la section Définir les tâches de sauvegarde dans l’Assistant Utilisation du plan de maintenance.
Restauration à partir du stockage Azure à l’aide de SQL Server Management Studio
Si vous restaurez une base de données, l'option URL est incluse en tant qu'unité à partir de laquelle la restauration doit être effectuée. Les étapes suivantes décrivent les modifications apportées à la tâche de restauration pour autoriser la restauration à partir du stockage Azure :
Lorsque vous sélectionnez Périphériques dans la page Général de la tâche de restauration dans SQL Server Management Studio, la boîte de dialogue Sélectionner les unités de sauvegarde s'ouvre et comprend l'option URL comme type de support de sauvegarde.
Lorsque vous sélectionnez URL et cliquez sur Ajouter, la boîte de dialogue Se connecter au stockage Windows Azure s'ouvre. Spécifiez les informations d’identification SQL pour l’authentification auprès du stockage Azure.
SQL Server se connecte ensuite au stockage Azure à l’aide des informations d’identification SQL que vous avez fournies et ouvre la boîte de dialogue Localiser le fichier de sauvegarde dans Azure. Les fichiers de sauvegarde résidant dans le stockage s'affichent sur cette page. Sélectionnez le fichier à utiliser pour la restauration, puis cliquez sur OK. Vous revenez dans la boîte de dialogue Sélectionner les unités de sauvegarde, et lorsque vous cliquez sur OK, vous revenez dans la boîte de dialogue principale Restaurer où vous pourrez effectuer la restauration. Pour plus d'informations, consultez les rubriques ci-dessous :
Restaurer la base de données (page Général)
Exemples de code
Cette section contient les exemples suivants :
Création d'une sauvegarde complète du groupe de fichiers principal
Création d'une sauvegarde différentielle du groupe de fichiers principal
Restauration d’une base de données et déplacement des fichiers
Create a Credential
L’exemple suivant crée des informations d’identification qui stockent les informations d’authentification de Stockage 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
Sauvegarde d'une base de données complète
L’exemple suivant sauvegarde la base de données AdventureWorks2012 dans le service de stockage 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
Sauvegarde de la base de données et du journal
L'exemple suivant sauvegarde l'exemple de base de données AdventureWorks2012 qui utilise par défaut le mode de récupération simple. Pour prendre en charge les sauvegardes de fichier journal, la base de données AdventureWorks2012 est modifiée pour utiliser le mode de récupération complète. L’exemple crée ensuite une sauvegarde de base de données complète dans Azure Blob et, après une période d’activité de mise à jour, sauvegarde le journal. Cet exemple crée un nom de fichier de sauvegarde avec un tampon d'horodateur.
-- 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
Création d'une sauvegarde complète du groupe de fichiers principal
L'exemple suivant crée une sauvegarde complète du groupe de fichiers principal.
--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
Création d'une sauvegarde différentielle du groupe de fichiers principal
L'exemple suivant crée une sauvegarde différentielle du groupe de fichiers principal.
--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
Restauration d'une base de données et déplacement des fichiers
L'exemple suivant restaure une sauvegarde complète de la base de données et déplace la base de données restaurée vers le répertoire C:\Program Files\Microsoft SQL Server\MSSQL12.MSSQLSERVER\MSSQL\Data.
-- 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)
Restauration jusqu'à une date et heure en utilisant STOPAT
L'exemple suivant restaure une base de données dans l'état où elle se trouvait à un moment donné et montre une opération de restauration.
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()
Voir aussi
Bonnes pratiques et résolution des problèmes liés à la sauvegarde SQL Server vers une URL
Sauvegarder et restaurer des bases de données système (SQL Server)