Ejemplos de montajes vinculados para Amazon ECS

En los siguientes ejemplos se cubren los casos de uso más comunes de montaje vinculado para los contenedores.

Para asignar una mayor cantidad de espacio de almacenamiento efímero a una tarea de Fargate

Para las tareas de Amazon ECS alojadas en Fargate que utilizan la versión 1.4.0 o posterior (Linux) o 1.0.0 (Windows) de la plataforma, se puede asignar una cantidad mayor de almacenamiento efímero que la predeterminada para que la utilicen los contenedores de la tarea. Este ejemplo se puede incorporar a los otros ejemplos para asignar un almacenamiento más efímero para sus tareas de Fargate.

En la definición de tarea, defina un objeto ephemeralStorage. El valor de sizeInGiB se expresa en GiB y debe ser un número entero entre 21 y 200.
```
"ephemeralStorage": {
    "sizeInGiB": integer
}
```

Para proporcionar un volumen de datos vacío para uno o más contenedores

En algunos casos, es posible que desee proporcionar a los contenedores de una tarea algo de espacio de almacenamiento temporal. Por ejemplo, podría tener dos contenedores de base de datos que deben acceder a la misma ubicación de almacenamiento de archivos scratch durante una tarea. Esto se puede lograr con un montaje de enlace.

En la sección de definición de tarea volumes, defina un montaje vinculado con el nombre database_scratch.
```
  "volumes": [
    {
      "name": "database_scratch"
    }
  ]
```

En la sección containerDefinitions, cree las definiciones de contenedor de base de datos. Esto es para que monten el volumen.


"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"
        }
      ]
    }
  ]

Para exponer una ruta y su contenido en un Dockerfile a un contenedor

En este ejemplo, tiene un Dockerfile que escribe los datos que va a montar dentro de un contenedor. Este ejemplo funciona para tareas que están alojadas en instancias de Fargate o Amazon EC2.

Cree un Dockerfile. En el siguiente ejemplo, se utiliza la imagen de contenedor pública de Amazon Linux 2 y se crea un archivo con el nombre examplefile en el directorio /var/log/exported que queremos montar dentro del contenedor. La directiva VOLUME debe especificar una ruta absoluta.
```
FROM public.ecr.aws/amazonlinux/amazonlinux:latest
RUN mkdir -p /var/log/exported
RUN touch /var/log/exported/examplefile
VOLUME ["/var/log/exported"]
```
De forma predeterminada, los permisos de los volúmenes se establecen en0755 y el propietario como root. Estos permisos se pueden cambiar en el Dockerfile. En el ejemplo siguiente, el propietario del directorio /var/log/exported se establece como 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"]
```
En la sección de definición de tarea de volumes, defina un volumen con el nombre application_logs.
```
  "volumes": [
    {
      "name": "application_logs"
    }
  ]
```

En la sección containerDefinitions, cree las definiciones de contenedor de aplicaciones. Esto es para que monten el almacenamiento. El valor de containerPath debe coincidir con la ruta absoluta especificada en la directiva VOLUME del 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"
        }
      ]
    }
  ]

Para proporcionar un volumen de datos vacío para un contenedor que está vinculado al ciclo de vida de la instancia de Amazon EC2 del host

Para las tareas que están alojadas en instancias de Amazon EC2, se pueden utilizar montajes de enlace y vincular los datos al ciclo de vida de la instancia de Amazon EC2 del host. Para ello, se utiliza el parámetro host y se especifica un valor de sourcePath. Cualquier archivo que exista en sourcePath se presenta a los contenedores con el valor containerPath. Cualquier archivo que se escriba en el valor containerPath, se escribe en el valor sourcePath en la instancia de Amazon EC2 del host.

importante

Amazon ECS no sincroniza el almacenamiento en todas las instancias de Amazon EC2. Las tareas que utilizan almacenamiento persistente se pueden colocar en cualquier instancia de Amazon EC2 del clúster que tenga capacidad disponible. Si las tareas requieren almacenamiento persistente después de detenerse y reiniciarse, especifique siempre la misma instancia de Amazon EC2 en el momento de lanzar la tarea con el comando start-task de la AWS CLI. También puede utilizar volúmenes de Amazon EFS para el almacenamiento persistente. Para obtener más información, consulte Uso de volúmenes de Amazon EFS con Amazon ECS.

En la sección de la definición de tarea volumes, defina un montaje vinculado con los valores de name y sourcePath. En el ejemplo siguiente, la instancia de Amazon EC2 del host contiene datos de /ecs/webdata que va a montar dentro del contenedor.
```
  "volumes": [
    {
      "name": "webdata",
      "host": {
        "sourcePath": "/ecs/webdata"
      }
    }
  ]
