Exemples de montage lié pour Amazon ECS

Les exemples suivants couvrent les cas d’utilisation courants pour l’utilisation d’un montage lié pour vos conteneurs.

Pour allouer une quantité accrue d'espace de stockage éphémère pour une tâche Fargate

Pour les tâches Amazon ECS hébergées sur Fargate à l'aide de la version 1.4.0 de la plateforme ou une version ultérieure (Linux) ou 1.0.0 (Windows), vous pouvez allouer plus que la quantité de magasins éphémères par défaut pour les conteneurs de votre tâche à utiliser. Cet exemple peut être intégré dans les autres exemples afin d'allouer plus de stockage éphémère pour vos tâches Fargate.

Dans la définition de la tâche, définissez un objet ephemeralStorage. La valeur sizeInGiB doit être un nombre entier compris entre 21 et 200 est exprimée en GiB.
```
"ephemeralStorage": {
    "sizeInGiB": integer
}
```

Pour fournir un volume de données vide pour un ou plusieurs conteneurs

Dans certains cas, vous voudrez fournir aux conteneurs dans une tâche un peu d'espace vide. Supposons par exemple que deux conteneurs de base de données doivent accéder au même emplacement de stockage temporaire pendant une tâche. Cela peut être réalisé à l'aide d'un montage lié.

Dans la section volumes de la définition de tâche, définissez un montage lié nommé database_scratch.
```
  "volumes": [
    {
      "name": "database_scratch"
    }
  ]
```

Dans la section containerDefinitions, créez les définitions de conteneur de base de données. Cela permet de monter le volume.


"containerDefinitions": [
    {
      "name": "database1",
      "image": "my-repo/database",
      "cpu": 100,
      "memory": 100,
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "database_scratch",
          "containerPath": "/var/scratch"
        }
      ]
    },
    {
      "name": "database2",
      "image": "my-repo/database",
      "cpu": 100,
      "memory": 100,
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "database_scratch",
          "containerPath": "/var/scratch"
        }
      ]
    }
  ]

Pour exposer un chemin d'accès et son contenu d'un fichier Dockerfile à un ou plusieurs conteneurs.

Dans cet exemple, vous avez un fichier Dockerfile qui écrit les données que vous souhaitez monter à l'intérieur d'un conteneur. Cet exemple fonctionne pour les tâches hébergées sur des instances Fargate ou Amazon EC2.

Créez un fichier Dockerfile. L'exemple suivant utilise l'image du conteneur Amazon Linux 2 publique et crée un fichier nommé examplefile dans le répertoire /var/log/exported que nous voulons monter à l'intérieur du conteneur. Le répertoire VOLUME doit spécifier un chemin absolu.
```
FROM public.ecr.aws/amazonlinux/amazonlinux:latest
RUN mkdir -p /var/log/exported
RUN touch /var/log/exported/examplefile
VOLUME ["/var/log/exported"]
```
Par défaut, les autorisations de volume sont définies sur 0755 et le propriétaire en tant que root. Ces autorisations peuvent être modifiées dans le fichier Dockerfile. L'exemple suivant définit le propriétaire du répertoire /var/log/exported en tant que node.
```
FROM public.ecr.aws/amazonlinux/amazonlinux:latest
RUN yum install -y shadow-utils && yum clean all
RUN useradd node
RUN mkdir -p /var/log/exported && chown node:node /var/log/exported					    
USER node
RUN touch /var/log/exported/examplefile
VOLUME ["/var/log/exported"]
```
Dans la section volumes de la définition de tâche, définissez un volume nommé application_logs.
```
  "volumes": [
    {
      "name": "application_logs"
    }
  ]
```

Dans la section containerDefinitions, créez les définitions de conteneur d'application. Cela permet de monter le stockage. La valeur containerPath doit correspondre au chemin absolu spécifié dans la directive VOLUME du Dockerfile.


  "containerDefinitions": [
    {
      "name": "application1",
      "image": "my-repo/application",
      "cpu": 100,
      "memory": 100,
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "application_logs",
          "containerPath": "/var/log/exported"
        }
      ]
    },
    {
      "name": "application2",
      "image": "my-repo/application",
      "cpu": 100,
      "memory": 100,
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "application_logs",
          "containerPath": "/var/log/exported"
        }
      ]
    }
  ]

