

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.

# Intégration d'une instance de base de données Amazon RDS for SQL Server DB avec Amazon S3
<a name="User.SQLServer.Options.S3-integration"></a>

Vous pouvez transférer des fichiers entre une instance de base de données exécutant Amazon RDS for SQL Server et un compartiment Amazon S3. Ainsi, vous pouvez utiliser Amazon S3 avec des fonctionnalités SQL, telles que BULK INSERT. Par exemple, vous pouvez télécharger des fichiers .csv, .xml, .txt, etc. depuis Amazon S3 vers l'hôte de l'instance de base de données, puis importer les données depuis `D:\S3\` dans la base de données. Tous les fichiers sont stockés dans `D:\S3\` sur l'instance de base de données.

Les limites suivantes s'appliquent :

**Note**  
Le trafic entre l'hôte RDS et S3 est acheminé via les points de terminaison VPC dans RDS en VPCs interne pour toutes les fonctionnalités de SQL Server qui utilisent S3. Ce trafic n’utilise pas le point de terminaison de l’instance RDS ENI. Les stratégies de compartiment S3 ne peuvent pas restreindre le trafic RDS en fonction des conditions du réseau.
+ Les fichiers du dossier `D:\S3` sont supprimés du réplica de secours après un basculement sur des instances Multi-AZ. Pour de plus amples informations, veuillez consulter [Limitations Multi-AZ pour l'intégration S3](#S3-MAZ).
+ L'instance de base de données et le compartiment S3 doivent se trouver dans la même AWS région.
+ Si vous exécutez plusieurs tâches d'intégration S3 simultanément, les tâches s'exécutent de manière séquentielle et non en parallèle.
**Note**  
Les tâches d'intégration S3 partagent la même file d'attente que les tâches de sauvegarde et de restauration natives. Vous pouvez uniquement disposer de deux tâches maximum en cours à tout moment dans cette file d'attente. Par conséquent, deux tâches de sauvegarde et de restauration natives en cours d'exécution bloquent toutes les tâches d'intégration S3.
+ Vous devez réactiver la fonctionnalité d'intégration S3 sur les instances restaurées. Elle ne se propage pas depuis l'instance source vers l'instance restaurée. Sur une instance restaurée, les fichiers situés sous `D:\S3` sont supprimés.
+ Le téléchargement vers l'instance de base de données est limité à 100 fichiers. En d'autres termes, il ne peut pas y avoir plus de 100 fichiers dans `D:\S3\`.
+ Seuls les fichiers sans extension ou qui possèdent une des extensions suivantes sont pris en charge pour le téléchargement : .abf, .asdatabase, .bcp, .configsettings, .csv, .dat, .deploymentoptions, .deploymenttargets, .fmt, .info, .ispac, .lst, .tbl, .txt, .xml et .xmla.
+ Le compartiment S3 doit avoir le même propriétaire que le rôle Gestion des identités et des accès AWS (IAM) associé. Par conséquent, l'intégration S3 entre comptes n'est pas prise en charge.
+ Le compartiment S3 ne peut pas être ouvert au public.
+ La taille des chargements de RDS vers S3 est limitée à 50 Go par fichier.
+ La taille des fichiers téléchargés de S3 vers RDS est limitée au maximum pris en charge par S3.

**Topics**
+ [Prérequis pour l'intégration de RDS for SQL Server avec S3](Appendix.SQLServer.Options.S3-integration.preparing.md)
+ [Activation de l'intégration de RDS for SQL Server avec S3](Appendix.SQLServer.Options.S3-integration.enabling.md)
+ [Transfert de fichiers entre RDS for SQL Server et Amazon S3](Appendix.SQLServer.Options.S3-integration.using.md)
+ [Liste des fichiers sur l'instance de base de données RDS](Appendix.SQLServer.Options.S3-integration.using.listing-files.md)
+ [Suppression de fichiers sur l'instance de base de données RDS](Appendix.SQLServer.Options.S3-integration.using.deleting-files.md)
+ [Surveillance du statut d'une tâche de transfert de fichiers](Appendix.SQLServer.Options.S3-integration.using.monitortasks.md)
+ [Annulation d'une tâche](Appendix.SQLServer.Options.S3-integration.canceltasks.md)
+ [Limitations Multi-AZ pour l'intégration S3](#S3-MAZ)
+ [Désactivation de l'intégration de RDS for SQL Server avec S3](Appendix.SQLServer.Options.S3-integration.disabling.md)

Pour plus d’informations sur l’utilisation des fichiers dans Amazon S3, consultez [Démarrer avec Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3).

# Prérequis pour l'intégration de RDS for SQL Server avec S3
<a name="Appendix.SQLServer.Options.S3-integration.preparing"></a>

Avant de commencer, recherchez ou créez le compartiment S3 que vous souhaitez utiliser. De plus, ajoutez des autorisations afin que l'instance de base de données RDS puisse accéder au compartiment S3. Pour configurer cet accès, vous créez une stratégie et un rôle IAM.

## Console
<a name="Appendix.SQLServer.Options.S3-integration.preparing.console"></a>

**Pour créer une stratégie IAM afin d'accéder à Amazon S3**

1. Dans la console [IAM Management Console](https://console.aws.amazon.com/iam/home?#home), choisissez **Stratégie** dans le panneau de navigation.

1. Créez une nouvelle stratégie et utilisez l'onglet **Éditeur visuel** pour exécuter les étapes suivantes.

1. Pour **Service**, saisissez **S3** et choisissez le service **S3**.

1. Pour **Actions**, choisissez les actions suivantes pour accorder l'accès nécessaire à votre instance de base de données :
   + `ListAllMyBuckets` – Obligatoire
   + `ListBucket` – Obligatoire
   + `GetBucketAcl` – Obligatoire
   + `GetBucketLocation` – Obligatoire
   + `GetObject` : obligatoire pour télécharger des fichiers depuis S3 vers `D:\S3\`
   + `PutObject` : obligatoire pour charger des fichiers depuis `D:\S3\` vers S3
   + `ListMultipartUploadParts` : obligatoire pour charger des fichiers depuis `D:\S3\` vers S3
   + `AbortMultipartUpload` : obligatoire pour charger des fichiers depuis `D:\S3\` vers S3

1. Pour **Ressources**, les options qui s'affichent dépendent des actions choisies dans l'étape précédente. Vous pourrez voir des options pour **compartiment**, **objet** ou les deux. Pour chacune d'entre elles, ajoutez l'Amazon Resource Name (ARN) approprié.

   Pour **compartiment**, ajoutez l'ARN du compartiment que vous souhaitez utiliser. Par exemple, si votre compartiment est nommé *amzn-s3-demo-bucket*, définissez l'ARN sur `arn:aws:s3:::amzn-s3-demo-bucket`.

   Pour **objet**, saisissez l'ARN pour le compartiment, puis choisissez l'une des options suivantes :
   + Pour accorder l'accès à tous les fichiers d'un compartiment spécifié, choisissez **Tous** pour le **Bucket name (Nom du compartiment)** et le **Object name (Nom de l'objet)**.
   + Pour accorder l'accès à des fichiers ou à des dossiers spécifiques du bucket, ARNs indiquez les buckets et les objets spécifiques auxquels vous souhaitez que SQL Server accède. 

1. Suivez les instructions dans la console jusqu'à la création de la stratégie.

   Ce qui précède est un guide abrégé pour configurer une stratégie. Pour obtenir des instructions détaillées sur la création de stratégies IAM, consultez [Création de stratégies IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) dans le *Guide de l’utilisateur IAM.*

**Pour créer un rôle IAM utilisant la stratégie IAM de la procédure précédente.**

1. Dans la console [IAM Management Console](https://console.aws.amazon.com/iam/home?#home), choisissez **Rôles** dans le panneau de navigation.

1. Créez un rôle IAM et choisissez les options suivantes à mesure qu'elles s'affichent dans la console :
   + **AWSweb**
   + **RDS**
   + **RDS – Ajoutez un rôle à la base de données**

   Ensuite, choisissez **Suivant : Autorisations** en bas.

1. Pour **Attach permissions policies (Attacher des stratégies d'autorisations)**, saisissez le nom de la stratégie IAM précédemment créée. Ensuite, choisissez la stratégie dans la liste.

1. Suivez les instructions dans la console jusqu'à la création du rôle.

   Ce qui précède est un guide abrégé pour configurer un rôle. Pour obtenir des instructions plus détaillées sur la création des rôles, consultez [Rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) dans le *Guide de l’utilisateur IAM.*

## AWS CLI
<a name="Appendix.SQLServer.Options.S3-integration.preparing.CLI"></a>

Pour accorder à Amazon RDS l'accès à un compartiment Amazon S3, procédez comme suit :

1. Créez une stratégie IAM qui accorde à Amazon RDS l'accès à un compartiment S3.

1. Créez un rôle IAM qu'Amazon RDS peut endosser en votre nom pour accéder à vos compartiments S3.

   Pour plus d’informations, consultez [Création d’un rôle pour déléguer des autorisations à un utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) dans le *Guide de l’utilisateur IAM*.

1. Attachez la politique IAM que vous avez créée au rôle IAM que vous venez de créer.

**Pour créer la stratégie IAM**

Ajoutez les actions appropriées pour accorder l'accès nécessaire à votre instance de base de données :
+ `ListAllMyBuckets` – Obligatoire
+ `ListBucket` – Obligatoire
+ `GetBucketAcl` – Obligatoire
+ `GetBucketLocation` – Obligatoire
+ `GetObject` : obligatoire pour télécharger des fichiers depuis S3 vers `D:\S3\`
+ `PutObject` : obligatoire pour charger des fichiers depuis `D:\S3\` vers S3
+ `ListMultipartUploadParts` : obligatoire pour charger des fichiers depuis `D:\S3\` vers S3
+ `AbortMultipartUpload` : obligatoire pour charger des fichiers depuis `D:\S3\` vers S3

1. La AWS CLI commande suivante crée une politique IAM nommée `rds-s3-integration-policy` avec ces options. Elle accorde un accès à un compartiment nommé *amzn-s3-demo-bucket*.  
**Example**  

   Pour Linux, macOS ou Unix :

   ```
   aws iam create-policy \
   	 --policy-name rds-s3-integration-policy \
   	 --policy-document '{
   	        "Version": "2012-10-17",		 	 	 
   	        "Statement": [
   	            {
   	                "Effect": "Allow",
   	                "Action": "s3:ListAllMyBuckets",
   	                "Resource": "*"
   	            },
   	            {
   	                "Effect": "Allow",
   	                "Action": [
   	                    "s3:ListBucket",
   	                    "s3:GetBucketAcl",
   	                    "s3:GetBucketLocation"
   	                ],
   	                "Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
   	            },
   	            {
   	                "Effect": "Allow",
   	                "Action": [
   	                    "s3:GetObject",
   	                    "s3:PutObject",
   	                    "s3:ListMultipartUploadParts",
   	                    "s3:AbortMultipartUpload"
   	                ],
   	                "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/key_prefix/*"
   	            }
   	        ]
   	    }'
   ```

   Pour Windows :

   Veillez à remplacer les fins de ligne par celles prises en charge par votre interface (`^` au lieu de `\`). De plus, dans Windows, vous devez utiliser une séquence d'échappement sur tous les guillemets doubles avec un `\`. Pour éviter d'utiliser une séquence d'échappement sur tous les guillemets dans le JSON, vous pouvez l'enregistrer dans un fichier et le transmettre en tant que paramètre. 

   Tout d'abord, créez le fichier `policy.json` avec la stratégie d'autorisation suivante :

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "s3:ListAllMyBuckets",
               "Resource": "*"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "s3:ListBucket",
                   "s3:GetBucketACL",
                   "s3:GetBucketLocation"
               ],
               "Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:PutObject",
                   "s3:ListMultipartUploadParts",
                   "s3:AbortMultipartUpload"
               ],
               "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/key_prefix/*"
           }
       ]
   }
   ```