```

En la sección containerDefinitions, defina un contenedor con un valor de mountPoints que haga referencia al nombre del montaje de enlace y el valor de containerPath en el que va a realizar el montaje de enlace en el contenedor.


  "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"
        }
      ]
    }
  ]

Para montar un volumen definido en varios contenedores en diferentes ubicaciones

Puede definir un volumen de datos en una definición de tarea y montarlo en diferentes ubicaciones en distintos contenedores. Por ejemplo, el contenedor del host tiene una carpeta de datos del sitio web en /data/webroot. Es posible que desee montar ese volumen de datos como de solo lectura en dos servidores web diferentes que tengan diferentes raíces de documentos.

En la sección de definición de tarea de volumes, defina un volumen de datos con el nombre webroot y la ruta de origen /data/webroot.


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

En la sección containerDefinitions, defina un contenedor para cada servidor web con valores de mountPoints que permitan asociar el volumen de webroot con el valor de containerPath apuntando a la raíz de documentos para ese contenedor.


  "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
        }
      ]
    }
  ]

Para montar volúmenes desde otro contenedor con `volumesFrom`

Para las tareas alojadas en instancias de Amazon EC2, puede definir uno o más volúmenes en un contenedor y, a continuación, utilizar el parámetro volumesFrom en una definición de contenedor diferente dentro de la misma tarea para montar todos los volúmenes de sourceContainer en sus puntos de montaje definidos originalmente. El parámetro volumesFrom se aplica a volúmenes definidos en la definición de tarea, y a los que están integrados en la imagen con un Dockerfile.

(Opcional) Para compartir un volumen integrado en una imagen, utilice la instrucción VOLUME del Dockerfile. En el siguiente ejemplo de Dockerfile se utiliza una imagen httpd y, a continuación, se agrega un volumen y se lo monta en dockerfile_volume en la raíz de documentos de Apache. Es la carpeta que utiliza el servidor web httpd.
```
FROM httpd
VOLUME ["/usr/local/apache2/htdocs/dockerfile_volume"]
```
Puede crear una imagen con este Dockerfile y enviarla a un repositorio, como Docker Hub, y utilizarla en su definición de tarea. La imagen de ejemplo my-repo/httpd_dockerfile_volume que se utiliza en los pasos siguientes se diseñó con el Dockerfile anterior.
Cree una definición de tarea que defina los otros volúmenes y puntos de montaje para los contenedores. En esta sección de ejemplo volumes, se crea un volumen vacío llamado empty, que será administrado por el daemon de Docker. También hay un volumen de host definido denominado host_etc. Exporta la carpeta /etc en la instancia de contenedor del host.
```
{
  "family": "test-volumes-from",
  "volumes": [
    {
      "name": "empty",
      "host": {}
    },
    {
      "name": "host_etc",
      "host": {
        "sourcePath": "/etc"
      }
    }
  ],
```
En la sección de definiciones de contenedor, cree un contenedor para montar los volúmenes definidos anteriormente. En este ejemplo, el contenedor web monta los volúmenes empty y host_etc. Este es el contenedor que utiliza la imagen creada con un volumen en el 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
    },
```
Cree otro contenedor que utiliza volumesFrom para montar todos los volúmenes que están asociados con el contenedor web. Todos los volúmenes del contenedor web se montan también en el contenedor busybox. Esto incluye el volumen especificado en el Dockerfile que se utilizó para crear la imagen 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
    }
  ]
}
```
Cuando esta tarea se ejecuta, los dos contenedores montan los volúmenes y el command en el contenedor busybox escribe la fecha y la hora en un archivo. Este archivo se denomina date en cada una de las carpetas de volumen. Las carpetas se pueden ver en el sitio web mostrado por el contenedor web.

nota
Como el contenedor busybox ejecuta un comando rápido y, a continuación, se cierra, debe establecerse como "essential": false en la definición de contenedor. De no ser así, detiene toda la tarea cuando se cierra.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Especificación de un montaje de unión en la definición de tareas

Administración del espacio de memoria de intercambio de contenedores