# Uso de volumes do Docker com o Amazon ECS
Ao usar os volumes do Docker, o driver `local` integrado ou um driver de volume de terceiros poderão ser usados. Os volumes do Docker são gerenciados pelo Docker e um diretório é criado em `/var/lib/docker/volumes` na instância de contêiner que contém os dados de volume.
Para usar os volumes do Docker, especifique uma `dockerVolumeConfiguration` em sua definição de tarefa. Para obter mais informações, consulte [Volumes](https://docs.docker.com/engine/storage/volumes/) na documentação do Docker.
Alguns casos de uso comuns para os volumes do Docker são os seguintes:
+ Para fornecer volumes de dados persistentes para uso com contêineres
+ Para compartilhar um volume de dados definido em locais diferentes em contêineres diferentes na mesma instância de contêiner
+ Para definir um volume de dados não persistente e vazio, além de montá-lo em vários contêineres na mesma tarefa
+ Para fornecer um volume de dados para sua tarefa gerenciada por um driver de terceiros
## Considerações sobre o uso de volumes do Docker
Considere o seguinte ao usar volumes do Docker:
+ Só há suporte para os volumes do Docker com o uso do tipo de inicialização do EC2 ou instâncias externas.
+ Os contêineres do Windows só são compatíveis com o uso do driver `local`.
+ Se um driver de terceiros for usado, verifique se ele está instalado e ativo na instância do contêiner antes que o agente de contêiner seja iniciado. Se o driver de terceiros não estiver ativo antes da inicialização do agente, será possível reiniciar o agente do contêiner usando um dos comandos a seguir:
+ Para a AMI do Amazon Linux 2 otimizada para o Amazon ECS:
```
sudo systemctl restart ecs
```
+ Para a AMI do Amazon Linux otimizada para o Amazon ECS:
```
sudo stop ecs && sudo start ecs
```
Para obter informações sobre como especificar um volume do Docker em uma definição de tarefa, consulte [Especificar um volume do Docker em uma definição de tarefa do Amazon ECS](specify-volume-config.md).
# Especificar um volume do Docker em uma definição de tarefa do Amazon ECS
Antes de seus contêineres poderem usar volumes de dados, você deve especificar as configurações de volume e ponto de montagem em sua definição de tarefa. Esta seção descreve a configuração do volume de um contêiner. Para tarefas que usam um volume do Docker, especifique um `dockerVolumeConfiguration`. Para tarefas que usam um volume de host de montagem bind, especifique um `host` e `sourcePath` opcional.
O JSON de definição de tarefa a seguir mostra a sintaxe para os objetos `volumes` e `mountPoints` de um contêiner.
```
{
"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`
Tipo: string
Obrigatório: não
O nome do volume. São permitidos até 255 letras (caixa alta e baixa), números, hífens (`-`) e sublinhados (`_`). Esse nome é referenciado no parâmetro `sourceVolume` do objeto `mountPoints` de definição do contêiner.
`dockerVolumeConfiguration`
Tipo: objeto [DockerVolumeConfiguration](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DockerVolumeConfiguration.html)
Obrigatório: não
Esse parâmetro é especificado ao usar volumes do Docker. Os volumes do Docker só são compatíveis ao executar tarefas em instâncias do EC2. Os contêineres do Windows só são compatíveis com o uso do driver `local`. Para usar montagens bind, em vez disso, especifique um `host`.
`scope`
Tipo: string
Valores válidos: `task` \$1 `shared`
Obrigatório: não
O escopo para o volume do Docker, que determina o ciclo de vida. Os volumes do Docker que são delimitados para uma `task` são provisionados automaticamente quando a tarefa é iniciada e destruídos quando a tarefa é interrompida. Volumes do Docker delimitados como `shared` são mantidos após a interrupção da tarefa.
`autoprovision`
Tipo: booliano
Valor padrão: `false`
Obrigatório: não
Se o valor for `true`, o volume de Docker será criado se ele ainda não existir. Esse campo só será usado se `scope` for `shared`. Se `scope` for `task`, esse parâmetro deverá ser omitido.
`driver`
Tipo: string
Obrigatório: não
O driver do volume do Docker a ser usado. O valor do driver deve corresponder ao nome do driver fornecido pelo Docker porque esse nome é usado no posicionamento de tarefas. Se o driver foi instalado usando a CLI de plug-in do Docker, use `docker plugin ls` para recuperar o nome do driver na instância de contêiner. Se o driver foi instalado usando outro método, use a descoberta de plug-in do Docker para recuperar o nome do driver.
`driverOpts`
Tipo: string
Obrigatório: não
Um mapa de opções específicas do driver do Docker pelas quais passar. Esse parâmetro é mapeado para `DriverOpts` na seção Criar um volume da API remota do Docker.
`labels`
Tipo: string
Obrigatório: não
Metadados personalizados para adicionar ao volume do Docker.
`mountPoints`
Tipo: Matriz de objeto
Obrigatório: não
Os pontos de montagem dos volumes de dados no contêiner. Esse parâmetro é mapeado em `Volumes` na API create-container do Docker na opção `--volume` de execução do docker.
Os contêineres do Windows podem montar diretórios inteiros na mesma unidade como `$env:ProgramData`. Os contêineres do Windows não podem montar diretórios em uma unidade diferente, e os pontos de montagem não podem ser usados entre unidades. Você deve especificar pontos de montagem para anexar um volume do Amazon EBS diretamente a uma tarefa do Amazon ECS.
`sourceVolume`
Tipo: string
Exigido: Sim, quando `mountPoints` são usados
O nome do volume a ser montado.
`containerPath`
Tipo: string
Exigido: Sim, quando `mountPoints` são usados
O caminho no contêiner onde o volume será montado.
`readOnly`
Tipo: booliano
Obrigatório: não
Caso o valor seja `true`, o contêiner tem acesso somente leitura ao volume. Caso esse valor seja `false`, o contêiner pode gravar no volume. O valor padrão é `false`.
Para tarefas executadas em instâncias do EC2 que executam o sistema operacional Windows, deixe o valor como o padrão de `false`.
# Exemplos de volume do Docker para o Amazon ECS
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"
}
]
}
]
```