------

   Ensuite, utilisez la commande suivante pour créer la stratégie :

   ```
   aws iam create-policy ^
        --policy-name rds-s3-integration-policy ^
        --policy-document file://file_path/assume_role_policy.json
   ```

1. Après avoir créé la stratégie, notez son ARN (Amazon Resource Name). Vous aurez besoin de l'ARN lors d'une étape ultérieure.

**Pour créer le rôle IAM**
+ La AWS CLI commande suivante crée le rôle `rds-s3-integration-role` IAM à cette fin.  
**Example**  

  Pour Linux, macOS ou Unix :

  ```
  aws iam create-role \
  	   --role-name rds-s3-integration-role \
  	   --assume-role-policy-document '{
  	     "Version": "2012-10-17",		 	 	 
  	     "Statement": [
  	       {
  	         "Effect": "Allow",
  	         "Principal": {
  	            "Service": "rds.amazonaws.com"
  	          },
  	         "Action": "sts:AssumeRole"
  	       }
  	     ]
  	   }'
  ```

  Pour Windows :

  Veillez à remplacer les fins de ligne par celles prises en charge par votre interface (`^` au lieu de `\`). De plus, dans Windows, vous devez utiliser une séquence d'échappement sur tous les guillemets doubles avec un `\`. Pour éviter d'utiliser une séquence d'échappement sur tous les guillemets dans le JSON, vous pouvez l'enregistrer dans un fichier et le transmettre en tant que paramètre. 

  Tout d'abord, créez le fichier `assume_role_policy.json` avec la stratégie suivante :

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Principal": {
                  "Service": [
                      "rds.amazonaws.com"
                  ]
              },
              "Action": "sts:AssumeRole"
          }
      ]
  }
  ```

------

  Ensuite, utilisez la commande suivante pour créer le rôle IAM :

  ```
  aws iam create-role ^
       --role-name rds-s3-integration-role ^
       --assume-role-policy-document file://file_path/assume_role_policy.json
  ```  
**Example d'utiliser la clé de contexte de condition globale pour créer le rôle IAM**  

  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 politiques 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 de politique.
  + 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 politique, assurez-vous d'utiliser la clé de contexte de condition globale `aws:SourceArn` avec l'Amazon Resource Name (ARN) complet des ressources qui accèdent au rôle. Pour l'intégration S3, assurez-vous d'inclure l'instance de base de données ARNs, comme indiqué dans l'exemple suivant.

  Pour Linux, macOS ou Unix :

  ```
  aws iam create-role \
  	   --role-name rds-s3-integration-role \
  	   --assume-role-policy-document '{
  	     "Version": "2012-10-17",		 	 	 
  	     "Statement": [
  	       {
  	         "Effect": "Allow",
  	         "Principal": {
  	            "Service": "rds.amazonaws.com"
  	          },
  	         "Action": "sts:AssumeRole",
                  "Condition": {
                      "StringEquals": {
                          "aws:SourceArn":"arn:aws:rds:Region:my_account_ID:db:db_instance_identifier"
                      }
                  }
  	       }
  	     ]
  	   }'
  ```

  Pour Windows :

  Ajoutez la clé de contexte de condition globale à `assume_role_policy.json`.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Principal": {
                  "Service": [
                      "rds.amazonaws.com"
                  ]
              },
              "Action": "sts:AssumeRole",
              "Condition": {
                  "StringEquals": {
                      "aws:SourceArn":"arn:aws:rds:Region:my_account_ID:db:db_instance_identifier"
                  }
              }
          }
      ]
  }
  ```

------

**Pour attacher la politique IAM à un rôle IAM**
+ La AWS CLI commande suivante associe la politique au rôle nommé`rds-s3-integration-role`. Remplacez `your-policy-arn` par l’ARN de stratégie que vous avez noté lors d’une étape précédente.  
**Example**  

  Pour Linux, macOS ou Unix :

  ```
  aws iam attach-role-policy \
  	   --policy-arn your-policy-arn \
  	   --role-name rds-s3-integration-role
  ```

  Pour Windows :

  ```
  aws iam attach-role-policy ^
  	   --policy-arn your-policy-arn ^
  	   --role-name rds-s3-integration-role
  ```

# Activation de l'intégration de RDS for SQL Server avec S3
<a name="Appendix.SQLServer.Options.S3-integration.enabling"></a>

Dans la section suivante, vous trouverez comment activer l'intégration Amazon S3 avec Amazon RDS for SQL Server. Pour utiliser une intégration S3, votre instance de base de données doit être associée au rôle IAM précédemment créé avant d'utiliser le paramètre feature-name `S3_INTEGRATION`.

**Note**  
Pour ajouter un rôle IAM à une instance de base de données, le statut de l'instance de base de données doit être **disponible**.

## Console
<a name="Appendix.SQLServer.Options.S3-integration.enabling.console"></a>

**Pour associer le rôle IAM à votre instance de base de données**

1. Connectez-vous à la AWS Management Console et ouvrez la console Amazon RDS à l’adresse [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).

1. Cliquez sur le nom de l’instance de base de données RDS for SQL Server pour en afficher les détails.

1. Dans l'onglet **Connectivity & security (Connexion et sécurité)** de la section **Gestion des rôles IAM**, choisissez le rôle IAM à ajouter sous **Add IAM roles to this instance (Ajouter des rôles IAM à cette instance)**.

1. Pour **Fonction**, choisissez **S3\$1INTEGRATION**.  
![\[Ajouter le rôle S3_INTEGRATION\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/ora-s3-integration-role.png)

1. Choisissez **Add role (Ajouter un rôle)**.

## AWS CLI
<a name="Appendix.SQLServer.Options.S3-integration.enabling.cli"></a>

**Pour ajouter le rôle IAM à l'instance de base de données RDS for SQL Server**
+ La commande AWS CLI suivante ajoute votre rôle IAM à une instance de base de données RDS for SQL Server nommée `mydbinstance`.  
**Example**  

  Pour Linux, macOS ou Unix :

  ```
  aws rds add-role-to-db-instance \
  	   --db-instance-identifier mydbinstance \
  	   --feature-name S3_INTEGRATION \
  	   --role-arn your-role-arn
  ```

  Pour Windows :

  ```
  aws rds add-role-to-db-instance ^
  	   --db-instance-identifier mydbinstance ^
  	   --feature-name S3_INTEGRATION ^
  	   --role-arn your-role-arn
  ```

  Remplacez `your-role-arn` par l’ARN du rôle que vous avez noté lors d’une étape précédente. `S3_INTEGRATION` doit être spécifié pour l’option `--feature-name`.

# Transfert de fichiers entre RDS for SQL Server et Amazon S3
<a name="Appendix.SQLServer.Options.S3-integration.using"></a>

Vous pouvez utiliser des procédures stockées Amazon RDS pour charger et télécharger des fichiers entre Amazon S3 et votre instance de base de données RDS. Vous pouvez également utiliser des procédures stockées Amazon RDS pour répertorier et supprimer des fichiers sur l'instance RDS.

Les fichiers que vous téléchargez depuis/chargez vers S3 sont stockés dans le dossier `D:\S3`. Il s'agit du seul dossier que vous pouvez utiliser pour accéder à vos fichiers. Vous pouvez organiser vos fichiers en sous-dossiers, qui sont créés pour vous lorsque vous incluez le dossier de destination lors du téléchargement.

Certaines procédures stockées exigent que vous fournissiez un nom ARN (Amazon Resource Name) à votre compartiment et votre fichier S3. Le format pour votre ARN est `arn:aws:s3:::amzn-s3-demo-bucket/file_name`. Amazon S3 n'a pas besoin de numéro de compte ni de AWS région dans ARNs.

Les tâches d'intégration S3 s'exécutent de manière séquentielle, partagent la même file d'attente que la sauvegarde native et restaurent des tâches. Vous pouvez uniquement disposer de deux tâches maximum en cours à tout moment dans cette file d'attente. Le traitement de la tâche peut mettre jusqu'à cinq minutes avant de commencer.

## Téléchargement des fichiers d'un compartiment Amazon S3 vers une instance de base de données SQL Server
<a name="Appendix.SQLServer.Options.S3-integration.using.download"></a>

Pour télécharger des fichiers d'un compartiment S3 vers une instance de base de données RDS for SQL Server, suivez la procédure `msdb.dbo.rds_download_from_s3` stockée dans Amazon RDS avec les paramètres suivants.


| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description | 
| --- | --- | --- | --- | --- | 
|  `@s3_arn_of_file`  |  NVARCHAR  |  –  |  Obligatoire  |  L'ARN S3 du fichier à télécharger, par exemple : `arn:aws:s3:::amzn-s3-demo-bucket/mydata.csv`  | 
|  `@rds_file_path`  |  NVARCHAR  |  –  |  Facultatif  |  Le chemin du fichier pour l'instance RDS. Si aucun n'est spécifié, le chemin du fichier est `D:\S3\<filename in s3>`. RDS prend en charge des chemins absolus et relatifs. Si vous souhaitez créer un sous-dossier, incluez-le dans le chemin du fichier.  | 
|  `@overwrite_file`  |  INT  |  0  |  Facultatif  | Écraser le fichier existant :  0 = Ne pas écraser 1 = Écraser | 

Vous pouvez télécharger des fichiers sans extension de fichier et des fichiers avec les extensions de fichier suivantes : .bcp, .csv, .dat, .fmt, .info, .lst, .tbl, .txt et .xml.

**Note**  
Les fichiers avec l'extension de fichier .ispac sont pris en charge pour le téléchargement lorsque SQL Server Integration Services est activé. Pour plus d'informations sur l'activation de SSIS, veuillez consulter [SQL Server Integration Services](Appendix.SQLServer.Options.SSIS.md).  
Les fichiers avec les extensions de fichier suivantes sont pris en charge pour le téléchargement lorsque SQL Server Analysis Services est activé : .abf, .asdatabase, .configsettings, .deploymentoptions, .deploymenttargets et .xmla. Pour plus d'informations sur l'activation de SSAS, veuillez consulter [SQL Server Analysis Services](Appendix.SQLServer.Options.SSAS.md).

L'exemple suivant illustre la procédure stockée pour télécharger des fichiers depuis S3. 

```
exec msdb.dbo.rds_download_from_s3
	    @s3_arn_of_file='arn:aws:s3:::amzn-s3-demo-bucket/bulk_data.csv',
	    @rds_file_path='D:\S3\seed_data\data.csv',
	    @overwrite_file=1;