Pour fournir un volume de données vide pour un conteneur lié au cycle de vie de l'instance Amazon EC2 hôte

Pour les tâches hébergées sur des instances Amazon EC2, vous pouvez utiliser des montages liés et lier les données au cycle de vie de l'instance Amazon EC2 hôte. Vous pouvez effectuer cette opération en utilisant le paramètre host et en spécifiant une valeur sourcePath. Tous les fichiers qui existent sur le sourcePath sont présentés dans les conteneurs à la valeur containerPath. Tous les fichiers écrits dans la valeur containerPath sont écrits dans la valeur sourcePath de l'instance Amazon EC2 hôte.

Important

Amazon ECS ne synchronise pas votre stockage entre les instances Amazon EC2. Les tâches qui utilisent un stockage permanent peuvent être placées sur n'importe quelle instance Amazon EC2 disposant de la capacité nécessaire dans votre cluster. Si vos tâches nécessitent un stockage permanent après l'arrêt et le redémarrage, spécifiez toujours la même instance Amazon EC2 au moment du lancement de la tâche avec la commande start-task de la AWS CLI. Vous pouvez également utiliser des volumes Amazon EFS pour le stockage permanent. Pour de plus amples informations, consultez Utilisation des volumes Amazon EFS avec Amazon ECS.

Dans la section volumes de la définition de tâche, définissez un montage lié avec les valeurs name et sourcePath. Dans l'exemple suivant, l'instance Amazon EC2 hôte contient des données sous /ecs/webdata que vous souhaitez monter à l'intérieur du conteneur.
```
  "volumes": [
    {
      "name": "webdata",
      "host": {
        "sourcePath": "/ecs/webdata"
      }
    }
  ]
```

Dans la section containerDefinitions, définissez un conteneur avec une valeur mountPoints qui fait référence au nom du montage lié défini et la valeur containerPath sur laquelle monter le montage lié sur le conteneur.


  "containerDefinitions": [
    {
      "name": "web",
      "image": "public.ecr.aws/docker/library/nginx:latest",
      "cpu": 99,
      "memory": 100,
      "portMappings": [
        {
          "containerPort": 80,
          "hostPort": 80
        }
      ],
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "webdata",
          "containerPath": "/usr/share/nginx/html"
        }
      ]
    }
  ]

Pour monter un volume défini sur plusieurs conteneurs à différents emplacements

Vous pouvez définir un volume de données dans une définition de tâche et monter ce volume à différents emplacements de différents conteneurs. Par exemple, votre conteneur hôte possède un dossier de données de site web à l'adresse /data/webroot. Vous voudrez peut-être monter ce volume de données en lecture seule sur deux serveurs web qui ont des racines de documents différentes.

Dans la section volumes de la définition de tâche, définissez un volume de données nommé webroot et ayant le chemin source /data/webroot.


  "volumes": [
    {
      "name": "webroot",
      "host": {
        "sourcePath": "/data/webroot"
      }
    }
  ]

Dans la section containerDefinitions, définissez un conteneur pour chaque serveur web avec des valeurs mountPoints qui associent le volume webroot à la valeur containerPath pointant vers la racine du document pour ce conteneur.


  "containerDefinitions": [
    {
      "name": "web-server-1",
      "image": "my-repo/ubuntu-apache",
      "cpu": 100,
      "memory": 100,
      "portMappings": [
        {
          "containerPort": 80,
          "hostPort": 80
        }
      ],
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "webroot",
          "containerPath": "/var/www/html",
          "readOnly": true
        }
      ]
    },
    {
      "name": "web-server-2",
      "image": "my-repo/sles11-apache",
      "cpu": 100,
      "memory": 100,
      "portMappings": [
        {
          "containerPort": 8080,
          "hostPort": 8080
        }
      ],
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "webroot",
          "containerPath": "/srv/www/htdocs",
          "readOnly": true
        }
      ]
    }
  ]

Pour monter les volumes à partir d'un autre conteneur à l'aide de `volumesFrom`

