# Exemplos de volume do Docker para o Amazon ECS
<a name="docker-volume-examples"></a>

Os exemplos a seguir mostram como fornecer armazenamento temporário para um contêiner, como fornecer um volume compartilhado para vários contêineres e como fornecer armazenamento persistente NFS para um contêiner.

**Para fornecer armazenamento temporário em um contêiner usando um volume do Docker**

Neste exemplo, um contêiner utiliza um volume de dados vazio que é descartado após o término da tarefa. Um exemplo de caso de uso é que você pode ter um contêiner que precisa acessar algum local de armazenamento de arquivos temporários durante uma tarefa. Essa tarefa pode ser realizada usando um volume do Docker.

1. Na seção `volumes` de definição de tarefa, defina um volume de dados com os valores `name` e `DockerVolumeConfiguration`. Neste exemplo, especificamos o escopo como `task` para que o volume seja excluído depois que a tarefa é interrompida e use o driver `local` integrado.

   ```
   "volumes": [
       {
           "name": "scratch",
           "dockerVolumeConfiguration" : {
               "scope": "task",
               "driver": "local",
               "labels": {
                   "scratch": "space"
               }
           }
       }
   ]
   ```

1. Na seção `containerDefinitions`, defina um contêiner com valores `mountPoints` que faz referência ao nome do volume definido e o valor `containerPath` para montar o volume no contêiner.

   ```
   "containerDefinitions": [
       {
           "name": "container-1",
           "mountPoints": [
               {
                 "sourceVolume": "scratch",
                 "containerPath": "/var/scratch"
               }
           ]
       }
   ]
   ```

**Para fornecer armazenamento persistente para vários contêiner usando um volume do Docker**

Neste exemplo, você quer um volume compartilhado para vários contêineres usarem e deseja que ele persista após a interrupção de qualquer tarefa única que o esteja usando. O driver `local` integrado está sendo usado. Isso acontece para que o volume permaneça vinculado ao ciclo de vida da instância de contêiner.

1. Na seção `volumes` de definição de tarefa, defina um volume de dados com os valores `name` e `DockerVolumeConfiguration`. Neste exemplo, especifique um escopo `shared` de forma que o volume persista e defina a provisão automática como `true`. Isso acontece para que o volume seja criado para uso. Então, utilize também o driver `local` incorporado.

   ```
   "volumes": [
       {
           "name": "database",
           "dockerVolumeConfiguration" : {
               "scope": "shared",
               "autoprovision": true,
               "driver": "local",
               "labels": {
                   "database": "database_name"
               }
           }
       }
   ]
   ```

1. Na seção `containerDefinitions`, defina um contêiner com valores `mountPoints` que faz referência ao nome do volume definido e o valor `containerPath` para montar o volume no contêiner.

   ```
   "containerDefinitions": [
       {
           "name": "container-1",
           "mountPoints": [
           {
             "sourceVolume": "database",
             "containerPath": "/var/database"
           }
         ]
       },
       {
         "name": "container-2",
         "mountPoints": [
           {
             "sourceVolume": "database",
             "containerPath": "/var/database"
           }
         ]
       }
     ]
   ```

**Para fornecer armazenamento NFS persistente para um contêiner usando um volume do Docker**

 Neste exemplo, um contêiner utiliza um volume de dados do NFS que é montado automaticamente quando a tarefa é iniciada e desmontado quando a tarefa é interrompida. Isso usa o driver `local` integrado do Docker. Um exemplo de caso de uso: você pode ter um armazenamento NFS local e precisa acessá-lo por meio de uma tarefa do ECS Anywhere. Isso pode ser feito usando uma opção de volume do Docker com driver NFS.

1. Na seção `volumes` de definição de tarefa, defina um volume de dados com os valores `name` e `DockerVolumeConfiguration`. Neste exemplo, especifique um escopo de `task` para que o volume seja desmontado após o término da tarefa. Use o driver `local` e configure o `driverOpts` com as opções `type`, `device` e `o` de acordo. Substitua `NFS_SERVER` pelo endpoint do servidor NFS.

   ```
   "volumes": [
          {
              "name": "NFS",
              "dockerVolumeConfiguration" : {
                  "scope": "task",
                  "driver": "local",
                  "driverOpts": {
                      "type": "nfs",
                      "device": "$NFS_SERVER:/mnt/nfs",
                      "o": "addr=$NFS_SERVER"
                  }
              }
          }
      ]
   ```

1. Na seção `containerDefinitions`, defina um contêiner com valores `mountPoints` que faça referência ao nome do volume definido e o valor `containerPath` para montar o volume no contêiner.

   ```
   "containerDefinitions": [
          {
              "name": "container-1",
              "mountPoints": [
                  {
                    "sourceVolume": "NFS",
                    "containerPath": "/var/nfsmount"
                  }
              ]
          }
      ]
   ```