```

L'exemple `rds_download_from_s3` créé un dossier nommé `seed_data` in `D:\S3\`, si le dossier n'existe pas encore. Ensuite, l'exemple télécharge le fichier source `bulk_data.csv` depuis S3 vers un nouveau fichier nommé `data.csv` sur l'instance de base de données. Si le fichier existait déjà, il est écrasé car le paramètre `@overwrite_file` est défini sur `1`.

## Téléchargement des fichiers depuis une instance de base de données SQL Server vers un compartiment Amazon S3
<a name="Appendix.SQLServer.Options.S3-integration.using.upload"></a>

Pour charger des fichiers d'une instance de base de données RDS for SQL Server vers un compartiment S3, suivez la procédure `msdb.dbo.rds_upload_to_s3` stockée dans Amazon RDS avec les paramètres suivants.


| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description | 
| --- | --- | --- | --- | --- | 
|  `@s3_arn_of_file`  |  NVARCHAR  |  –  |  Obligatoire  |  L'ARN S3 du fichier à créer dans S3, par exemple : `arn:aws:s3:::amzn-s3-demo-bucket/mydata.csv`  | 
|  `@rds_file_path`  |  NVARCHAR  |  –  |  Obligatoire  | Le chemin du fichier à charger sur S3. Les chemins absolus et relatifs sont pris en charge. | 
|  `@overwrite_file`  |  INT  |  –  |  Facultatif  |  Écraser le fichier existant :  0 = Ne pas écraser 1 = Écraser  | 

L'exemple suivant charge le fichier nommé `data.csv` depuis l'emplacement spécifié dans `D:\S3\seed_data\` vers un fichier `new_data.csv` dans le compartiment S3 spécifié par l'ARN.

```
exec msdb.dbo.rds_upload_to_s3 
		@rds_file_path='D:\S3\seed_data\data.csv',
		@s3_arn_of_file='arn:aws:s3:::amzn-s3-demo-bucket/new_data.csv',
		@overwrite_file=1;