Pour les tâches hébergées sur des instances Amazon EC2, vous pouvez définir un ou plusieurs volumes sur un conteneur, puis utiliser le paramètre volumesFrom dans une définition du conteneur différente, au sein de la même tâche, pour monter tous les volumes du sourceContainer à leurs points de montage définis à l'origine. Le paramètre volumesFrom s'applique aux volumes définis dans la définition de tâche et à ceux qui sont intégrés à l'image au sein d'un Dockerfile.

(Facultatif) Pour partager un volume qui est intégré à une image, suivez les instructions VOLUME du fichier Dockerfile. L'exemple de Dockerfile suivant utilise une image httpd, puis ajoute un volume et le monte à l'emplacement dockerfile_volume dans la racine du document Apache. Il s'agit du dossier utilisé par le serveur web httpd.
```
FROM httpd
VOLUME ["/usr/local/apache2/htdocs/dockerfile_volume"]
```
Vous pouvez créer une image avec ce Dockerfile, la transférer dans un référentiel (comme Docker Hub), puis l'utiliser dans votre définition de tâche. L’exemple d’image my-repo/httpd_dockerfile_volume utilisée dans les étapes suivantes a été créée avec le Dockerfile précédent.
Créez une définition de tâche qui définit les autres volumes et points de montage pour les conteneurs. Dans la section volumes de cet exemple, vous créez un volume vide appelé empty qui est géré par le démon Docker. Il existe également un volume hôte défini qui est appelé host_etc. Il exporte le dossier /etc dans l'instance de conteneur hôte.
```
{
  "family": "test-volumes-from",
  "volumes": [
    {
      "name": "empty",
      "host": {}
    },
    {
      "name": "host_etc",
      "host": {
        "sourcePath": "/etc"
      }
    }
  ],
```
Dans la section des définitions de conteneur, créez un conteneur qui monte les volumes définis précédemment. Dans cet exemple, le conteneur web monte les volumes empty et host_etc. Il s'agit du conteneur qui utilise l'image créée avec un volume dans le Dockerfile.
```
"containerDefinitions": [
    {
      "name": "web",
      "image": "my-repo/httpd_dockerfile_volume",
      "cpu": 100,
      "memory": 500,
      "portMappings": [
        {
          "containerPort": 80,
          "hostPort": 80
        }
      ],
      "mountPoints": [
        {
          "sourceVolume": "empty",
          "containerPath": "/usr/local/apache2/htdocs/empty_volume"
        },
        {
          "sourceVolume": "host_etc",
          "containerPath": "/usr/local/apache2/htdocs/host_etc"
        }
      ],
      "essential": true
    },
```
Créez un autre conteneur qui utilise volumesFrom pour monter tous les volumes qui sont associés au conteneur web. Tous les volumes du conteneur web sont également montés sur le conteneur busybox. Cela inclut le volume spécifié dans le Dockerfile qui a été utilisé pour générer l'image my-repo/httpd_dockerfile_volume.
```
    {
      "name": "busybox",
      "image": "busybox",
      "volumesFrom": [
        {
          "sourceContainer": "web"
        }
      ],
      "cpu": 100,
      "memory": 500,
      "entryPoint": [
        "sh",
        "-c"
      ],
      "command": [
        "echo $(date) > /usr/local/apache2/htdocs/empty_volume/date && echo $(date) > /usr/local/apache2/htdocs/host_etc/date && echo $(date) > /usr/local/apache2/htdocs/dockerfile_volume/date"
      ],
      "essential": false
    }
  ]
}
```
Lorsque la tâche est exécutée, les deux conteneurs montent les volumes, et la fonction command du conteneur busybox écrit la date et l'heure dans un fichier. Ce fichier est appelé date dans chacun des dossiers de volumes. Les dossiers sont alors visibles sur le site web affiché par le conteneur web.

Note
Étant donné que le conteneur busybox exécute une commande rapide avant de s'arrêter, il doit être défini en tant que "essential": false dans la définition de conteneur. Dans le cas contraire, il arrête l'ensemble de la tâche lorsqu'il s'arrête.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Spécification d’un montage lié dans une définition de tâche

Gestion de l’espace mémoire d’échange de conteneur