Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Importation et exportation de bases de données SQL Server à l'aide de la sauvegarde et de la restauration natives
Amazon RDS prend en charge les sauvegarde et restauration natives pour les bases de données Microsoft SQL Server à l'aide de fichiers de sauvegarde complète (fichiers .bak). Lorsque vous utilisez RDS, vous accédez aux fichiers stockés dans Amazon S3 au lieu d'utiliser le système de fichiers local sur le serveur de base de données.
Par exemple, vous pouvez créer une sauvegarde complète depuis votre serveur local, la stocker sur S3, puis la restaurer sur une instance de base de données Amazon RDS existante. Vous pouvez également créer des sauvegardes à partir de RDS, les stocker sur S3, puis les restaurer chaque fois que vous le souhaitez.
La sauvegarde et la restauration natives sont disponibles dans toutes les AWS régions pour les instances de base de données mono-AZ et multi-AZ, y compris les instances de base de données multi-AZ avec des répliques de lecture. Les sauvegarde et restauration natives sont disponibles pour toutes les éditions de Microsoft SQL Server prises en charge sur Amazon RDS.
Le schéma suivant illustre les scénarios pris en charge.
![\[Architecture de sauvegarde et restauration natives\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/SQL-bak-file.png)
L'utilisation de fichiers .bak natifs pour sauvegarder et restaurer des bases de données est généralement le moyen le plus rapide de sauvegarder et de restaurer des bases de données. Il existe de nombreux avantages supplémentaires à l'utilisation des sauvegarde et restauration natives. Par exemple, vous pouvez effectuer les opérations suivantes :
+ Migrer des bases de données vers ou depuis Amazon RDS.
+ Déplacer des bases de données entre des instances de base de données RDS for SQL Server.
+ Migrer des données, des schémas, des procédures stockées, des déclencheurs et tout autre code de base de données dans des fichiers .bak.
+ Sauvegarder et restaurer des bases de données uniques, au lieu de la totalité d'instances de base de données.
+ Créer des copies de bases de données à des fins de développement, de test, de formation et de démonstration.
+ Stocker et transférer des fichiers de sauvegarde avec Amazon S3, pour offrir une couche de protection supplémentaire pour la reprise après sinistre.
+ Créez des sauvegardes natives de bases de données sur lesquelles Transparent Data Encryption (TDE) est activé, puis restaurez ces sauvegardes sur des bases de données sur site. Pour de plus amples informations, veuillez consulter [Prise en charge de Transparent Data Encryption dans SQL Server](Appendix.SQLServer.Options.TDE.md).
+ Restaurez les sauvegardes natives des bases de données sur site sur lesquelles TDE est activé sur des instances de base de données RDS for SQL Server. Pour de plus amples informations, veuillez consulter [Prise en charge de Transparent Data Encryption dans SQL Server](Appendix.SQLServer.Options.TDE.md).
**Contents**
+ [Limitations et recommandations](#SQLServer.Procedural.Importing.Native.Limitations)
+ [Configuration pour les sauvegarde et restauration natives](SQLServer.Procedural.Importing.Native.Enabling.md)
+ [Création manuelle d'un rôle IAM pour les sauvegarde et restauration natives](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM)
+ [Utilisation des sauvegarde et restauration natives](SQLServer.Procedural.Importing.Native.Using.md)
+ [Sauvegarde d'une base de données](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Backup)
+ [Usage](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Backup.Syntax)
+ [Exemples](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Backup.Examples)
+ [Restauration d'une base de données](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore)
+ [Usage](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Syntax)
+ [Exemples](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Examples)
+ [Restauration d'un journal](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log)
+ [Usage](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log.Syntax)
+ [Exemples](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log.Examples)
+ [Finalisation d'une restauration de base de données](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Finish.Restore)
+ [Usage](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Finish.Restore.Syntax)
+ [Utilisation de bases de données partiellement restaurées](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Partially.Restored)
+ [Suppression d'une base de données partiellement restaurée](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Drop.Partially.Restored)
+ [Comportement de restauration et point-in-time de restauration des instantanés pour les bases de données partiellement restaurées](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Snapshot.Restore)
+ [Annulation d'une tâche](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Cancel)
+ [Usage](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Cancel.Syntax)
+ [Suivi de l'état des tâches](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking)
+ [Usage](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Syntax)
+ [Exemples](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Examples)
+ [Réponse](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Response)
+ [Compression des fichiers de sauvegarde](SQLServer.Procedural.Importing.Native.Compression.md)
+ [Résolution des problèmes](SQLServer.Procedural.Importing.Native.Troubleshooting.md)
+ [Importation et exportation de données SQL Server à l'aide d'autres méthodes](SQLServer.Procedural.Importing.Snapshots.md)
+ [Importation de données dans RDS for SQL Server à l'aide d'un instantané](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Importing.Procedure)
+ [Importer les données](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.Import)
+ [Assistant de génération et de publication de scripts](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.ScriptWizard)
+ [Assistant d'importation et d'exportation](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.ImportExportWizard)
+ [Copie en bloc](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.BulkCopy)
+ [Exportation de données depuis RDS for SQL Server](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting)
+ [Assistant d'importation et d'exportation SQL Server](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting.SSIEW)
+ [Assistant Générer et publier des scripts et utilitaire bcp](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting.SSGPSW)
+ [Utilisation de l’utilitaire BCP dans Linux pour importer et exporter des données](SQLServer.Procedural.Importing.BCP.Linux.md)
+ [Prérequis](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Prerequisites)
+ [Installation des outils de ligne de commande SQL Server sur Linux](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Installing)
+ [Exportation de données depuis RDS for SQL Server](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting)
+ [Syntaxe d’exportation de base](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting.Basic)
+ [Exemple d’exportation](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting.Example)
+ [Importation de données vers RDS for SQL Server](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing)
+ [Syntaxe d’importation de base](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing.Basic)
+ [Exemple d’importation](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing.Example)
+ [Options BCP courantes](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Options)
+ [Bonnes pratiques et considérations](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.BestPractices)
+ [Dépannage des problèmes courants](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Troubleshooting)
## Limitations et recommandations
Voici quelques limitations quant à l'utilisation des sauvegarde et restauration natives :
+ Vous ne pouvez pas effectuer de sauvegarde ou de restauration depuis un compartiment Amazon S3 situé dans une AWS région différente de celle de votre instance de base de données Amazon RDS.
+ Vous ne pouvez pas restaurer une base de données qui porte le même nom qu'une base de données existante. Les noms de base de données sont uniques.
+ Nous vous recommandons vivement de ne pas restaurer de fichiers de sauvegarde d'un fuseau horaire dans un autre fuseau horaire. Si vous restaurez des sauvegardes d'un fuseau horaire dans un autre, vous devez auditer vos requêtes et vos applications afin de déterminer les effets du changement de fuseau horaire.
+ RDS pour Microsoft SQL Server possède une limite de taille de 5 To par fichier. Pour les sauvegardes natives de bases de données plus volumineuses, vous pouvez utiliser la sauvegarde multifichier.
+ La taille maximale de la base de données pouvant être sauvegardée sur S3 dépend de la mémoire disponible, du processeur, des I/O et des ressources réseau sur l'instance de base de données. Plus la base de données est grande, plus l'agent de sauvegarde consomme de la mémoire.
+ Vous ne pouvez pas effectuer une sauvegarde ou une restauration à partir de plus de 10 fichiers de sauvegarde simultanément.
+ Une sauvegarde différentielle est basée sur la dernière sauvegarde complète. Pour que les sauvegardes différentielles fonctionnent, vous ne pouvez prendre un instantané entre la dernière sauvegarde complète et la sauvegarde différentielle. Si vous souhaitez faire une sauvegarde différentielle, mais qu'il existe un instantané manuel ou automatique, créez une autre sauvegarde complète avant de créer la sauvegarde différentielle.
+ Les restaurations différentielles et de journaux ne sont pas prises en charge pour les bases de données possédant des fichiers dont l'identifiant unique file\$1guid est défini sur `NULL`.
+ Vous pouvez exécuter jusqu'à deux tâches de sauvegarde ou restauration simultanément.
+ Vous ne pouvez pas effectuer de sauvegardes natives de journaux à partir de SQL Server sur Amazon RDS.
+ RDS prend en charge les restaurations natives des bases de données allant jusqu’à 64 Tio. Les restaurations natives des bases de données sur SQL Server Express Edition sont limitées à 10 Go.
+ Vous ne pouvez pas sauvegarder une base de données pendant la fenêtre de maintenance, ou à tout moment où Amazon RDS prend un instantané de la base de données. Si une tâche de sauvegarde native se chevauche avec la fenêtre de sauvegarde quotidienne RDS, la tâche de sauvegarde native est annulée.
+ Sur des instances de base de données multi-AZ, vous pouvez uniquement restaurer nativement des bases de données sauvegardées en utilisant le modèle de restauration « Full ».
+ L'appel des procédures RDS pour la sauvegarde/restauration au sein d'une transaction n'est pas pris en charge.
+ Utilisez un chiffrement symétrique AWS KMS key pour chiffrer vos sauvegardes. Amazon RDS ne prend pas en charge les clés KMS asymétriques. Pour plus d'informations, consultez [Création de clés KMS de chiffrement symétriques](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) dans le *Guide du développeur AWS Key Management Service *.
+ Les fichiers de sauvegarde natifs sont chiffrés avec la clé KMS spécifiée à l'aide du mode cryptographique « Chiffrement seul ». Lorsque vous restaurez des fichiers de sauvegarde chiffrés, gardez à l'esprit qu'ils ont été chiffrés à l'aide du mode cryptographique « Chiffrement seul ».
+ Vous ne pouvez pas restaurer une base de données contenant un groupe de fichiers FILESTREAM.
+ Le chiffrement côté serveur Amazon S3 avec AWS KMS (SSE-KMS) est pris en charge par le biais de la configuration de chiffrement par défaut de votre compartiment S3 lorsque vous passez `@enable_bucket_default_encryption=1` à la procédure stockée de sauvegarde. Par défaut, la restauration prend en charge le chiffrement côté serveur de l'objet S3.
Lorsque vous fournissez une clé KMS à une procédure stockée, toutes les sauvegardes et restaurations natives sont chiffrées et déchiffrées côté client à l'aide de la clé KMS. AWS stocke les sauvegardes dans le compartiment S3 avec SSE-S3 quand `@enable_bucket_default_encryption=0` ou avec la clé de chiffrement par défaut configurée de votre compartiment S3 quand. `@enable_bucket_default_encryption=1`
+ Lorsque vous utilisez des points d'accès S3, le point d'accès ne peut pas être configuré pour utiliser un VPC interne RDS.
+ Pour des performances optimales, nous vous recommandons d'utiliser des compartiments de répertoire ou des points d'accès pour les compartiments d'annuaire s'ils sont disponibles dans votre région.
Nous vous recommandons d'utiliser les sauvegarde et restauration natives pour migrer votre base de données vers RDS si votre base de données peut être hors connexion pendant que le fichier de sauvegarde est créé, copié et restauré. Si votre base de données locale ne peut pas être hors ligne, nous vous recommandons d'utiliser le AWS Database Migration Service pour migrer votre base de données vers Amazon RDS. Pour plus d'informations, voir [Qu'est-ce que c'est AWS Database Migration Service ?](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)
Les sauvegarde et restauration natives ne visent pas à remplacer les fonctionnalités de récupération des données de la fonction de copie d'instantané entre régions. Nous vous recommandons d'utiliser la copie instantanée pour copier l'instantané de votre base de données dans une autre AWS région afin de permettre une reprise après sinistre entre régions sur Amazon RDS. Pour de plus amples informations, veuillez consulter [Copie d’un instantané de base de données pour Amazon RDS](USER_CopySnapshot.md).
# Configuration pour les sauvegarde et restauration natives
Pour configurer la sauvegarde et la restauration natives, vous avez besoin de trois composants :
1. Un compartiment Amazon S3 pour stocker vos fichiers de sauvegarde.
Vous devez disposer d'un compartiment S3 pour vos fichiers de sauvegarde et charger les sauvegardes que vous souhaitez migrer vers RDS. Si vous avez déjà un compartiment Amazon S3, vous pouvez l'utiliser. Si vous n'en avez pas, vous pouvez en [créer un](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html). Sinon, vous pouvez choisir d'avoir un compartiment créé pour vous quand vous ajoutez l'option `SQLSERVER_BACKUP_RESTORE` à l'aide de AWS Management Console.
Pour obtenir des informations sur l'utilisation de S3, consultez le [Guide de l'utilisateur Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/)
1. Rôle Gestion des identités et des accès AWS (IAM) permettant d'accéder au compartiment.
Si vous avez déjà un rôle IAM, vous pouvez l'utiliser. Vous pouvez choisir d'avoir un nouveau rôle IAM créé pour vous quand vous ajoutez l'option `SQLSERVER_BACKUP_RESTORE` à l'aide de la AWS Management Console. Vous pouvez également en créer un nouveau manuellement.
Si vous souhaitez créer un nouveau rôle IAM manuellement, optez pour l'approche abordée à la section suivante. Faites de même si vous souhaitez associer des relations d'approbation et des stratégies d'autorisations à un rôle IAM existant.
1. L'option `SQLSERVER_BACKUP_RESTORE` ajoutée à un groupe d'options sur votre instance de base de données.
Pour activer les sauvegarde et restauration natives sur votre instance de base de données, vous ajoutez l'option `SQLSERVER_BACKUP_RESTORE` à un groupe d'options sur votre instance de base de données. Pour plus d'informations et des instructions, consultez [Prise en charge des sauvegarde et restauration natives dans SQL Server](Appendix.SQLServer.Options.BackupRestore.md).
## Création manuelle d'un rôle IAM pour les sauvegarde et restauration natives
Si vous souhaitez créer manuellement un rôle IAM à utiliser avec une sauvegarde native et à restaurer, vous pouvez le faire. Dans ce cas, vous créez un rôle pour déléguer des autorisations depuis le service Amazon RDS vers votre compartiment Amazon S3. Lorsque vous créez un rôle IAM, vous attachez une relation d'approbation et une stratégie d'autorisation. La relation d'approbation permet à RDS d'assumer ce rôle. La politique d'autorisation définit les actions que ce rôle peut exécuter. Pour plus d'informations sur la création d'un rôle, consultez [Création d'un rôle pour déléguer des autorisations à un service AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html).
Pour la fonction de sauvegarde et restauration native, utilisez des relations d'approbation et des stratégies d'autorisation similaires aux exemples de cette section. Dans l'exemple suivant, nous utilisons le nom principal de service `rds.amazonaws.com` comme alias de tous les comptes de service. Dans les autres exemples, nous spécifions un ARN (Amazon Resource Name) pour identifier un autre compte, utilisateur ou rôle auquel nous accordons l'accès dans la stratégie d'approbation.
Nous vous recommandons d’utiliser les clés de contexte de condition globale [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) et [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) dans des relations d’approbation basées sur les ressources pour limiter les autorisations du service à une ressource spécifique. C’est le moyen le plus efficace de se protéger contre le [problème du député confus](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html).
Vous pouvez utiliser les deux clés de contexte de condition globale et faire en sorte que la valeur `aws:SourceArn` contienne l'ID de compte. Dans ce cas, la valeur `aws:SourceAccount` et le compte dans la valeur `aws:SourceArn` doivent utiliser le même ID de compte lorsqu'ils sont utilisés dans la même instruction.
+ Utilisez `aws:SourceArn` si vous souhaitez un accès interservices pour une seule ressource.
+ Utilisez `aws:SourceAccount` si vous souhaitez autoriser une ressource de ce compte à être associée à l’utilisation interservices.
Dans la relation d'approbation, assurez-vous d'utiliser la clé de contexte de condition globale `aws:SourceArn` avec l'ARN complet des ressources qui accèdent au rôle. Pour la sauvegarde et la restauration natives, veillez à inclure à la fois le groupe d'options de base de données et les instances de base de données, comme indiqué dans l'exemple suivant.
**Example de la relation d’approbation avec clé de contexte de condition globale pour la sauvegarde et la restauration natives**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceArn": [
"arn:aws:rds:Region:0123456789:db:db_instance_identifier",
"arn:aws:rds:Region:0123456789:og:option_group_name"
],
"aws:SourceAccount": "0123456789"
}
}
}
]
}
```
L'exemple suivant utilise un ARN pour spécifier une ressource. Pour plus d'informations sur l'utilisationARNs, consultez [Amazon resource names (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
**Example de la politique d’autorisation pour la sauvegarde et la restauration natives sans prise en charge du chiffrement**
****
```
{
"Version":"2012-10-17",
"Statement":
[
{
"Effect": "Allow",
"Action":
[
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Effect": "Allow",
"Action":
[
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
**Example politique d'autorisation pour la sauvegarde et la restauration natives avec prise en charge du chiffrement**
Si vous souhaitez chiffrer vos fichiers de sauvegarde, incluez une clé de chiffrement dans votre stratégie d'autorisation. Pour en savoir plus sur les clés de chiffrement, consultez [Mise en route](https://docs.aws.amazon.com/kms/latest/developerguide/getting-started.html) dans le *Manuel du développeur AWS Key Management Service *.
Vous devez utiliser une clé KMS de chiffrement symétrique pour chiffrer vos sauvegardes. Amazon RDS ne prend pas en charge les clés KMS asymétriques. Pour plus d'informations, consultez [Création de clés KMS de chiffrement symétriques](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) dans le *Guide du développeur AWS Key Management Service *.
Le rôle IAM doit également être un utilisateur de clé et un administrateur de clé pour la clé KMS, c'est-à-dire qu'il doit être spécifié dans la stratégie de clé. Pour plus d'informations, consultez [Création de clés KMS de chiffrement symétriques](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) dans le *Guide du développeur AWS Key Management Service *.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAccessToKey",
"Effect": "Allow",
"Action": [
"kms:DescribeKey",
"kms:GenerateDataKey",
"kms:Encrypt",
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-1:123456789012:key/key-id"
},
{
"Sid": "AllowAccessToS3",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Sid": "GetS3Info",
"Effect": "Allow",
"Action": [
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
**Example politique d'autorisations pour la sauvegarde et la restauration natives à l'aide de points d'accès sans support de chiffrement**
Les actions requises pour utiliser les points d'accès S3 sont les mêmes que pour les compartiments S3. Le chemin de ressource est mis à jour pour correspondre au modèle ARN du point d'accès S3.
Les points d'accès doivent être configurés pour utiliser l'**origine du réseau : Internet**, car RDS ne publie pas en mode privé VPCs. Le trafic S3 provenant des instances RDS ne passe pas par l'Internet public puisqu'il passe par le réseau privé VPCs.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:us-east-1:111122223333:accesspoint/amzn-s3-demo-ap",
"arn:aws:s3:::underlying-bucket"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": [
"arn:aws:s3:us-east-1:111122223333:accesspoint/amzn-s3-demo-ap/*",
"arn:aws:s3:::underlying-bucket/*"
]
}
]
}
```
**Example politique d'autorisations pour la sauvegarde et la restauration natives à l'aide de points d'accès pour les compartiments de répertoire sans support de chiffrement**
Les compartiments d'annuaire utilisent un [mécanisme d'autorisation basé sur les sessions différent de celui des compartiments à usage général. La seule autorisation](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-authenticating-authorizing.html) requise pour la restauration de sauvegarde native est donc l'autorisation « s3express : » au niveau du compartiment. CreateSession Pour configurer l'accès au niveau des objets, vous devez utiliser des [points d'accès pour les compartiments de répertoire](https://docs.aws.amazon.com//AmazonS3/latest/userguide/access-points-directory-buckets-policies.html).
Les points d'accès doivent être configurés pour utiliser l'**origine du réseau : Internet**, car RDS ne publie pas en mode privé VPCs. Le trafic S3 provenant des instances RDS ne passe pas par l'Internet public puisqu'il passe par le réseau privé VPCs.
****
```
{
"Version":"2012-10-17",
"Statement":
[
{
"Effect": "Allow",
"Action": "s3express:CreateSession",
"Resource":
[
"arn:aws:s3express:us-east-1:111122223333:accesspoint/amzn-s3-demo-accesspoint--use1-az6--xa-s3",
"arn:aws:s3express:us-east-1:111122223333:bucket/amzn-s3-demo-bucket--use1-az6--x-s3"
]
}
]
}
```
# Utilisation des sauvegarde et restauration natives
Une fois que vous avez activé et configuré les sauvegarde et restauration natives, vous pouvez commencer à les utiliser. Tout d'abord, vous vous connectez à votre base de données Microsoft SQL Server, puis vous appelez une procédure stockée Amazon RDS pour faire le travail. Pour plus d'informations sur la connexion à votre base de données, consultez [Connexion à votre instance de base de données Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
Certaines procédures stockées nécessitent que vous fournissiez un Amazon Resource Name (ARN) à votre compartiment et votre fichier Amazon S3. Le format pour votre ARN est `arn:aws:s3:::bucket_name/file_name.extension`. Amazon S3 n'a pas besoin de numéro de compte ni de AWS région dans ARNs.
Si vous fournissez également une clé KMS facultative, le format de l'ARN de la clé est `arn:aws:kms:region:account-id:key/key-id`. Pour plus d'informations, consultez les [noms des ressources Amazon (ARNs) et les espaces de noms des AWS services](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html). Vous devez utiliser une clé KMS de chiffrement symétrique pour chiffrer vos sauvegardes. Amazon RDS ne prend pas en charge les clés KMS asymétriques. Pour plus d'informations, consultez [Création de clés KMS de chiffrement symétriques](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) dans le *Guide du développeur AWS Key Management Service *.
**Note**
Que vous utilisiez ou non une clé KMS, les tâches de sauvegarde et de restauration natives activent le chiffrement AES (Advanced Encryption Standard) 256 bits côté serveur via SSE-S3 par défaut pour les fichiers téléchargés sur S3. Le passage `@enable_bucket_default_encryption=1` à la procédure stockée de sauvegarde utilise la clé de chiffrement par défaut configurée dans votre compartiment S3.
Pour plus d’informations sur la façon d’appeler chaque procédure stockée, consultez les rubriques suivantes :
+ [Sauvegarde d'une base de données](#SQLServer.Procedural.Importing.Native.Using.Backup)
+ [Restauration d'une base de données](#SQLServer.Procedural.Importing.Native.Using.Restore)
+ [Restauration d'un journal](#SQLServer.Procedural.Importing.Native.Restore.Log)
+ [Finalisation d'une restauration de base de données](#SQLServer.Procedural.Importing.Native.Finish.Restore)
+ [Utilisation de bases de données partiellement restaurées](#SQLServer.Procedural.Importing.Native.Partially.Restored)
+ [Annulation d'une tâche](#SQLServer.Procedural.Importing.Native.Using.Cancel)
+ [Suivi de l'état des tâches](#SQLServer.Procedural.Importing.Native.Tracking)
## Sauvegarde d'une base de données
Pour sauvegarder votre base de données, utilisez la procédure stockée `rds_backup_database`.
**Note**
Vous ne pouvez pas sauvegarder une base de données pendant la fenêtre de maintenance ou lorsqu'Amazon RDS prend un instantané.
### Usage
```
exec msdb.dbo.rds_backup_database
@source_db_name='database_name',
@s3_arn_to_backup_to='arn:aws:s3:::bucket_name/file_name.extension',
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@overwrite_s3_backup_file=0|1],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n],
[@type='DIFFERENTIAL|FULL'],
[@number_of_files=n],
[@enable_bucket_default_encryption=0|1];
```
Les paramètres suivants sont obligatoires :
+ `@source_db_name` – Nom de la base de données à sauvegarder.
+ `@s3_arn_to_backup_to`— L'ARN indiquant le compartiment Amazon S3, le point d'accès, le compartiment de répertoire ou le point d'accès du compartiment de répertoire à utiliser pour la sauvegarde, ainsi que le nom du fichier de sauvegarde.
Le fichier peut avoir n'importe quelle extension mais `.bak` est généralement utilisée. Notez que le point d'accès ARNs doit être au format`arn:aws:s3:us-east-1:111122223333:access-point-name/object/key`.
Les paramètres suivants sont facultatifs :
+ `@kms_master_key_arn` – ARN de la clé KMS de chiffrement symétrique à utiliser pour chiffrer l'élément.
+ Vous ne pouvez pas utiliser la clé de chiffrement par défaut. Si vous utilisez la clé par défaut, la base de données n'est pas sauvegardée.
+ Si vous ne spécifiez pas d’identifiant de clé KMS, le fichier de sauvegarde n’est pas chiffré. Pour plus d’informations, consultez [Chiffrer des ressources Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html).
+ Lorsque vous spécifiez une clé KMS, le chiffrement côté client est utilisé.
+ Amazon RDS ne prend pas en charge les clés KMS asymétriques. Pour plus d'informations, consultez [Création de clés KMS de chiffrement symétriques](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) dans le *Guide du développeur AWS Key Management Service *.
+ `@overwrite_s3_backup_file` – Une valeur qui indique si un fichier de sauvegarde existant doit être écrasé.
+ `0` – N'écrase pas un fichier existant. Cette valeur est celle par défaut.
Si `@overwrite_s3_backup_file` est défini sur 0, une erreur est retournée si le fichier existe déjà.
+ `1` – Écrase le fichier existant qui possède déjà le nom spécifié, même s'il ne s'agit pas d'un fichier de sauvegarde.
+ `@type` – Le type de sauvegarde.
+ `DIFFERENTIAL` – Crée une sauvegarde différentielle.
+ `FULL` – Crée une sauvegarde complète. Cette valeur est celle par défaut.
Une sauvegarde différentielle est basée sur la dernière sauvegarde complète. Pour que les sauvegardes différentielles fonctionnent, vous ne pouvez prendre un instantané entre la dernière sauvegarde complète et la sauvegarde différentielle. Si vous souhaitez faire une sauvegarde différentielle, mais qu'il existe un instantané, alors créez une autre sauvegarde complète avant de créer la sauvegarde différentielle.
Vous pouvez rechercher la dernière sauvegarde complète ou le dernier instantané à l'aide de l'exemple de requête SQL suivant :
```
select top 1
database_name
, backup_start_date
, backup_finish_date
from msdb.dbo.backupset
where database_name='mydatabase'
and type = 'D'
order by backup_start_date desc;
```
+ `@number_of_files` – Nombre de fichiers dans lesquels la sauvegarde sera divisée (en morceaux). Le nombre maximum est de 10.
+ La sauvegarde en plusieurs fichiers est prise en charge pour les sauvegardes complètes et différentielles.
+ Si vous entrez la valeur 1 ou omettez le paramètre, un seul fichier de sauvegarde est créé.
Fournissez le préfixe que les fichiers ont en commun, puis ajoutez un astérisque comme suffixe (`*`). L'astérisque peut se trouver n'importe où dans la *file\$1name* partie de l'ARN S3. L'astérisque est remplacé par une série de chaînes alphanumériques dans les fichiers générés, en commençant par `1-of-number_of_files`.
Par exemple, si les noms de fichiers dans l'ARN S3 ont pour modèle `backup*.bak` et que vous définissez `@number_of_files=4`, les fichiers de sauvegarde générés auront pour noms `backup1-of-4.bak`, `backup2-of-4.bak`, `backup3-of-4.bak` et `backup4-of-4.bak`.
+ Si l'un des noms de fichier existe déjà et que `@overwrite_s3_backup_file` a pour valeur 0, une erreur est renvoyée.
+ Les sauvegardes multifichiers ne peuvent comporter qu'un seul astérisque dans la *file\$1name* partie de l'ARN S3.
+ Les sauvegardes à fichier unique peuvent comporter un certain nombre d'astérisques dans la *file\$1name* partie de l'ARN S3. Les astérisques ne sont pas supprimés du nom de fichier généré.
+ `@block_size` : taille de bloc (en octets) spécifiant la taille de bloc physique pour les opérations de sauvegarde. Les valeurs valides sont 512, 1024, 2048, 4096, 8192, 16384, 32768 et 65536.
+ `@max_transfer_size`— La taille de transfert maximale indique la limite supérieure du volume de données (en octets) transmis par I/O opération pendant le processus de sauvegarde. Les valeurs valides sont des multiples de 65 536 octets (64 Ko) jusqu’à 4 194 304 octets (4 Mo).
+ `@buffer_count`— Nombre total de I/O tampons à utiliser pour le processus de sauvegarde.
+ `@enable_bucket_default_encryption`— Une valeur qui indique s'il faut utiliser la configuration de chiffrement par défaut du compartiment S3 pour le chiffrement côté serveur dans S3. Les compartiments de répertoire utilisent toujours la configuration de chiffrement par défaut du compartiment, quel que soit ce paramètre.
+ `0`— Le chiffrement côté serveur utilise le chiffrement AES (Advanced Encryption Standard) 256 bits via SSE-S3.
+ `1`— Le chiffrement côté serveur utilise le chiffrement [par défaut](https://docs.aws.amazon.com//AmazonS3/latest/userguide/bucket-encryption.html) configuré dans votre compartiment S3.
### Exemples
**Example de sauvegarde différentielle**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup1.bak',
@overwrite_s3_backup_file=1,
@type='DIFFERENTIAL';
```
**Example de sauvegarde complète avec chiffrement côté client**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup1.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE',
@overwrite_s3_backup_file=1,
@type='FULL';
```
**Example de sauvegarde sur plusieurs fichiers**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=4;
```
**Example de sauvegarde différentielle sur plusieurs fichiers**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@type='DIFFERENTIAL',
@number_of_files=4;
```
**Example de sauvegarde sur plusieurs fichiers avec chiffrement**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE',
@number_of_files=4;
```
**Example de sauvegarde sur plusieurs fichiers avec écrasement S3**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@overwrite_s3_backup_file=1,
@number_of_files=4;
```
**Example de sauvegarde avec taille de bloc**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@block_size=512;
```
**Example de sauvegarde sur plusieurs fichiers avec `@max_transfer_size` et `@buffer_count`**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=4,
@max_transfer_size=4194304,
@buffer_count=10;
```
**Example de sauvegarde en un seul fichier avec le paramètre @number\$1of\$1files**
Cet exemple génère un fichier de sauvegarde nommé `backup*.bak`.
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=1;
```
**Example de sauvegarde complète avec chiffrement côté serveur**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@overwrite_s3_backup_file=1,
@type='FULL',
@enable_bucket_default_encryption=1;
```
**Example d'une sauvegarde complète à l'aide d'un point d'accès**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/object/backup1.bak',
@overwrite_s3_backup_file=1,
@type='FULL';
```
**Example d'une sauvegarde complète à l'aide d'un point d'accès pour un bucket de répertoire**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3express:us-east-1:123456789012:accesspoint/my-access-point--use1-az6--xa-s3/object/backup1.bak',
@overwrite_s3_backup_file=1,
@type='FULL';
```
## Restauration d'une base de données
Pour restaurer votre base de données, appelez la procédure stockée `rds_restore_database`. Amazon RDS crée un instantané initial de la base de données après la fin de la tâche de restauration et l'ouverture de la base de données.
### Usage
```
exec msdb.dbo.rds_restore_database
@restore_db_name='database_name',
@s3_arn_to_restore_from='arn:aws:s3:::bucket_name/file_name.extension',
@with_norecovery=0|1,
[@keep_cdc=0|1],
[@data_file_volume='D:|H:|I:|J:'],
[@log_file_volume='D:|H:|I:|J:'],
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n],
[@type='DIFFERENTIAL|FULL'];
```
Les paramètres suivants sont obligatoires :
+ `@restore_db_name` – Nom de la base de données à restaurer. Les noms de base de données sont uniques. Vous ne pouvez pas restaurer une base de données qui porte le même nom qu'une base de données existante.
+ `@s3_arn_to_restore_from` – L'ARN indique le préfixe Amazon S3 et les noms des fichiers de sauvegarde utilisés pour restaurer la base de données.
+ Pour une seule sauvegarde de fichier, fournissez la totalité du nom du fichier.
+ Pour une sauvegarde comportant plusieurs fichiers, fournissez le préfixe que les fichiers ont en commun, puis ajoutez un astérisque comme suffixe (`*`).
+ Si vous utilisez un compartiment de répertoire, l'ARN doit se terminer par `/*` en raison des [différences entre les compartiments de répertoire](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-differences.html).
+ Si `@s3_arn_to_restore_from` est vide, le message d'erreur suivant est renvoyé : Le préfixe de l'ARN S3 ne peut pas être vide.
Le paramètre suivant est obligatoire pour les différentes restaurations, mais facultatifs pour les restaurations complètes :
+ `@with_norecovery` – La clause de restauration à utiliser pour l'opération de restauration.
+ Définissez le paramètre sur `0` pour restaurer avec RECOVERY (RESTAURATION). Dans ce cas, la base de données est en ligne après la restauration.
+ Définissez le paramètre sur `1` pour restaurer avec NORECOVERY (SANS RESTAURATION). Dans ce cas, la base de données reste à l'état RESTORING (EN COURS DE RESTAURATION) après la fin de la tâche de restauration. Grâce à cette approche, vous pouvez procéder à des restaurations différentielles ultérieurement.
+ Pour les restaurations DIFFÉRENTIELLES, spécifiez `0` ou `1`.
+ Pour les restaurations `FULL`, cette valeur par défaut est `0`.
Les paramètres suivants sont facultatifs :
+ `@keep_cdc`— Indique s'il faut conserver la configuration Change Data Capture (CDC) sur la base de données restaurée. Définissez sur pour `1` activer KEEP\$1CDC, `0` pour le désactiver. La valeur par défaut est `0`.
+ `@data_file_volume`— Spécifie la lettre du lecteur pour les fichiers de données de base de données. La valeur par défaut est `D:`.
+ `@log_file_volume`— Spécifie la lettre du lecteur pour les fichiers journaux de base de données. La valeur par défaut est`D:`.
+ `@kms_master_key_arn` – Clé KMS à utiliser pour déchiffrer le fichier si vous avez chiffré le fichier de sauvegarde.
Lorsque vous spécifiez une clé KMS, le chiffrement côté client est utilisé.
+ `@type` – Le type de restauration. Les types valides sont `DIFFERENTIAL` et `FULL`. La valeur par défaut est `FULL`.
+ `@block_size` : taille de bloc (en octets) spécifiant la taille de bloc physique pour les opérations de sauvegarde. Les valeurs valides sont 512, 1024, 2048, 4096, 8192, 16384, 32768 et 65536.
+ `@max_transfer_size`— La taille de transfert maximale indique la limite supérieure du volume de données (en octets) transmis par I/O opération pendant le processus de sauvegarde. Les valeurs valides sont des multiples de 65 536 octets (64 Ko) jusqu’à 4 194 304 octets (4 Mo).
+ `@buffer_count`— Nombre total de I/O tampons à utiliser pour le processus de sauvegarde.
**Note**
Pour les restaurations différentielles, la base de données doit se trouver en état RESTORING (EN COURS DE RESTAURATION) ou une tâche de restauration doit déjà exister avec NORECOVERY (SANS RESTAURATION).
Vous ne pouvez pas restaurer ultérieurement des sauvegardes différentielles tant que la base de données est en ligne.
Vous ne pouvez pas envoyer de tâche de restauration pour une base de données qui possède déjà une tâche de restauration en attente avec RECOVERY (RESTAURATION).
Les restaurations complètes avec NORECOVERY et KEEP\$1CDC ne sont pas prises en charge.
Toutes les restaurations natives ne sont pas prises en charge sur les instances dotées de répliques de lecture entre régions.
Pour les configurations prises en charge, la restauration d’une base de données sur une instance multi-AZ avec réplicas en lecture est similaire à la restauration d’une base de données sur une instance multi-AZ. Vous n'avez pas besoin d'effectuer d'actions supplémentaires pour restaurer une base de données sur un réplica.
### Exemples
**Example de restauration d'un seul fichier**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak';
```
**Example de restauration de plusieurs fichiers**
Pour éviter les erreurs lors de la restauration de plusieurs fichiers, assurez-vous que tous les fichiers de sauvegarde ont le même préfixe et qu'aucun autre fichier n'utilise ce préfixe.
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup*';
```
**Example de restauration de base de données complète avec RECOVERY (RESTAURATION)**
Les trois exemples suivants exécutent la même tâche de restauration complète avec RECOVERY (RESTAURATION).
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak';
```
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
[@type='DIFFERENTIAL|FULL'];
```
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='FULL',
@with_norecovery=0;
```
**Example de restauration de base de données complète avec chiffrement**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE';
```
**Example de restauration avec taille de bloc**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@block_size=512;
```
**Example de restauration multifichiers avec @max\$1transfer\$1size et @buffer\$1count**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup*',
@max_transfer_size=4194304,
@buffer_count=10;
```
**Example de restauration de base de données complète avec NORECOVERY (SANS RESTAURATION)**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='FULL',
@with_norecovery=1;
```
**Example de restauration différentielle avec NORECOVERY (SANS RESTAURATION)**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='DIFFERENTIAL',
@with_norecovery=1;
```
**Example de restauration différentielle avec RECOVERY (RESTAURATION).**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='DIFFERENTIAL',
@with_norecovery=0;
```
**Example de restauration complète de la base de données avec RECOVERY à l'aide d'un point d'accès**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/object/backup1.bak',
@with_norecovery=0;
```
**Example de restauration complète de la base de données avec KEEP\$1CDC**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@keep_cdc=1;
```
## Restauration d'un journal
Pour restaurer votre journal, appelez la procédure stockée `rds_restore_log`.
### Usage
```
exec msdb.dbo.rds_restore_log
@restore_db_name='database_name',
@s3_arn_to_restore_from='arn:aws:s3:::bucket_name/log_file_name.extension',
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@with_norecovery=0|1],
[@keep_cdc=0|1],
[@stopat='datetime'],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n];
```
Les paramètres suivants sont obligatoires :
+ `@restore_db_name` – Le nom de la base de données dont vous souhaitez restaurer le journal.
+ `@s3_arn_to_restore_from` – L'ARN indique le préfixe Amazon S3 et le nom du fichier journal utilisé pour restaurer le journal. Le fichier peut avoir n'importe quelle extension mais `.trn` est généralement utilisée.
Si `@s3_arn_to_restore_from` est vide, le message d'erreur suivant est renvoyé : Le préfixe de l'ARN S3 ne peut pas être vide.
Les paramètres suivants sont facultatifs :
+ `@keep_cdc`— Indique s'il faut conserver la configuration Change Data Capture (CDC) sur la base de données restaurée. Définissez sur 1 pour activer KEEP\$1CDC, 0 pour le désactiver. La valeur par défaut est 0.
+ `@kms_master_key_arn` – Clé KMS à utiliser pour déchiffrer le journal si vous avez chiffré le journal.
+ `@with_norecovery` – La clause de restauration à utiliser pour l'opération de restauration. La valeur par défaut est `1`.
+ Définissez le paramètre sur `0` pour restaurer avec RECOVERY (RESTAURATION). Dans ce cas, la base de données est en ligne après la restauration. Vous ne pouvez pas restaurer ultérieurement des sauvegardes de journaux tant que la base de données est en ligne.
+ Définissez le paramètre sur `1` pour restaurer avec NORECOVERY (SANS RESTAURATION). Dans ce cas, la base de données reste à l'état RESTORING (EN COURS DE RESTAURATION) après la fin de la tâche de restauration. Grâce à cette approche, vous pouvez procéder à des restaurations de journaux ultérieurement.
+ `@stopat` – Une valeur qui spécifie que la base de données est restaurée dans son état à la date et l'heure spécifiées (au format datetime). Seul les enregistrements de journaux de transaction écrits avant la date et l'heure spécifiées sont appliqués à la base de données.
Si ce paramètre n'est pas spécifié (il est NULL), le journal complet est restauré.
+ `@block_size` : taille de bloc (en octets) spécifiant la taille de bloc physique pour les opérations de sauvegarde. Les valeurs valides sont 512, 1024, 2048, 4096, 8192, 16384, 32768 et 65536.
+ `@max_transfer_size`— La taille de transfert maximale indique la limite supérieure du volume de données (en octets) transmis par I/O opération pendant le processus de sauvegarde. Les valeurs valides sont des multiples de 65 536 octets (64 Ko) jusqu’à 4 194 304 octets (4 Mo).
+ `@buffer_count`— Nombre total de I/O tampons à utiliser pour le processus de sauvegarde.
**Note**
Pour les restaurations de journaux, la base de données doit se trouver en état de restauration ou une tâche de restauration doit déjà exister avec NORECOVERY (SANS RESTAURATION).
Vous ne pouvez pas restaurer de sauvegardes de journaux tant que la base de données est en ligne.
Vous ne pouvez pas envoyer de tâche de restauration de journaux sur une base de données qui possède déjà une tâche de restauration en attente avec RECOVERY (RESTAURATION).
### Exemples
**Example de restaurations de journaux**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn';
```
**Example de restaurations de journaux avec chiffrement**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE';
```
**Example de restaurations de journaux avec NORECOVERY (SANS RESTAURATION)**
Les trois exemples suivants exécutent la même tâche de restauration de journaux avec NORECOVERY (SANS RESTAURATION).
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=1;
```
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn';
```
**Example de restauration avec taille de bloc**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@block_size=512;
```
**Example de restaurations de journaux avec RECOVERY (RESTAURATION)**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=0;
```
**Example de restaurations de journaux avec clause STOPAT**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=0,
@stopat='2019-12-01 03:57:09';
```
**Example de restauration du journal avec KEEP\$1CDC**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@keep_cdc=1;
```
## Finalisation d'une restauration de base de données
Si la dernière tâche de restauration sur la base de données a été exécutée à l'aide de `@with_norecovery=1`, la base de données est désormais en état RECOVERY (RESTAURATION). Ouvrez cette base de données pour exécuter des opérations normales à l'aide de la procédure stockée `rds_finish_restore`.
### Usage
```
exec msdb.dbo.rds_finish_restore @db_name='database_name';
```
**Note**
Pour utiliser cette approche, la base de données doit être en état RECOVERY (RESTAURATION) sans aucune tâche de restauration en attente.
Pour finaliser la restauration de la base de données, utilisez l'identifiant principal. Ou utilisez l'identifiant utilisateur qui a permis de restaurer récemment la base de données ou de se connecter avec NORECOVERY (SANS RESTAURATION).
## Utilisation de bases de données partiellement restaurées
### Suppression d'une base de données partiellement restaurée
Pour supprimer une base de données partiellement restaurée (laissée en état RECOVERY (RESTAURATION), utilisez la procédure stockée `rds_drop_database`.
```
exec msdb.dbo.rds_drop_database @db_name='database_name';
```
**Note**
Vous ne pouvez pas envoyer de demande de base de données DROP (SUPPRIMER) pour une base de données qui possède déjà une tâche de restauration en attente ou de finalisation de restauration.
Pour supprimer la base de données, utilisez l'identifiant principal. Ou utilisez l'identifiant utilisateur qui a permis de restaurer récemment la base de données ou de se connecter avec NORECOVERY (SANS RESTAURATION).
### Comportement de restauration et point-in-time de restauration des instantanés pour les bases de données partiellement restaurées
Les bases de données partiellement restaurées dans l'instance source (laissées dans l'état RESTORING) sont supprimées de l'instance cible lors de la restauration et de la point-in-time restauration des instantanés.
## Annulation d'une tâche
Pour annuler une tâche de sauvegarde ou de restauration, appelez la procédure stockée `rds_cancel_task`.
**Note**
Vous ne pouvez pas annuler une tâche FINISH\$1RESTORE.
### Usage
```
exec msdb.dbo.rds_cancel_task @task_id=ID_number;
```
Les paramètres suivants sont obligatoires :
+ `@task_id` – ID de la tâche à annuler. Vous pouvez obtenir l'ID de la tâche en appelant `rds_task_status`.
## Suivi de l'état des tâches
Pour suivre l'état de vos tâches de sauvegarde et restauration, appelez la procédure stockée `rds_task_status`. Si vous ne fournissez pas de paramètre, la procédure stockée retourne l'état de toutes les tâches. Le statut des tâches est mis à jour environ toutes les deux minutes. L'historique des tâches est conservé pendant 36 jours.
### Usage
```
exec msdb.dbo.rds_task_status
[@db_name='database_name'],
[@task_id=ID_number];
```
Les paramètres suivants sont facultatifs :
+ `@db_name` – Nom de la base de données pour laquelle afficher l'état de la tâche.
+ `@task_id` – ID de la tâche pour laquelle afficher l'état de tâche.
### Exemples
**Example de liste des statuts d'une tâche spécifique**
```
exec msdb.dbo.rds_task_status @task_id=5;
```
**Example de liste des statuts d'une base de données et d'une tâche spécifiques**
```
exec msdb.dbo.rds_task_status
@db_name='my_database',
@task_id=5;
```
**Example de liste de toutes les tâches et de leurs statuts sur une base de données spécifique**
```
exec msdb.dbo.rds_task_status @db_name='my_database';
```
**Example de liste de toutes les tâches et de leurs statuts sur l'instance actuelle**
```
exec msdb.dbo.rds_task_status;
```
### Réponse
La procédure stockée `rds_task_status` renvoie les colonnes suivantes.
****
| Colonne | Description |
| --- | --- |
| `task_id` | ID de la tâche |
| `task_type` | Le type de tâche dépend des paramètres d'entrée, comme suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) Amazon RDS crée un instantané initial de la base de données après son ouverture à la fin des tâches de restauration suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) |
| `database_name` | Nom de la base de données à laquelle est associée à la tâche. |
| `% complete` | La progression de la tâche sous forme de pourcentage. |
| `duration (mins)` | Temps consacré à la tâche, en minutes. |
| `lifecycle` | État de la tâche. Les statuts possibles sont les suivants : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) |
| `task_info` | Informations supplémentaires sur la tâche. Si une erreur se produit lors de la sauvegarde ou de la restauration d'une base de données, cette colonne contient des informations sur l'erreur. Pour obtenir une liste des erreurs possibles et des stratégies d'atténuation, consultez [Résolution des problèmes](SQLServer.Procedural.Importing.Native.Troubleshooting.md). |
| `last_updated` | Date et heure de la dernière mise à jour de l'état de la tâche. Le statut est mis à jour tous les 5 pour cent de progression. |
| `created_at` | Date et heure de création de la tâche. |
| S3\$1object\$1arn | L'ARN indique le préfixe Amazon S3 et le nom du fichier en cours de sauvegarde ou de restauration. |
| `overwrite_s3_backup_file` | Valeur du paramètre `@overwrite_s3_backup_file` spécifié lorsque vous appelez une tâche de sauvegarde. Pour de plus amples informations, veuillez consulter [Sauvegarde d'une base de données](#SQLServer.Procedural.Importing.Native.Using.Backup). |
| KMS\$1master\$1key\$1arn | L'ARN pour la clé KMS utilisée pour le chiffrement (pour la sauvegarde) et le déchiffrement (pour la restauration). |
| filepath | Non applicable aux tâches de sauvegarde et de restauration natives |
| overwrite\$1file | Non applicable aux tâches de sauvegarde et de restauration natives |
# Compression des fichiers de sauvegarde
Pour économiser de l'espace sur votre compartiment Amazon S3, vous pouvez compresser vos fichiers de sauvegarde. Pour plus d'informations sur la compression de fichiers de sauvegarde, consultez [Backup Compression (Compression de sauvegarde)](https://msdn.microsoft.com/en-us/library/bb964719.aspx) dans la documentation Microsoft.
La compression des fichiers sauvegardés est prise en charge pour les éditions de base de données suivantes :
+ Configurer SQL Server Enterprise Edition
+ Microsoft SQL Server Standard Edition
Pour vérifier l’option de compression de vos fichiers sauvegardés, exécutez le code suivant :
```
1. exec rdsadmin.dbo.rds_show_configuration 'S3 backup compression';
```
Pour activer la compression de vos fichiers sauvegardés, exécutez le code suivant :
```
1. exec rdsadmin.dbo.rds_set_configuration 'S3 backup compression', 'true';
```
Pour désactiver la compression de vos fichiers sauvegardés, exécutez le code suivant :
```
1. exec rdsadmin.dbo.rds_set_configuration 'S3 backup compression', 'false';
```
# Résolution des problèmes
Voici les problèmes que vous risquez de rencontrer lorsque vous utilisez la sauvegarde et la restauration natives.
****
| Problème | Suggestions de dépannage |
| --- | --- |
| L'option de sauvegarde/restauration de base de données n'est pas encore activée ou est en cours d'activation. Réessayez ultérieurement. | Vérifiez que vous avez ajouté l'option `SQLSERVER_BACKUP_RESTORE` au groupe d'options de base de données associé à votre instance de base de données. Pour plus d’informations, consultez [Ajout de l'option de sauvegarde et restauration natives](Appendix.SQLServer.Options.BackupRestore.md#Appendix.SQLServer.Options.BackupRestore.Add). |
| L’autorisation EXECUTE a été refusée sur l’objet « *rds\$1backup\$1database* », la base de données « msdb » et le schéma « dbo ». | Assurez-vous d’utiliser l’utilisateur principal lorsque vous exécutez la procédure stockée. Si vous rencontrez cette erreur même après avoir été connecté en tant qu’utilisateur principal, cela peut être dû à un mauvais alignement des autorisations de l’utilisateur administrateur. Pour réinitialiser l’utilisateur principal, utilisez la AWS Management Console. Consultez [Réinitialisation de l’appartenance au rôle db\$1owner pour Amazon RDS for SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md). |
| L’autorisation EXECUTE a été refusée sur l’objet « *rds\$1restore\$1database* », la base de données « msdb » et le schéma « dbo ». | Assurez-vous d’utiliser l’utilisateur principal lorsque vous exécutez la procédure stockée. Si vous rencontrez cette erreur même après avoir été connecté en tant qu’utilisateur principal, cela peut être dû à un mauvais alignement des autorisations de l’utilisateur administrateur. Pour réinitialiser l’utilisateur principal, utilisez la AWS Management Console. Consultez [Réinitialisation de l’appartenance au rôle db\$1owner pour Amazon RDS for SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md). |
| Accès refusé | Le processus de sauvegarde ou de restauration ne parvient pas à accéder au fichier de sauvegarde. Cela est généralement provoqué par des problèmes tels que : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Troubleshooting.html) |
| BACKUP DATABASE With COMPRESSION n'est pas pris en charge sur l’Édition | La compression des fichiers de sauvegarde est uniquement prise en charge pour Microsoft SQL Server Enterprise Edition. La Standard Edition. Pour plus d'informations, consultez [Compression des fichiers de sauvegarde](SQLServer.Procedural.Importing.Native.Compression.md). |
| La clé n'existe pas | Vous avez essayé de restaurer une sauvegarde chiffrée, mais n'avez pas fourni une clé de chiffrement valide. Vérifiez votre clé de chiffrement et réessayez. Pour plus d'informations, consultez [Restauration d'une base de données](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore). |
| Veuillez réémettre la tâche avec le type correct et remplacer la propriété | Si vous essayez de sauvegarder votre base de données et fournissez le nom d'un fichier qui existe déjà, mais que la propriété de remplacement est définie sur false, l'opération de sauvegarde échoue. Pour corriger cette erreur, entrez le nom d'un fichier qui n'existe pas déjà ou définissez la propriété de remplacement sur true. Pour plus d'informations, consultez [Sauvegarde d'une base de données](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Backup). Il est également possible qu'en tentant de restaurer votre base de données, vous ayez accidentellement appelé la procédure stockée `rds_backup_database`. Dans ce cas, appelez la procédure stockée `rds_restore_database` à la place. Pour plus d'informations, consultez [Restauration d'une base de données](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore). Si vous aviez pour but de restaurer votre base de données et avez appelé la procédure stockée `rds_restore_database`, assurez-vous que vous avez fourni le nom d'un fichier de sauvegarde valide. Pour plus d'informations, consultez [Utilisation des sauvegarde et restauration natives](SQLServer.Procedural.Importing.Native.Using.md). |
| Veuillez spécifier un compartiment qui se trouve dans la même région que l'instance RDS | Vous ne pouvez effectuer une sauvegarde vers, ou une restauration depuis, un compartiment Amazon S3 dans une région AWS autre que celle de votre instance de base de données Amazon RDS. Vous utilisez la réplication Amazon S3 pour copier le fichier de sauvegarde vers la bonne région AWS. Pour plus d'informations, consultez [Réplication entre régions](https://docs.aws.amazon.com/AmazonS3/latest/userguide/crr.html) dans la documentation Amazon S3. |
| Le compartiment spécifié n'existe pas | Vérifiez que vous avez fourni l'ARN correct pour votre compartiment et le fichier, dans le bon format. Pour plus d'informations, consultez [Utilisation des sauvegarde et restauration natives](SQLServer.Procedural.Importing.Native.Using.md). |
| L’utilisateur n’est pas autorisé à exécuter sur la ressource | Vous avez demandé à une opération chiffrée, mais n'avez pas fourni d'autorisations AWS KMS correctes. Vérifiez que vous avez les autorisations appropriées ou ajoutez-les. Pour plus d'informations, consultez [Configuration pour les sauvegarde et restauration natives](SQLServer.Procedural.Importing.Native.Enabling.md). |
| La tâche de restauration n'est pas en mesure de restaurer à partir de plus de 10 fichiers de sauvegarde). Veuillez réduire le nombre de fichiers correspondants et réessayer. | Réduisez le nombre de fichiers que vous utilisez pour la restauration. Si nécessaire, vous pouvez augmenter la taille de chaque fichier. |
| La base de données « *database\$1name* » existe déjà. Deux bases de données qui ne diffèrent que par la casse ou l'accentuation ne sont pas autorisées. Choisissez un nom de base de données différent. | Vous ne pouvez pas restaurer une base de données qui porte le même nom qu'une base de données existante. Les noms de base de données sont uniques. |
# Importation et exportation de données SQL Server à l'aide d'autres méthodes
Par la suite, vous trouverez des informations sur l'utilisation d'instantanés pour importer vos données Microsoft SQL Server vers Amazon RDS. Vous trouverez également des informations sur l'utilisation d'instantanés pour exporter vos données depuis une instance de base de données RDS exécutant SQL Server.
Si votre scénario le prend en charge, il est plus facile transférer des données vers et depuis Amazon RDS à l'aide de la fonctionnalité de sauvegarde et restauration natives. Pour plus d’informations, consultez [Importation et exportation de bases de données SQL Server à l'aide de la sauvegarde et de la restauration natives](SQLServer.Procedural.Importing.md).
**Note**
Amazon RDS for Microsoft SQL Server ne prend pas en charge l'importation de données dans la base de données `msdb`.
## Importation de données dans RDS for SQL Server à l'aide d'un instantané
**Pour importer des données dans une instance de base de données SQL Server à l'aide d'un instantané**
1. Créez une instance de base de données. Pour plus d'informations, consultez [Création d'une instance de base de données Amazon RDS](USER_CreateDBInstance.md).
1. Arrêtez l'accès des applications à l'instance de base de données de destination.
Si vous empêchez l'accès à votre instance de base de données pendant l'importation des données, le transfert de données est plus rapide. En outre, vous n'aurez plus à vous inquiéter de conflits pendant le chargement de données si d'autres applications ne peuvent pas écrire sur l'instance de base de données simultanément. En cas de problème, et si vous devez procéder à une restauration vers un instantané de base de données antérieur, les seules modifications que vous perdez sont les données importées. Vous pouvez importer à nouveau ces données après avoir résolu le problème.
Pour plus d'informations sur le contrôle de l'accès à votre instance de base de données, consultez [Contrôle d’accès par groupe de sécurité](Overview.RDSSecurityGroups.md).
1. Créez un instantané de la base de données cible.
Si la base de données cible contient déjà des données, nous vous recommandons de prendre un instantané de la base de données avant d'importer les données. En cas de problème d'importation des données ou si vous souhaitez ignorer les modifications, l'instantané vous permet de restaurer l'état précédent de la base de données. Pour plus d’informations sur les instantanés de base de données, consultez [Création d’un instantané de base de données pour une instance de base de données mono-AZ pour Amazon RDS](USER_CreateSnapshot.md).
**Note**
Lorsque vous prenez un instantané de base de données, les opérations I/O vers la base de données sont suspendues pendant un moment (millisecondes) pendant la progression de la sauvegarde.
1. Désactivez les sauvegardes automatiques sur la base de données cible.
La désactivation des sauvegardes automatiques sur l'instance de base de données cible améliore la performance pendant l'importation de vos données, car Amazon RDS ne consigne pas de transactions lorsque les sauvegardes automatiques sont désactivées. Cependant, certains éléments sont à prendre en compte. Les sauvegardes automatiques sont obligatoires pour exécuter une reprise ponctuelle. Ainsi, vous ne pouvez pas restaurer la base de données à un instant spécifique dans le passé tant que vous importez des données. En outre, toutes les sauvegardes automatiques qui ont été créées sur l'instance de base de données sont effacées à moins que vous choisissiez de les conserver.
Le choix de conserver les sauvegardes automatiques peut vous aider à vous protéger contre la suppression accidentelle de données. Amazon RDS enregistre également les propriétés de l'instance de base de données avec chaque sauvegarde automatique afin de faciliter la récupération. Cette option vous permet de restaurer une instance de base de données supprimée à un moment donné dans le cadre de la période de conservation des sauvegardes, y compris après sa suppression. Les sauvegardes automatisées sont automatiquement supprimées à la fin de la plage de sauvegarde spécifiée, comme pour une instance de base de données active.
Vous pouvez également utiliser des instantanés précédents pour récupérer la base de données. En outre, tous les instantanés que vous avez pris demeureront disponibles. Pour plus d'informations sur les sauvegardes automatiques, consultez [Présentation des sauvegardes](USER_WorkingWithAutomatedBackups.md).
1. Désactivez les contraintes de clé étrangère, le cas échéant.
Si vous avez besoin de désactiver des contraintes de clé étrangère, vous pouvez utiliser pour cela le script suivant.
```
--Disable foreign keys on all tables
DECLARE @table_name SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE table_cursor CURSOR FOR SELECT name FROM sys.tables;
OPEN table_cursor;
FETCH NEXT FROM table_cursor INTO @table_name;
WHILE @@FETCH_STATUS = 0 BEGIN
SELECT @cmd = 'ALTER TABLE '+QUOTENAME(@table_name)+' NOCHECK CONSTRAINT ALL';
EXEC (@cmd);
FETCH NEXT FROM table_cursor INTO @table_name;
END
CLOSE table_cursor;
DEALLOCATE table_cursor;
GO
```
1. Abandonnez les index, le cas échéant.
1. Désactivez les déclencheurs, le cas échéant.
Si vous avez besoin de désactiver des déclencheurs, vous pouvez utiliser pour cela le script suivant.
```
--Disable triggers on all tables
DECLARE @enable BIT = 0;
DECLARE @trigger SYSNAME;
DECLARE @table SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE trigger_cursor CURSOR FOR SELECT trigger_object.name trigger_name,
table_object.name table_name
FROM sysobjects trigger_object
JOIN sysobjects table_object ON trigger_object.parent_obj = table_object.id
WHERE trigger_object.type = 'TR';
OPEN trigger_cursor;
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
WHILE @@FETCH_STATUS = 0 BEGIN
IF @enable = 1
SET @cmd = 'ENABLE ';
ELSE
SET @cmd = 'DISABLE ';
SET @cmd = @cmd + ' TRIGGER dbo.'+QUOTENAME(@trigger)+' ON dbo.'+QUOTENAME(@table)+' ';
EXEC (@cmd);
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
END
CLOSE trigger_cursor;
DEALLOCATE trigger_cursor;
GO
```
1. Interrogez l'instance SQL Server source pour tous les ID de connexion que vous souhaitez importer dans l'instance de base de données de destination.
SQL Server stocke des ID de connexion et des mots de passe dans la base de données `master`. Du fait que Amazon RDS n'accorde pas l'accès à la base de données `master`, vous ne pouvez pas importer directement des ID de connexion et des mots de passe dans votre instance de base de données de destination. À la place, vous devez interroger la base de données `master` sur l'instance SQL Server source pour générer un fichier Langage de définition de données (DDL). Ce fichier doit inclure tous les identifiants et les mots de passe que vous souhaitez ajouter à l'instance de base de données de destination. Ce fichier doit également inclure des appartenances à un rôle et des autorisations que vous souhaitez transférer.
Pour en savoir plus sur la manière d’interroger la base de données `master`, consultez [Transfert de connexions et de mots de passe entre des instances de SQL Server](https://learn.microsoft.com/en-us/troubleshoot/sql/database-engine/security/transfer-logins-passwords-between-instances) dans la base de connaissances Microsoft.
Le résultat du script est un script que vous pouvez exécuter sur l'instance de base de données de destination. Le script dans l'article de base de connaissances comporte le code suivant :
```
p.type IN
```
Partout où `p.type` s'affiche, utilisez plutôt le code suivant :
```
p.type = 'S'
```
1. Importez les données à l'aide de la méthode dans [Importer les données](#ImportData.SQLServer.Import).
1. Accordez aux applications l'accès à l'instance de base de données cible.
Lorsque l'importation de vos données est terminée, vous pouvez accorder l'accès à l'instance de base de données aux applications que vous avez bloquées pendant l'importation. Pour plus d'informations sur le contrôle de l'accès à votre instance de base de données, consultez [Contrôle d’accès par groupe de sécurité](Overview.RDSSecurityGroups.md).
1. Activez les sauvegardes automatiques sur l'instance de base de données cible.
Pour plus d'informations sur les sauvegardes automatiques, consultez [Présentation des sauvegardes](USER_WorkingWithAutomatedBackups.md).
1. Activer les contraintes de clé étrangère.
Si vous avez désactivé les contraintes de clé étrangère précédemment, vous pouvez à présent les activer avec le script suivant.
```
--Enable foreign keys on all tables
DECLARE @table_name SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE table_cursor CURSOR FOR SELECT name FROM sys.tables;
OPEN table_cursor;
FETCH NEXT FROM table_cursor INTO @table_name;
WHILE @@FETCH_STATUS = 0 BEGIN
SELECT @cmd = 'ALTER TABLE '+QUOTENAME(@table_name)+' CHECK CONSTRAINT ALL';
EXEC (@cmd);
FETCH NEXT FROM table_cursor INTO @table_name;
END
CLOSE table_cursor;
DEALLOCATE table_cursor;
```
1. Activez les index, le cas échéant.
1. Activez les déclencheurs, le cas échéant.
Si vous avez désactivé les déclencheurs précédemment, vous pouvez à présent les activer avec le script suivant.
```
--Enable triggers on all tables
DECLARE @enable BIT = 1;
DECLARE @trigger SYSNAME;
DECLARE @table SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE trigger_cursor CURSOR FOR SELECT trigger_object.name trigger_name,
table_object.name table_name
FROM sysobjects trigger_object
JOIN sysobjects table_object ON trigger_object.parent_obj = table_object.id
WHERE trigger_object.type = 'TR';
OPEN trigger_cursor;
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
WHILE @@FETCH_STATUS = 0 BEGIN
IF @enable = 1
SET @cmd = 'ENABLE ';
ELSE
SET @cmd = 'DISABLE ';
SET @cmd = @cmd + ' TRIGGER dbo.'+QUOTENAME(@trigger)+' ON dbo.'+QUOTENAME(@table)+' ';
EXEC (@cmd);
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
END
CLOSE trigger_cursor;
DEALLOCATE trigger_cursor;
```
### Importer les données
Microsoft SQL Server Management Studio est un client SQL Server graphique qui est inclus dans toutes les éditions de Microsoft SQL Server, sauf Express Edition. SQL Server Management Studio Express est disponible auprès de Microsoft en téléchargement gratuit. Pour trouver ce téléchargement, consultez le [site Web de Microsoft](https://www.microsoft.com/en-us/download).
**Note**
SQL Server Management Studio Express est disponible uniquement en tant qu'application basée sur Windows.
SQL Server Management Studio inclut les outils suivants, qui sont utiles pour l'importation de données dans une instance de base de données SQL Server :
+ Assistant de génération et de publication de scripts
+ Assistant d'importation et d'exportation
+ Copie en bloc
#### Assistant de génération et de publication de scripts
L'assistant de génération et de publication de scripts crée un script qui contient le schéma d'une base de données, les données elles-mêmes, ou les deux. Vous pouvez générer un script pour une base de données dans votre déploiement SQL Server local. Vous pouvez ensuite exécuter le script pour transférer les informations qu'il contient vers une instance de base de données Amazon RDS.
**Note**
Pour les bases de données d'1 GiB ou plus, il est plus efficace de scripter uniquement le schéma de la base de données. Ensuite, vous utilisez l'assistant d'importation et d'exportation ou la fonctionnalité de copie en bloc de SQL Server pour transférer les données.
Pour plus d'informations sur l'assistant de génération et de publication de scripts, consultez la [documentation Microsoft SQL Server](http://msdn.microsoft.com/en-us/library/ms178078%28v=sql.105%29.aspx).
Dans l'assistant, prêtez une attention particulière aux options avancées sur la page **Set Scripting Options** (Définir les options de scripting) pour garantir que tout ce que vous souhaitez que votre script inclue soit sélectionné. Par exemple, par défaut, les déclencheurs de base de données ne sont pas inclus dans le script.
Lorsque le script est généré et enregistré, vous pouvez utiliser SQL Server Management Studio pour vous connecter à votre instance de base de données puis exécuter le script.
#### Assistant d'importation et d'exportation
L'assistant d'importation et d'exportation crée un package Integration Services spécial que vous pouvez utiliser pour copier des données depuis votre base de données SQL Server locale vers l'instance de base de données de destination. L'assistant peut filtrer les tables et même les tuples dans une table qui sont copiés vers l'instance de base de données de destination.
**Note**
L'assistant d'importation et d'exportation est efficace pour les jeux de données de grande taille, mais ce n'est peut-être pas la manière la plus rapide d'exporter des données à distance depuis votre déploiement local. Pour une manière encore plus rapide, envisagez la fonction de copie en bloc SQL Server.
Pour plus d'informations sur l'assistant d'importation et d'exportation, consultez la [ documentation Microsoft SQL Server](http://msdn.microsoft.com/en-us/library/ms140052%28v=sql.105%29.aspx).
Dans l'assistant, sur la page **Choose a Destination (Choisir une destination)**, procédez comme suit :
+ Pour **Server Name (Nom de serveur)**, saisissez le nom du point de terminaison pour votre instance de base de données.
+ Pour le mode d'authentification de serveur, sélectionnez **Use SQL Server Authentication (Utiliser l'authentification SQL Server)**.
+ Pour **Nom d'utilisateur** et **Mot de passe**, entrez les informations d'identification pour l'utilisateur principal que vous avez créé pour l'instance de base de données.
#### Copie en bloc
La fonction Copie en bloc de SQL Server est un moyen efficace de copier des données depuis une base de données source vers votre instance de base de données. La copie en bloc écrit les données que vous spécifiez vers un fichier de données, tel qu'un fichier ASCII. Vous pouvez ensuite exécuter à nouveau la copie en bloc pour écrire le contenu du fichier dans l'instance de base de données de destination.
Cette section utilise l'utilitaire **bcp** qui est inclus dans toutes les éditions de SQL Server. Pour plus d'informations sur les opérations d'importation et d'exportation en bloc, consultez [la documentation Microsoft SQL Server](http://msdn.microsoft.com/en-us/library/ms187042%28v=sql.105%29.aspx).
**Note**
Avant d'utiliser la copie en bloc, vous devez importer votre schéma de base de données vers l'instance de base de données de destination. L'assistant de génération et de publication de scripts, décrit plus tôt dans cette rubrique, est un excellent outil à cette fin.
La commande suivante se connecte à l'instance SQL Server locale. Elle génère un fichier délimité par des tabulations d'une table spécifique dans le répertoire racine C:\$1 de votre déploiement SQL Server existant. La table est spécifiée par son nom entièrement qualifié, et le fichier texte a le même nom que la table qui est copiée.
```
bcp dbname.schema_name.table_name out C:\table_name.txt -n -S localhost -U username -P password -b 10000
```
Le code précédent inclut les options suivantes :
+ `-n` spécifie que la copie en bloc utilise les types de données natifs des données à copier.
+ `-S` spécifie l'instance SQL Server à laquelle l'utilitaire *bcp* se connecte.
+ `-U` spécifie le nom d'utilisateur du compte qui se connecte à l'instance SQL Server.
+ `-P` spécifie le mot de passe pour l'utilisateur spécifié par `-U`.
+ `-b` spécifie le nombre de lignes par lot de données importées.
**Note**
Il peut exister d'autres paramètres qui sont importants pour votre situation d'importation. Par exemple, vous pouvez avoir besoin du paramètre `-E` qui concerne les valeurs d'identité. Pour plus d'informations, consultez la description complète de la syntaxe de ligne de commande pour l'utilitaire **bcp** dans la [documentation Microsoft SQL Server](http://msdn.microsoft.com/en-us/library/ms162802%28v=sql.105%29.aspx).
Prenons l'exemple d'une base de données nommée `store` qui utilise le schéma par défaut, `dbo`, et qui contient une table nommée `customers`. Le compte utilisateur `admin`, avec le mot de passe `insecure`, copie 10 000 lignes de la table `customers` dans un fichier nommé `customers.txt`.
```
bcp store.dbo.customers out C:\customers.txt -n -S localhost -U admin -P insecure -b 10000
```
Après avoir généré le fichier de données, vous pouvez charger les données sur votre instance de base de données à l'aide d'une commande similaire. Au préalable, créez la base de données et le schéma sur l'instance de base de données cible. Ensuite, utiliser l'argument `in` pour spécifier un fichier d'entrée au lieu de `out` pour spécifier un fichier de sortie. Au lieu d'utiliser l'hôte local pour spécifier l'instance SQL Server locale, vous spécifiez le point de terminaison de votre instance de base de données. Si vous utilisez un port autre que 1433, vous le spécifiez également. Le nom d'utilisateur et le mot de passe sont identiques à l'utilisateur principal et au mot de passe de votre instance de base de données. La syntaxe est la suivante.
```
bcp dbname.schema_name.table_name
in C:\table_name.txt -n -S endpoint,port -U master_user_name -P master_user_password -b 10000
```
Pour poursuivre l'exemple précédent, supposons que le nom d'utilisateur maître soit `admin`, et que le mot de passe soit `insecure`. Le point de terminaison pour l'instance de base de données est `rds.ckz2kqd4qsn1.us-east-1.rds.amazonaws.com`, et vous utilisez le port 4080. La commande est la suivante.
```
bcp store.dbo.customers in C:\customers.txt -n -S rds.ckz2kqd4qsn1.us-east-1.rds.amazonaws.com,4080 -U admin -P insecure -b 10000
```
**Note**
Spécifiez un mot de passe autre que celui indiqué ici, en tant que bonne pratique de sécurité.
## Exportation de données depuis RDS for SQL Server
Vous pouvez choisir l'une des options suivantes pour exporter des données à partir d'une instance de base de données RDS for SQL Server :
+ **Sauvegarde et restauration natives à l'aide d'un fichier de sauvegarde complète (.bak)** – L'utilisation de fichiers .bak pour sauvegarder des bases de données est fortement optimisée et constitue généralement le moyen le plus rapide d'exporter des données. Pour plus d'informations, consultez [Importation et exportation de bases de données SQL Server à l'aide de la sauvegarde et de la restauration natives](SQLServer.Procedural.Importing.md).
+ **Assistant d'importation et d'exportation SQL Server** – Pour en savoir plus, consultez [Assistant d'importation et d'exportation SQL Server](#SQLServer.Procedural.Exporting.SSIEW).
+ **Assistant de génération et de publication de scripts SQL Server et utilitaire bcp** – Pour en savoir plus, consultez [Assistant Générer et publier des scripts et utilitaire bcp](#SQLServer.Procedural.Exporting.SSGPSW).
### Assistant d'importation et d'exportation SQL Server
Vous pouvez utiliser l'assistant d'importation et d'exportation SQL Server pour copier une ou plusieurs tables, vues ou requêtes depuis votre instance de base de données RDS for SQL Server vers un autre magasin de données. Ce choix est le meilleur si le magasin de données cible n'est pas SQL Server. Pour plus d’informations, consultez la [Assistant d’importation et exportation SQL Server](http://msdn.microsoft.com/en-us/library/ms141209%28v=sql.110%29.aspx) dans la documentation Microsoft SQL Server.
L'assistant d'importation et d'exportation SQL Server est disponible dans le cadre de Microsoft SQL Server Management Studio. Ce client SQL Server graphique est inclus dans toutes les éditions de Microsoft SQL Server, sauf Express Edition. SQL Server Management Studio Express est disponible uniquement en tant qu'application basée sur Windows. SQL Server Management Studio Express est disponible auprès de Microsoft en téléchargement gratuit. Pour trouver ce téléchargement, consultez le [site Web de Microsoft](http://www.microsoft.com/en-us/search/Results.aspx?q=sql%20server%20management%20studio).
**Pour utiliser l'assistant d'importation et d'exportation SQL Server pour exporter des données**
1. Dans SQL Server Management Studio, connectez-vous à votre instance de base de données RDS for SQL Server. Pour plus d'informations sur la manière de procéder, consultez [Connexion à votre instance de base de données Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
1. Dans **Object Explorer (Navigateur d'objet)**, développez **Databases (Bases de données)**, ouvrez le menu contextuel (clic droit) pour la base de données source, et sélectionnez **Tasks (Tâches)**, puis **Export Data (Exporter des données)**. L'assistant s'affiche.
1. Sur la page **Choose a Data Source (Choisir une source de données)**, procédez comme suit :
1. Pour **Data source (Source de données)**, choisissez **SQL Server Native Client 11.0**.
1. Vérifiez que la case **Server name (Nom du serveur)** indique le point de terminaison de votre instance de base de données RDS for SQL Server.
1. Sélectionnez **Use SQL Server Authentication (Utiliser l'authentification SQL Server)**. Pour **User name (Nom d'utilisateur)** et **Password (Mot de passe)**, saisissez le nom d'utilisateur principal et le mot de passe de votre instance de base de données.
1. Vérifiez que la zone **Base de données** affiche la base de données depuis laquelle vous souhaitez exporter des données.
1. Choisissez **Suivant**.
1. Sur la page **Choose a Destination (Choisir une destination)**, procédez comme suit :
1. Pour **Destination**, choisissez **SQL Server Native Client 11.0**.
**Note**
D'autres sources de données cibles sont disponibles. Elles incluent les suivantes : les fournisseurs de données .NET Framework, les fournisseurs OLE DB, les fournisseurs SQL Server Native Client, les fournisseurs ADO.NET, Microsoft Office Excel, Microsoft Office Access et la source du fichier plat. Si vous choisissez de cibler l'une de ces sources de données, ignorez le reste de l'étape 4. Pour obtenir des détails sur les informations de connexion à fournir ensuite, consultez [Choix d’une destination](http://msdn.microsoft.com/en-us/library/ms178430%28v=sql.110%29.aspx) dans la documentation SQL Server.
1. Pour **Server name (Nom de serveur)**, saisissez le nom du serveur de l'instance de base de données SQL Server cible.
1. Choisissez le type d'authentification qui convient. Saisissez un nom d'utilisateur et un mot de passe si nécessaire.
1. Pour **Base de données**, choisissez le nom de base de données cible, ou sélectionnez **Nouveau** pour créer une base de données qui contiendra les données exportées.
Si vous choisissez **Nouveau**, consultez [Créer une base de données](http://msdn.microsoft.com/en-us/library/ms183323%28v=sql.110%29.aspx) dans la documentation SQL Server pour obtenir des renseignements sur les informations de base de données à fournir.
1. Choisissez **Suivant**.
1. Sur la page **Table Copy or Query (Copie ou requête de tableau)**, choisissez **Copy data from one or more tables or views (Copier des données à partir d'un ou plusieurs tableaux ou affichages)** ou **Write a query to specify the data to transfer (Rédiger une requête pour spécifier les données à transférer)**. Choisissez **Suivant**.
1. Si vous avez choisi **Write a query to specify the data to transfer (Rédiger une requête pour spécifier les données à transférer)**, vous voyez la page **Provide a Source Query (Fournir une requête source)**. Saisissez ou collez une requête SQL, puis choisissez **Parse (Analyser)** pour la vérifier. Après la validation de la requête, choisissez **Suivant**.
1. Sur la page **Select Source Tables and Views (Sélectionner les tableaux et affichages source)**, procédez comme suit :
1. Sélectionnez les tables et les affichages que vous souhaitez exporter, ou bien vérifiez que la requête que vous avez fournie est sélectionnée.
1. Choisissez **Edit Mappings (Modifier le mappage)** puis spécifiez les informations de mappage de la colonne et de la base de données. Pour plus d’informations, consultez [Mapping de colonnes (Mappage des colonnes)](http://msdn.microsoft.com/en-us/library/ms189660%28v=sql.110%29.aspx) dans la documentation SQL Server.
1. (Facultatif) Pour afficher un aperçu des données à exporter, sélectionnez la table, l'affichage ou la requête, puis choisissez **Preview (Aperçu)**.
1. Choisissez **Suivant**.
1. Sur la page **Run Package (Exécuter le package)**, vérifiez que l'option **Run immediately (Exécuter immédiatement)** est sélectionnée. Choisissez **Suivant**.
1. Sur la page **Complete the Wizard (Finaliser l'assistant)**, vérifiez que les informations d'exportation des données sont telles que vous les attendez. Choisissez **Finish** (Terminer).
1. Sur la page **The execution was successful (L'exécution est réussie)**, choisissez **Close (Fermer)**.
### Assistant Générer et publier des scripts et utilitaire bcp
Vous pouvez utiliser l'assistant de génération et de publication de scripts pour créer des scripts pour une base de données entière ou seulement des objets sélectionnés. Vous pouvez exécuter ces scripts sur une instance de base de données SQL Server pour recréer les objets à base de script. Vous pouvez ensuite utiliser l'utilitaire bcp pour exporter en bloc les données pour les objets sélectionnés vers l'instance de base de données cible. Ce choix est préférable si vous souhaitez déplacer une base de données complète (dont des objets autres que des tables) ou d'importantes quantités de données entre deux instances DB SQL Server. Pour une description complète de la syntaxe de ligne de commande bcp, consultez [Utilitaire bcp](http://msdn.microsoft.com/en-us/library/ms162802%28v=sql.110%29.aspx) dans la documentation Microsoft SQL Server.
L'assistant SQL Server Generate et Publish Scripts est disponible dans le cadre de Microsoft SQL Server Management Studio. Ce client SQL Server graphique est inclus dans toutes les éditions de Microsoft SQL Server, sauf Express Edition. SQL Server Management Studio Express est disponible uniquement en tant qu'application basée sur Windows. SQL Server Management Studio Express est disponible auprès de Microsoft en [téléchargement gratuit](http://www.microsoft.com/en-us/search/Results.aspx?q=sql%20server%20management%20studio).
**Pour utiliser l'assistant de génération et de publication de scripts et l'utilitaire bcp pour exporter des données, procédez comme suit :**
1. Dans SQL Server Management Studio, connectez-vous à votre instance de base de données RDS for SQL Server. Pour plus d'informations sur la manière de procéder, consultez [Connexion à votre instance de base de données Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
1. Dans **Object Explorer (Navigateur d'objet)**, développez le nœud **Bases de données** et sélectionnez la base de données que vous souhaitez baser sur script.
1. Suivez les instructions dans [Assistant générer et publier des scripts](http://msdn.microsoft.com/en-us/library/bb895179%28v=sql.110%29.aspx) dans la documentation SQL Server pour créer un fichier script.
1. Dans SQL Server Management Studio, connectez-vous à votre instance de base de données SQL Server cible.
1. Avec l'instance de base de données SQL Server cible sélectionnée dans **Object Explorer** (Navigateur d'objet), dans le menu **File** (Fichier), choisissez **Open** (Ouvrir), sélectionnez **File** (Fichier), puis ouvrez le fichier script.
1. Si vous avez scripté la base de données entière, examinez l'instruction CREATE DATABASE dans le script. Veillez à ce que la base de données soit créée dans l'emplacement avec les paramètres de votre choix. Pour plus d'informations, consultez [CREATE DATABASE (CRÉER UNE BASE DE DONNÉES)](http://msdn.microsoft.com/en-us/library/ms176061%28v=sql.110%29.aspx) dans la documentation SQL Server.
1. Si vous créez des utilisateurs de base de données dans le script, assurez-vous que les ID de connexion serveur existent sur l'instance de base de données cible pour ces utilisateurs. Sinon, créez des ID de connexion pour ces utilisateurs. Dans le cas contraire, les commandes à base de script pour créer les utilisateurs de base de données échoueront. Pour plus d’informations, consultez [Créer un compte de connexion](http://msdn.microsoft.com/en-us/library/aa337562%28v=sql.110%29.aspx) dans la documentation SQL Server.
1. Choisissez **\$1Execute** dans le menu SQL Editor pour exécuter le fichier script et créer les objets de base de données. Lorsque le script se termine, vérifiez que tous les objets de base de données existent comme prévu.
1. Utilisez l'utilitaire bcp pour exporter des données depuis l'instance de base de données RDS for SQL Server vers des fichiers. Ouvrez une invite de commande et saisissez la commande suivante.
```
bcp database_name.schema_name.table_name out data_file -n -S aws_rds_sql_endpoint -U username -P password
```
Le code précédent inclut les options suivantes :
+ *table\$1name* correspond au nom d'une des tables que vous avez recréées dans la base de données cible et que vous voulez à présent remplir avec des données.
+ *data\$1file* correspond au nom et au chemin d'accès complet du fichier de données à créer.
+ `-n` spécifie que la copie en bloc utilise les types de données natifs des données à copier.
+ `-S` spécifie l'instance de base de données SQL Server d'origine de l'exportation.
+ `-U` spécifie le nom d'utilisateur à utiliser lors de la connexion à l'instance de base de données SQL Server.
+ `-P` spécifie le mot de passe pour l'utilisateur spécifié par `-U`.
Ce qui suit présente un exemple de commande .
```
bcp world.dbo.city out C:\Users\JohnDoe\city.dat -n -S sql-jdoe.1234abcd.us-west-2.rds.amazonaws.com,1433 -U JohnDoe -P ClearTextPassword
```
Répétez cette étape jusqu'à ce que vous ayez des fichiers de données pour toutes les tables que vous souhaitez exporter.
1. Préparez votre instance de base de données cible pour l'importation en bloc de données en suivant les instructions dans [Préparer l'importation de données en bloc](http://msdn.microsoft.com/en-us/library/ms189989%28v=sql.110%29.aspx) dans la documentation SQL Server.
1. Décidez du choix d'une méthode d'importation en bloc à utiliser après avoir pris en compte la performance et d'autres problèmes abordés dans [A propos des opérations d'exportation et d'importation en bloc](http://msdn.microsoft.com/en-us/library/ms187042%28v=sql.105%29.aspx) dans la documentation SQL Server.
1. Importez en bloc les données depuis les fichiers de données que vous créez à l'aide de l'utilitaire bcp. Pour ce faire, suivez les instructions dans [Importer et exporter des données en bloc à l'aide de l'utilitaire bcp](http://msdn.microsoft.com/en-us/library/aa337544%28v=sql.110%29.aspx) ou [Importer des données en bloc à l'aide de BULK INSERT ou OPENROWSET(BULK...)](http://msdn.microsoft.com/en-us/library/ms175915%28v=sql.110%29.aspx) dans la documentation SQL Server, selon ce que vous avez décidé à l'étape 11.
# Utilisation de l’utilitaire BCP dans Linux pour importer et exporter des données
L’utilitaire BCP (Bulk Copy Program) fournit un moyen efficace de transférer de grandes quantités de données entre votre instance de base de données RDS for SQL Server et les fichiers de données. Vous pouvez utiliser BCP dans les environnements Linux pour effectuer des opérations de données groupées. Cela le rend utile pour la migration des données, les processus ETL et les transferts de données réguliers.
BCP prend en charge à la fois l’importation de données depuis des fichiers vers des tables SQL Server et l’exportation de données depuis des tables SQL Server vers des fichiers. Cela est particulièrement efficace pour le transfert de données structurées dans différents formats, y compris des fichiers texte délimités.
## Prérequis
Avant d’utiliser BCP avec votre instance de base de données RDS for SQL Server dans Linux, assurez-vous de disposer des éléments suivants :
+ Un environnement Linux avec une connectivité réseau à votre instance de base de données RDS for SQL Server
+ Des outils de ligne de commande Microsoft SQL Server installés sur votre système Linux, notamment :
+ sqlcmd - Outil de requête de ligne de commande SQL Server
+ bcp - Utilitaire Bulk Copy Program
+ Des informations d’identification valides pour votre instance de base de données RDS for SQL Server
+ Accès au réseau configuré via des groupes de sécurité pour autoriser les connexions sur le port SQL Server (généralement 1433)
+ Autorisations de base de données appropriées pour les opérations que vous souhaitez effectuer
## Installation des outils de ligne de commande SQL Server sur Linux
Pour utiliser BCP sur Linux, vous devez installer les outils de ligne de commande Microsoft SQL Server. Pour obtenir des instructions d’installation détaillées pour votre distribution Linux spécifique, consultez la documentation Microsoft suivante :
+ [Installez sqlcmd et bcp, les outils de ligne de commande de SQL Server sur Linux](https://docs.microsoft.com/en-us/sql/linux/sql-server-linux-setup-tools)
+ [utilitaire bcp](https://docs.microsoft.com/en-us/sql/tools/bcp-utility) - Référence complète pour l’utilitaire BCP
Après l’installation, assurez-vous que les outils sont disponibles dans votre PATH en exécutant :
```
bcp -v
sqlcmd -?
```
## Exportation de données depuis RDS for SQL Server
Vous pouvez utiliser BCP pour exporter des données depuis votre instance de base de données RDS for SQL Server vers des fichiers de votre système Linux. Cela est utile pour créer des sauvegardes, analyser des données ou en préparer pour la migration.
### Syntaxe d’exportation de base
La syntaxe de base pour exporter des données à l’aide de BCP est la suivante :
```
bcp database.schema.table out output_file -S server_name -U username -P password [options]
```
Où :
+ `database.schema.table` - Le nom de table entièrement qualifié
+ `output_file` - Le chemin et le nom du fichier de sortie
+ `server_name` - Votre point de terminaison RDS for SQL Server
+ `username` - Votre nom d’utilisateur de base de données
+ `password` - Votre mot de passe de base de données
### Exemple d’exportation
L’exemple suivant exporte des données depuis une table nommée `customers` dans la base de données `sales` :
```
bcp sales.dbo.customers out /home/user/customers.txt \
-S mydb.cluster-abc123.us-east-1.rds.amazonaws.com \
-U admin \
-P mypassword \
-c \
-t "|" \
-r "\n"
```
Cette commande :
+ Exporte les données à partir de la table `customers`
+ Enregistrer la sortie dans `/home/user/customers.txt`
+ Utilise le format de caractères (`-c`)
+ Utilise la barre verticale (\$1) en tant que délimiteur de champ (`-t "|"`)
+ Utilise une nouvelle ligne en tant que délimiteur de ligne (`-r "\n"`)
## Importation de données vers RDS for SQL Server
Vous pouvez utiliser BCP pour importer des données depuis les fichiers de votre système Linux dans votre instance de base de données RDS for SQL Server. Cela est utile pour la migration des données, le chargement des données de test ou les mises à jour régulières des données.
### Syntaxe d’importation de base
La syntaxe de base pour importer des données à l’aide de BCP est la suivante :
```
bcp database.schema.table in input_file -S server_name -U username -P password [options]
```
Où :
+ `database.schema.table` - Le nom de table de destination entièrement qualifié
+ `input_file` - Le chemin et le nom du fichier d’entrée
+ `server_name` - Votre point de terminaison RDS for SQL Server
+ `username` - Votre nom d’utilisateur de base de données
+ `password` - Votre mot de passe de base de données
### Exemple d’importation
L’exemple suivant importe les données d’un fichier vers une table nommée `customers` :
```
bcp sales.dbo.customers in /home/user/customers.txt \
-S mydb.cluster-abc123.us-east-1.rds.amazonaws.com \
-U admin \
-P mypassword \
-c \
-t "|" \
-r "\n" \
-b 1000
```
Cette commande :
+ Importe les données dans la table `customers`
+ Lit les données de `/home/user/customers.txt`
+ Utilise le format de caractères (`-c`)
+ Utilise la barre verticale (\$1) en tant que délimiteur de champ (`-t "|"`)
+ Utilise une nouvelle ligne en tant que délimiteur de ligne (`-r "\n"`)
+ Traite les données par lots de 1 000 lignes (`-b 1000`)
## Options BCP courantes
BCP propose de nombreuses options pour contrôler la mise en forme des données et le comportement de transfert. Le tableau suivant décrit les options les plus fréquemment utilisées :
| Option | Description |
| --- | --- |
| -c | Utilise le type de données de caractère pour toutes les colonnes |
| -n | Utilise les types de données de bases de données natives |
| -t | Spécifie le délimiteur de champ (la valeur par défaut est une tabulation) |
| -r | Spécifie le délimiteur de ligne (la valeur par défaut est une nouvelle ligne) |
| -b | Spécifie la taille du lot pour les opérations groupées |
| -F | Spécifie la première ligne à exporter ou à importer |
| -L | Spécifie la dernière ligne à exporter ou à importer |
| -e | Spécifie un fichier d’erreur pour capturer les lignes rejetées |
| -f | Spécifie un fichier de format pour la mise en forme des données |
| -q | Utilise des identifiants entre guillemets pour les noms d’objets |
## Bonnes pratiques et considérations
Lorsque vous utilisez BCP avec RDS for SQL Server dans Linux, tenez compte des bonnes pratiques suivantes :
+ **Utilisez le traitement groupé** : pour les grands jeux de données, utilisez l’option `-b` permettant de traiter les données de manière groupée. Cela améliore les performances et permet une meilleure récupération après une erreur.
+ **Gérez correctement les erreurs** : utilisez l’option `-e` pour capturer les informations relatives aux erreurs et les lignes rejetées dans un fichier distinct à des fins d’analyse.
+ **Choisissez les formats de données appropriés** : utilisez le format de caractères (`-c`) pour la compatibilité multiplateforme ou le format natif (`-n`) pour bénéficier de meilleures performances lorsque la source et la destination sont SQL Server.
+ **Sécurisez vos informations d’identification** : évitez de saisir des mots de passe directement dans les lignes de commande. Pensez à utiliser des variables d’environnement ou des fichiers de configuration dotés des autorisations appropriées.
+ **Faites des tests avec de petits jeux de données** : avant de traiter de grandes quantités de données, testez vos commandes BCP avec des jeux de données plus petits afin de vérifier la mise en forme et la connectivité.
+ **Surveillez la connectivité réseau** : garantissez des connexions réseau stables, en particulier pour les transferts de données importants. Envisagez d’utiliser des outils tels que `screen` ou `tmux` pour les opérations de longue durée.
+ **Validez l’intégrité des données** : après le transfert des données, vérifiez le nombre de lignes et les données d’échantillon pour vous assurer que l’opération s’est bien déroulée.
## Dépannage des problèmes courants
Le tableau suivant décrit les problèmes courants que vous pouvez rencontrer lors de l’utilisation de BCP dans Linux, ainsi que leurs solutions :
| Problème | Solution |
| --- | --- |
| Expiration du délai de connexion ou erreurs réseau | Vérifiez votre point de terminaison Amazon RDS, les paramètres de votre groupe de sécurité et votre connectivité réseau. Assurez-vous que le port SQL Server (généralement 1433) est accessible à partir de votre système Linux. |
| Authentication failures (Échecs d’authentification) | Vérifiez votre nom d’utilisateur et votre mot de passe. Assurez-vous que l’utilisateur de la base de données dispose des autorisations appropriées pour les opérations que vous effectuez. |
| Erreurs de format de données | Vérifiez vos délimiteurs de champs et de lignes. Assurez-vous que le format des données correspond aux attentes de BCP. Utilisez des fichiers de format pour les structures de données complexes. |
| Erreurs de type « Autorisation refusée » | Assurez-vous que l’utilisateur de votre base de données dispose des autorisations INSERT pour les importations ou des autorisations SELECT pour les exportations sur les tables cibles. |
| Problèmes de gestion des fichiers volumineux | Utilisez le traitement par lots avec l’option -b. Envisagez de diviser les fichiers volumineux en petits morceaux pour améliorer les performances et récupérer après une erreur. |
| Problèmes de codage de caractères | Assurez-vous que vos fichiers de données utilisent un codage de caractères compatible. Utilisez l’option -c pour le format des caractères ou spécifiez les pages de code appropriées. |