```

Si le fichier existait déjà dans S3, il est écrasé car le paramètre @overwrite\$1file est défini sur `1`.

# Liste des fichiers sur l'instance de base de données RDS
<a name="Appendix.SQLServer.Options.S3-integration.using.listing-files"></a>

Pour répertorier les fichiers disponibles sur l'instance de base de données, utilisez une procédure stockée et une fonction. Tout d'abord, exécutez la procédure stockée suivante pour récupérer les détails depuis les fichiers dans `D:\S3\`. 

```
exec msdb.dbo.rds_gather_file_details;
```

La procédure stockée retourne l'ID de la tâche. À l'instar d'autres tâches, cette procédure stockée s'exécute de manière asynchrone. Dès que le statut de la tâche est `SUCCESS`, vous pouvez utiliser l'ID de tâche dans la fonction `rds_fn_list_file_details` pour répertorier les fichiers et répertoires existants dans D:\$1S3\$1, comme illustré ci-dessous.

```
SELECT * FROM msdb.dbo.rds_fn_list_file_details(TASK_ID);
```

La fonction `rds_fn_list_file_details` retourne un tableau avec les colonnes suivantes.


| Paramètre de sortie | Description | 
| --- | --- | 
| filepath | Chemin absolu du fichier (par exemple, D:\$1S3\$1mydata.csv) | 
| size\$1in\$1bytes | Taille du fichier (en octets) | 
| last\$1modified\$1utc | Date et heure de la dernière modification au format UTC | 
| is\$1directory | Option qui indique si l'objet est un annuaire (true/false) | 

# Suppression de fichiers sur l'instance de base de données RDS
<a name="Appendix.SQLServer.Options.S3-integration.using.deleting-files"></a>

Pour supprimer les fichiers disponibles sur l'instance de base de données, utilisez la procédure stockée Amazon RDS `msdb.dbo.rds_delete_from_filesystem` avec les paramètres suivants. 


| Nom du paramètre | Type de données | Par défaut | Obligatoire | Description | 
| --- | --- | --- | --- | --- | 
|  `@rds_file_path`  |  NVARCHAR  |  –  |  Obligatoire  | Le chemin du fichier à supprimer. Les chemins absolus et relatifs sont pris en charge.  | 
|  `@force_delete`  |  INT  | 0 |  Facultatif  |  Pour supprimer un annuaire, cet indicateur doit être inclus et défini sur `1`. `1` = Supprimer un annuaire Ce paramètre est ignoré si vous supprimez un fichier.  | 

Pour supprimer un annuaire, `@rds_file_path` doit se terminer par une barre oblique inverse (`\`) et `@force_delete` doit être défini sur `1`.

L'exemple suivant supprimer le fichier `D:\S3\delete_me.txt`.

```
exec msdb.dbo.rds_delete_from_filesystem
    @rds_file_path='D:\S3\delete_me.txt';
