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.
# Utilisation de volumes Docker avec Amazon ECS
Lorsque vous utilisez des volumes Docker, le pilote `local` intégré ou un pilote de volume tiers peut être utilisé. Les volumes Docker sont gérés par Docker et un répertoire est créé dans `/var/lib/docker/volumes` sur l'instance de conteneur qui contient les données du volume.
Pour utiliser des volumes Docker, spécifiez un `dockerVolumeConfiguration` dans votre définition de tâche. Pour plus d’informations, consultez la section [Volumes](https://docs.docker.com/engine/storage/volumes/) dans la documentation Docker.
Certains cas d'utilisation courants pour les volumes Docker sont les suivants :
+ Fournir des volumes de données permanent à utiliser avec des conteneurs
+ Partager un volume de données défini à différents emplacements sur différents conteneurs situés sur la même instance de conteneur
+ Définir un volume de données vide, non permanent et le monter dans plusieurs conteneurs au sein d’une même tâche
+ Fournir un volume de données à votre tâche qui est gérée par un pilote tiers
## Considérations relatives à l’utilisation des volumes Docker
Tenez compte des éléments suivants lorsque vous utilisez des volumes Docker :
+ Les volumes Docker sont pris en charge uniquement en utilisant le type de lancement EC2 ou des instances externes.
+ Les conteneurs Windows prennent uniquement en charge l'utilisation du pilote `local`.
+ Si un pilote tiers est utilisé, assurez-vous qu'il est installé et actif sur l'instance de conteneur avant le démarrage de l'agent de conteneur. Si le pilote tiers n'est pas actif avant le démarrage de l'agent, vous pouvez redémarrer l'agent de conteneur à l'aide de l'une des commandes suivantes :
+ Pour l'AMI Amazon Linux 2 optimisée pour Amazon ECS :
```
sudo systemctl restart ecs
```
+ Pour l'AMI Amazon Linux optimisée pour Amazon ECS :
```
sudo stop ecs && sudo start ecs
```
Pour plus d’informations sur la manière de spécifier un volume Docker dans une définition de tâche, consultez la section [Spécification d’un volume Docker dans une définition de tâche Amazon ECS](specify-volume-config.md).
# Spécification d’un volume Docker dans une définition de tâche Amazon ECS
Avant que vos conteneurs puissent utiliser des volumes de données, vous devez spécifier les configurations du volume et du point de montage dans votre définition de tâche. Cette section décrit la configuration du volume pour un conteneur. Pour les tâches qui utilisent un volume Docker, spécifiez une propriété `dockerVolumeConfiguration`. Pour les tâches qui utilisent un volume hôte de montage lié, spécifiez un `host` et éventuellement un `sourcePath`.
La définition de tâche JSON indiquée ci-dessous illustre la syntaxe des objets `volumes` et `mountPoints` pour un conteneur :
```
{
"containerDefinitions": [
{
"mountPoints": [
{
"sourceVolume": "string",
"containerPath": "/path/to/mount_volume",
"readOnly": boolean
}
]
}
],
"volumes": [
{
"name": "string",
"dockerVolumeConfiguration": {
"scope": "string",
"autoprovision": boolean,
"driver": "string",
"driverOpts": {
"key": "value"
},
"labels": {
"key": "value"
}
}
}
]
}
```
`name`
Type : chaîne
Obligatoire : non
Nom du volume. Jusqu’à 255 lettres (majuscules et minuscules), chiffres, traits d’union (`-`) et traits de soulignement (`_`) sont autorisés. Ce nom est référencé dans le paramètre `sourceVolume` de l’objet `mountPoints` de définition du conteneur.
`dockerVolumeConfiguration`
Type : [DockerVolumeConfiguration](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DockerVolumeConfiguration.html)Objet
Obligatoire : non
Ce paramètre est spécifié lorsque vous utilisez des volumes Docker. Les volumes Docker sont pris en charge uniquement lors de l’exécution de tâches sur des instances EC2. Les conteneurs Windows prennent uniquement en charge l’utilisation du pilote `local`. Pour utiliser des montages liés, spécifiez plutôt un paramètre `host`.
`scope`
Type : Chaîne
Valeurs valides : `task` \$1 `shared`
Obligatoire : non
Portée du volume Docker, qui détermine son cycle de vie. Les volumes Docker destinés à un élément `task` sont automatiquement mis en service lorsque la tâche commence, et détruits lorsque la tâche s'arrête. Les volumes Docker définis comme `shared` ne sont pas supprimés lorsque la tâche s'arrête.
`autoprovision`
Type : Boolean
Valeur par défaut : `false`
Obligatoire : non
Si cette valeur est `true`, le volume Docker est créé s'il n'existe pas déjà. Ce champ n’est utilisé que si `scope` a la valeur `shared`. Si le champ `scope` a la valeur `task`, ce paramètre doit être omis.
`driver`
Type : chaîne
Obligatoire : non
Pilote de volume Docker à utiliser. La valeur du pilote doit correspondre au nom du pilote fourni par Docker, car ce nom est utilisé pour le placement des tâches. Si le pilote a été installé à l’aide de l’interface CLI du plug-in Docker, utilisez `docker plugin ls` pour récupérer le nom du pilote à partir de votre instance de conteneur. Si le pilote a été installé à l’aide d’une autre méthode, utilisez la découverte du plug-in Docker pour récupérer le nom du pilote.
`driverOpts`
Type : chaîne
Obligatoire : non
Mappage des options spécifiques au pilote Docker à transmettre. Ce paramètre correspond à `DriverOpts` dans la section « Créer un volume » de Docker.
`labels`
Type : chaîne
Obligatoire : non
Métadonnées personnalisées à ajouter à votre volume Docker.
`mountPoints`
Type : tableau d'objets
Obligatoire : non
Les points de montage pour les volumes de données dans votre conteneur. Ce paramètre correspond à `Volumes` dans l’API Docker create-container et à l’option `--volume` de docker run.
Les conteneurs Windows peuvent monter des répertoires entiers sur le même lecteur que `$env:ProgramData`. Les conteneurs Windows ne peuvent pas monter de répertoires sur un autre lecteur, et les points de montage ne peuvent pas être utilisés sur plusieurs lecteurs. Vous devez spécifier des points de montage pour associer un volume Amazon EBS directement à une tâche Amazon ECS.
`sourceVolume`
Type : Chaîne
Obligatoire : oui, lorsque des objets `mountPoints` sont utilisés
Nom du volume à monter.
`containerPath`
Type : Chaîne
Obligatoire : oui, lorsque des objets `mountPoints` sont utilisés
Le chemin dans le conteneur où le volume sera monté.
`readOnly`
Type : booléen
Obligatoire : non
Si cette valeur est `true`, le conteneur ne peut accéder au volume qu'en lecture. Si cette valeur est `false`, le conteneur peut écrire sur le volume. La valeur par défaut est `false`.
Pour les tâches exécutées sur des instances EC2 exécutant le système d’exploitation Windows, laissez la valeur `false` par défaut.
# Exemples de volumes Docker pour Amazon ECS
Les exemples suivants montrent comment fournir un stockage éphémère pour un conteneur et comment fournir un volume partagé pour plusieurs conteneurs, et comment fournir un stockage persistant NFS pour un conteneur.
**Pour fournir un stockage éphémère à un conteneur à l’aide d’un volume Docker**
Dans cet exemple, un conteneur utilise un volume de données vide qui est éliminé une fois la tâche terminée. Un exemple d'utilisation est que vous pourriez avoir un conteneur qui doit accéder à un emplacement de stockage de fichiers de travail pendant une tâche. Cette tâche peut être réalisée à l'aide d'un volume Docker.
1. Dans la section `volumes` de la définition de tâche, définissez un volume de données avec les valeurs `name` et `DockerVolumeConfiguration`. Dans cet exemple, nous spécifions la portée sous la forme `task`. Le volume est donc supprimé après l'arrêt de la tâche et il utilise le pilote `local` intégré.
```
"volumes": [
{
"name": "scratch",
"dockerVolumeConfiguration" : {
"scope": "task",
"driver": "local",
"labels": {
"scratch": "space"
}
}
}
]
```
1. Dans la section `containerDefinitions`, définissez un conteneur avec des valeurs `mountPoints` qui font référence au nom du volume défini et la valeur `containerPath` sur laquelle monter le volume sur le conteneur.
```
"containerDefinitions": [
{
"name": "container-1",
"mountPoints": [
{
"sourceVolume": "scratch",
"containerPath": "/var/scratch"
}
]
}
]
```
**Pour fournir un stockage persistant à plusieurs conteneurs à l’aide d’un volume Docker**
Dans cet exemple, vous voulez un volume partagé qui sera utilisé par plusieurs conteneurs et vous souhaitez qu'il persiste après l'arrêt des tâches qui l'utilisent. Le pilote `local` intégré est en cours d'utilisation. Ainsi, le volume est toujours lié au cycle de vie de l'instance de conteneur.
1. Dans la section `volumes` de la définition de tâche, définissez un volume de données avec les valeurs `name` et `DockerVolumeConfiguration`. Dans cet exemple, spécifiez une portée `shared` pour que le volume persiste, définissez autoprovision sur `true`. C'est ainsi que le volume est créé pour être utilisé. Ensuite, utilisez également le pilote `local` intégré.
```
"volumes": [
{
"name": "database",
"dockerVolumeConfiguration" : {
"scope": "shared",
"autoprovision": true,
"driver": "local",
"labels": {
"database": "database_name"
}
}
}
]
```
1. Dans la section `containerDefinitions`, définissez un conteneur avec des valeurs `mountPoints` qui font référence au nom du volume défini et la valeur `containerPath` sur laquelle monter le volume sur le conteneur.
```
"containerDefinitions": [
{
"name": "container-1",
"mountPoints": [
{
"sourceVolume": "database",
"containerPath": "/var/database"
}
]
},
{
"name": "container-2",
"mountPoints": [
{
"sourceVolume": "database",
"containerPath": "/var/database"
}
]
}
]
```
**Pour fournir un stockage permanent NFS pour un conteneur à l'aide d'un volume Docker**
Dans cet exemple, un conteneur utilise un volume de données NFS qui est automatiquement monté lorsque la tâche démarre et démonté lorsque la tâche s'arrête. Cela utilise le pilote `local` intégré Docker. Un exemple d'utilisation est que vous pourriez avoir un stockage NFS local et que vous devez y accéder à l'aide d'une tâche ECS Anywhere. Cela peut être réalisé à l'aide d'un volume Docker avec option de pilote NFS.
1. Dans la section `volumes` de la définition de tâche, définissez un volume de données avec les valeurs `name` et `DockerVolumeConfiguration`. Dans cet exemple, spécifiez une portée `task` de telle sorte que le volume soit démonté une fois la tâche terminée. Utilisez le pilote `local` et configurez le `driverOpts` avec le `type`, `device` et les options `o` en conséquence. Remplacez `NFS_SERVER` par le point de terminaison du serveur NFS.
```
"volumes": [
{
"name": "NFS",
"dockerVolumeConfiguration" : {
"scope": "task",
"driver": "local",
"driverOpts": {
"type": "nfs",
"device": "$NFS_SERVER:/mnt/nfs",
"o": "addr=$NFS_SERVER"
}
}
}
]
```
1. Dans la section `containerDefinitions`, définissez un conteneur avec des valeurs `mountPoints` qui font référence au nom du volume défini et la valeur `containerPath` sur laquelle monter le volume sur le conteneur.
```
"containerDefinitions": [
{
"name": "container-1",
"mountPoints": [
{
"sourceVolume": "NFS",
"containerPath": "/var/nfsmount"
}
]
}
]
```