```

L'exemple suivant supprime l'annuaire `D:\S3\example_folder\`.

```
exec msdb.dbo.rds_delete_from_filesystem
    @rds_file_path='D:\S3\example_folder\',
    @force_delete=1;
```

# Surveillance du statut d'une tâche de transfert de fichiers
<a name="Appendix.SQLServer.Options.S3-integration.using.monitortasks"></a>

Pour suivre le statut de votre tâche d'intégration S3, appelez la fonction `rds_fn_task_status`. Deux paramètres sont nécessaires. Le premier paramètre doit toujours être `NULL` car il ne s'applique pas à l'intégration S3. Le second paramètre accepte l'ID de tâche.

Pour consulter une liste de toutes les tâches, définissez le premier paramètre sur `NULL` et le second sur `0`, comme illustré dans l'exemple suivant.

```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,0);
```

Pour obtenir une tâche spécifique, définissez le premier paramètre sur `NULL` et le second sur l'ID de tâche, comme illustré dans l'exemple suivant.

```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,42);
```

La fonction `rds_fn_task_status` retourne les informations suivantes.


|  Paramètre de sortie  |  Description  | 
| --- | --- | 
|  `task_id`  |  ID de la tâche  | 
|  `task_type`  |  Pour l'intégration S3, des tâches peuvent avoir les types suivants : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/Appendix.SQLServer.Options.S3-integration.using.monitortasks.html)  | 
|  `database_name`  | Non applicable aux tâches d'intégration S3. | 
|  `% complete`  |  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/Appendix.SQLServer.Options.S3-integration.using.monitortasks.html)  | 
|  `task_info`  |  Informations supplémentaires sur la tâche. Si une erreur se produit pendant le traitement, cette colonne contient des informations sur l'erreur.   | 
|  `last_updated`  |  Date et heure de la dernière mise à jour de l'état de la tâche.   | 
|  `created_at`  |  Date et heure de création de la tâche.  | 
|  `S3_object_arn`  |  L'ARN de l'objet S3 depuis lequel le téléchargement est effectué et vers lequel le chargement est effectué.  | 
|  `overwrite_S3_backup_file`  |  Non applicable aux tâches d'intégration S3.  | 
|  `KMS_master_key_arn`  |  Non applicable aux tâches d'intégration S3.  | 
|  `filepath`  |  Chemin du fichier sur l'instance de base de données RDS.  | 
|  `overwrite_file`  |  Option qui indique si un fichier existant a été écrasé.  | 
|  `task_metadata`  |  Non applicable aux tâches d'intégration S3.  | 

# Annulation d'une tâche
<a name="Appendix.SQLServer.Options.S3-integration.canceltasks"></a>

Pour annuler une tâche d'intégration S3, utilisez la procédure stockée `msdb.dbo.rds_cancel_task` avec le paramètre `task_id`. Les tâches de suppression et la liste des tâches en cours ne peuvent pas être annulées. L'exemple suivant illustre une demande d'annulation d'une tâche. 

```
exec msdb.dbo.rds_cancel_task @task_id = 1234;
```

Pour obtenir un aperçu de toutes els tâches et de leurs ID de tâche, utilisez la fonction `rds_fn_task_status`, telle que décrite dans [Surveillance du statut d'une tâche de transfert de fichiers](Appendix.SQLServer.Options.S3-integration.using.monitortasks.md).

## Limitations Multi-AZ pour l'intégration S3
<a name="S3-MAZ"></a>

Sur des instances Multi-AZ, les fichiers du dossier `D:\S3` sont supprimés du réplica de secours après un basculement. Un basculement peut être planifié, par exemple, lors de modifications apportées à une instance de base de données telles que la modification de la classe d'instance ou la mise à niveau de la version du moteur. La planification d'un basculement peut être annulée, par exemple en cas d'arrêt de l'instance principale.

**Note**  
Nous ne recommandons pas d'utiliser le dossier `D:\S3` pour le stockage de fichiers. La bonne pratique consiste à charger des fichiers créés dans Amazon S3 afin de les rendre durables, et à télécharger les fichiers lorsque vous avez besoin d'importer des données.

Pour déterminer l'heure du dernier basculement, vous pouvez utiliser la procédure stockée `msdb.dbo.rds_failover_time`. Pour plus d'informations, consultez [Détermination de l’heure du dernier basculement pour Amazon RDS for SQL Server](Appendix.SQLServer.CommonDBATasks.LastFailover.md).

**Example d'Aucun basculement récent**  
Cet exemple illustre la sortie lorsqu'il n'y a pas de basculement récent dans les journaux d'erreurs. Aucun basculement ne s'est produit depuis le 29/04/2020 à 23:59:00.01.  
Par conséquent, tous les fichiers téléchargés après cette date et cette heure et qui n'ont pas été supprimés avec la procédure stockée `rds_delete_from_filesystem` sont toujours accessibles sur l'hôte actuel. Les fichiers téléchargés avant cette date et cette heure peuvent également être disponibles.  


| errorlog\$1available\$1from | recent\$1failover\$1time | 
| --- | --- | 
|  2020-04-29 23:59:00.0100000  |  null  | 

**Example de Basculement récent**  
Cet exemple illustre la sortie lorsqu'un basculement récent est détecté dans les journaux d'erreurs. Le basculement le plus récent a eu lieu le 05/05/2020 à 18:57:51.89.  
Tous les fichiers téléchargés après cette date et cette heure et qui n'ont pas été supprimés avec la procédure stockée `rds_delete_from_filesystem` sont toujours accessibles sur l'hôte actuel.  


| errorlog\$1available\$1from | recent\$1failover\$1time | 
| --- | --- | 
|  2020-04-29 23:59:00.0100000  |  2020-05-05 18:57:51.8900000  | 

# Désactivation de l'intégration de RDS for SQL Server avec S3
<a name="Appendix.SQLServer.Options.S3-integration.disabling"></a>

Par la suite, vous trouverez comment désactiver l'intégration Amazon S3 avec Amazon RDS for SQL Server. Les fichiers stockés dans `D:\S3\` ne sont pas supprimés lors de la désactivation de l'intégration S3.

**Note**  
Pour supprimer un rôle IAM d'une instance de base de données, le statut de l'instance de base de données doit être `available`.

## Console
<a name="Appendix.SQLServer.Options.S3-integration.disabling.console"></a>

**Pour dissocier votre rôle IAM de votre instance de base de données**

1. Connectez-vous à la AWS Management Console et ouvrez la console Amazon RDS à l’adresse [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).

1. Cliquez sur le nom de l’instance de base de données RDS for SQL Server pour en afficher les détails.

1. Dans l'onglet **Connectivity & security (Connectivité et sécurité)** de la section **Gérer les rôles IAM**, choisissez le rôle IAM à supprimer.

1. Sélectionnez **Delete (Supprimer)**.

## AWS CLI
<a name="Appendix.SQLServer.Options.S3-integration.disabling.cli"></a>

**Pour supprimer le rôle IAM de l'instance de base de données RDS for SQL Server**
+ La commande AWS CLI suivante supprime le rôle IAM d'une instance de base de données RDS for SQL Server nommée `mydbinstance`.  
**Example**  

  Pour Linux, macOS ou Unix :

  ```
  aws rds remove-role-from-db-instance \
  	   --db-instance-identifier mydbinstance \
  	   --feature-name S3_INTEGRATION \
  	   --role-arn your-role-arn
  ```

  Pour Windows :

  ```
  aws rds remove-role-from-db-instance ^
  	   --db-instance-identifier mydbinstance ^
  	   --feature-name S3_INTEGRATION ^
  	   --role-arn your-role-arn
  ```

  Remplacez `your-role-arn` par l'ARN du rôle IAM approprié pour l'option `--feature-name`.