# Casos de uso de definiciones de tareas de Amazon ECS
<a name="use-cases"></a>

Obtenga más información sobre cómo escribir definiciones de tareas para varios servicios y características de AWS.

En función de la carga de trabajo, hay parámetros determinados de la definición de tareas que deben configurarse. Además para EC2, debe elegir instancias específicas que están diseñadas para la carga de trabajo.

**Topics**
+ [Definiciones de tareas de Amazon ECS para cargas de trabajo de GPU](ecs-gpu.md)
+ [Definiciones de tareas de Amazon ECS para cargas de trabajo de transcodificación de video](ecs-vt1.md)
+ [Definiciones de tareas de Amazon ECS para cargas de trabajo de machine learning de AWS Neuron](ecs-inference.md)
+ [Definiciones de tareas de Amazon ECS para instancias de aprendizaje profundo](ecs-dl1.md)
+ [Definiciones de tareas de Amazon ECS para cargas de trabajo de ARM de 64 bits](ecs-arm64.md)
+ [Envío de registros de Amazon ECS a CloudWatch](using_awslogs.md)
+ [Envío de registros de Amazon ECS a un servicio de AWS o AWS Partner](using_firelens.md)
+ [Uso de imágenes de contenedor que no sean de AWS en Amazon ECS](private-auth.md)
+ [Reinicio de contenedores individuales en tareas de Amazon ECS con políticas de reinicio de contenedores](container-restart-policy.md)
+ [Transferencia de datos confidenciales a un contenedor de Amazon ECS](specifying-sensitive-data.md)

# Definiciones de tareas de Amazon ECS para cargas de trabajo de GPU
<a name="ecs-gpu"></a>

Amazon ECS admite cargas de trabajo que utilizan unidades GPU cuando se crean clústeres con instancias de contenedor que admiten GPU. Las instancias de contenedor de Amazon EC2 basadas en GPU que utilizan los tipos de instancia p2, p3, p5, g3, g4 y g5 proporcionan acceso a las GPU NVIDIA. Para obtener más información, consulte [Instancias de computación acelerada de Linux](https://docs.aws.amazon.com/ec2/latest/instancetypes/ac.html) en la *Guía de tipos de instancias de Amazon EC2*.

Amazon ECS proporciona una AMI optimizada para GPU que está preconfigurada con controladores de kernel de NVIDIA y un tiempo de ejecución de GPU de Docker. Para obtener más información, consulte [AMI de Linux optimizadas para Amazon ECS](ecs-optimized_AMI.md).

Puede designar un número de GPU en su definición de tareas para la ubicación de tareas en el nivel de contenedor. Amazon ECS programa las tareas de acuerdo con las instancias de contenedor que admiten GPU disponibles y fija las GPU físicas en los contenedores correspondientes para conseguir un rendimiento óptimo. 

Se admiten los siguientes tipos de instancias de Amazon EC2 basadas en GPU. Para obtener más información, consulte [Instancias P2 de Amazon EC2](https://aws.amazon.com/ec2/instance-types/p2/), [Instancias P3 de Amazon EC2](https://aws.amazon.com/ec2/instance-types/p3/), [Instancias P4d de Amazon EC2](https://aws.amazon.com/ec2/instance-types/p4/), [Instancias P5 de Amazon EC2](https://aws.amazon.com/ec2/instance-types/p5/), [Instancias G3 de Amazon EC2](https://aws.amazon.com/ec2/instance-types/g3/), [Instancias G4 de Amazon EC2](https://aws.amazon.com/ec2/instance-types/g4/), [Instancias G5 de Amazon EC2](https://aws.amazon.com/ec2/instance-types/g5/), [Instancias G6 de Amazon EC2](https://aws.amazon.com/ec2/instance-types/g6/) e [Instancias G6e de Amazon EC2](https://aws.amazon.com/ec2/instance-types/g6e/).


|  Tipo de instancia  |  GPU  |  Memoria de GPU (GiB)  |  vCPU  |  Memoria (GiB)  | 
| --- | --- | --- | --- | --- | 
|  p3.2xlarge  |  1  |  16  |  8  |  61  | 
|  p3.8xlarge  |  4  |  64  |  32  |  244  | 
|  p3.16xlarge  |  8  |  128  |  64  |  488  | 
|  p3dn.24xlarge  |  8  |  256  |  96  |  768  | 
|  p4d.24xlarge  | 8 | 320 | 96 | 1152 | 
| p5.48xlarge | 8 | 640 | 192 | 2048 | 
|  g3s.xlarge  |  1  |  8  |  4  |  30,5  | 
|  g3.4xlarge  |  1  |  8  |  16  |  122  | 
|  g3.8xlarge  |  2  |  16  |  32  |  244  | 
|  g3.16xlarge  |  4  |  32  |  64  |  488  | 
|  g4dn.xlarge  |  1  |  16  |  4  |  16  | 
|  g4dn.2xlarge  |  1  |  16  |  8  |  32  | 
|  g4dn.4xlarge  |  1  |  16  |  16  |  64  | 
|  g4dn.8xlarge  |  1  |  16  |  32  |  128  | 
|  g4dn.12xlarge  |  4  |  64  |  48  |  192  | 
|  g4dn.16xlarge  |  1  |  16  |  64  |  256  | 
|  g5.xlarge  |  1  |  24  |  4  |  16  | 
|  g5.2xlarge  |  1  |  24  |  8  |  32  | 
|  g5.4xlarge  |  1  |  24  |  16  |  64  | 
|  g5.8xlarge  |  1  |  24  |  32  |  128  | 
|  g5.16xlarge  |  1  |  24  |  64  |  256  | 
|  g5.12xlarge  |  4  |  96  |  48  |  192  | 
|  g5.24xlarge  |  4  |  96  |  96  |  384  | 
|  g5.48xlarge  |  8  |  192  |  192  |  768  | 
| g6.xlarge | 1 | 24 | 4 | 16 | 
| g6.2xlarge | 1 | 24 | 8 | 32 | 
| g6.4xlarge | 1 | 24 | 16 | 64 | 
| g6.8xlarge | 1 | 24 | 32 | 128 | 
| g6.16.xlarge | 1 | 24 | 64 | 256 | 
| g6.12xlarge | 4 | 96 | 48 | 192 | 
| g6.24xlarge | 4 | 96 | 96 | 384 | 
| g6.48xlarge | 8 | 192 | 192 | 768 | 
| g6.metal | 8 | 192 | 192 | 768 | 
| gr6.4xlarge | 1 | 24 | 16 | 128 | 
| g6e.xlarge | 1 | 48 | 4 | 32 | 
| g6e.2xlarge | 1 | 48 | 8 | 64 | 
| g6e.4xlarge | 1 | 48 | 16 | 128 | 
| g6g.8xlarge | 1 | 48 | 32 | 256 | 
| g6e16.xlarge | 1 | 48 | 64 | 512 | 
| g6e12.xlarge | 4 | 192 | 48 | 384 | 
| g6e24.xlarge | 4 | 192 | 96 | 768 | 
| g6e48.xlarge | 8 | 384 | 192 | 1536 | 
| gr6.8xlarge | 1 | 24 | 32 | 256 | 

Puede recuperar el ID de Imagen de máquina de Amazon (AMI) de las AMI optimizadas para Amazon ECS al consultar la API de Parameter Store de AWS Systems Manager. Al utilizar este parámetro, no necesita buscar de manera manual los ID de la AMI optimizada para Amazon ECS. Para obtener más información acerca de la API de Systems Manager Parameter Store, consulte [GetParameter](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html). El usuario que utiliza debe tener el permiso de IAM `ssm:GetParameter` para recuperar los metadatos de la AMI optimizada para Amazon ECS.

```
aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/gpu/recommended --region us-east-1
```

# Uso de GPU con instancias administradas de Amazon ECS
<a name="managed-instances-gpu"></a>

Instancias administradas de Amazon ECS admite la computación acelerada por GPU para las cargas de trabajo como el machine learning, la computación de alto rendimiento y el procesamiento de video a través de los tipos de instancias de Amazon EC2 siguientes. Para obtener más información acerca de los tipos de instancias compatibles con instancias administradas de Amazon ECS, consulte [Tipos de instancias de instancias administradas de Amazon ECS](managed-instances-instance-types.md).

A continuación, se muestra un subconjunto de tipos de instancias basadas en GPU compatibles con instancias administradas de Amazon ECS:
+ `g4dn`: con tecnología de NVIDIA T4 GPUs, adecuado para aplicaciones de machine learning, inferencia, visión artificial y uso intensivo de gráficos.
+ `g5`: con tecnología de NVIDIA A10G GPUs, ofrece un mayor rendimiento para las aplicaciones con uso intensivo de gráficos y cargas de trabajo de machine learning.
+ `p3`: con tecnología de NVIDIA V100 GPUs, diseñado la computación de alto rendimiento y el entrenamiento de aprendizaje profundo.
+ `p4d`: con tecnología de NVIDIA A100 GPUs, ofrece el más alto rendimiento para el entrenamiento de machine learning y la computación de alto rendimiento.

Cuando utiliza tipos de instancias habilitadas para GPU con instancias administradas de Amazon ECS, los controladores de NVIDIA y el kit de herramientas de CUDA vienen preinstalados en la instancia, lo que facilita la puesta en marcha de cargas de trabajo aceleradas por GPU.

## Selección de instancias habilitadas para GPU
<a name="managed-instances-gpu-instance-selection"></a>

Para seleccionar tipos de instancias habilitadas para GPU para las cargas de trabajo de instancias administradas de Amazon ECS, utilice el objeto `instanceRequirements` de la plantilla de lanzamiento del proveedor de capacidad. En el siguiente fragmento se muestran los atributos que se pueden usar para seleccionar instancias habilitadas para GPU.

```
{
  "instanceRequirements": {
    "acceleratorTypes": "gpu",
    "acceleratorCount": 1,
    "acceleratorManufacturers": ["nvidia"]
  }
}
```

En el siguiente fragmento se muestran los atributos que se pueden utilizar para especificar los tipos de instancias habilitadas para la GPU en la plantilla de lanzamiento.

```
{
  "instanceRequirements": {
    "allowedInstanceTypes": ["g4dn.xlarge", "p4de.24xlarge"]
  }
}
```

## Imágenes de contenedores habilitadas para GPU
<a name="managed-instances-gpu-container-images"></a>

Para utilizar las GPU en los contenedores, debe utilizar imágenes de contenedor que contengan las bibliotecas y herramientas de GPU necesarias. NVIDIA proporciona varias imágenes de contenedor prediseñadas que puede utilizar como base para las cargas de trabajo de GPU, incluidas las siguientes:
+ `nvidia:cuda`: imágenes base con el kit de herramientas de CUDA para la computación mediante GPU.
+ `tensorflow/tensorflow:latest-gpu`: TensorFlow con compatibilidad con GPU.
+ `pytorch/pytorch:latest-cuda`: PyTorch con compatibilidad con GPU.

Para ver un ejemplo de definición de tareas para Amazon ECS en instancias administradas de Amazon ECS que implique el uso de GPU, consulte [Especificación de GPU en una definición de tareas de Amazon ECS](ecs-gpu-specifying.md).

## Consideraciones
<a name="gpu-considerations"></a>

**nota**  
La compatibilidad con el tipo de familia de instancias g2 ha quedado obsoleta.  
El tipo de familia de instancias p2 es compatible solo con versiones anteriores a `20230912` de la AMI de Amazon ECS optimizada para GPU. Si necesita seguir usando instancias p2, consulte [Qué hacer si necesita una instancia P2](#p2-instance).  
Las actualizaciones locales de los controladores NVIDIA/CUDA en estos dos tipos de familia de instancias pueden provocar posibles errores en la carga de trabajo de la GPU.

Le recomendamos que tenga en cuenta lo siguiente antes de comenzar a trabajar con GPU en Amazon ECS.
+ Sus clústeres pueden contener una combinación de instancias de contenedor habilitadas para GPU y no habilitadas para GPU.
+ Puede ejecutar cargas de trabajo de GPU en instancias externas. Cuando se registra una instancia externa en el clúster, asegúrese de que la marca `--enable-gpu` se incluya en el script de instalación. Para obtener más información, consulte [Registro de una instancia externa en un clúster de Amazon ECS](ecs-anywhere-registration.md).
+ Debe establecer `ECS_ENABLE_GPU_SUPPORT` en `true` en el archivo de configuración del agente. Para obtener más información, consulte [Configuración del agente de contenedor de Amazon ECS](ecs-agent-config.md).
+ Cuando ejecuta una tarea o crea un servicio, puede utilizar los atributos de tipo de instancia al configurar las restricciones de colocación de tareas para determinar las instancias de contenedor que se lanzan en la tarea. Esto le permite utilizar sus recursos de manera más eficiente. Para obtener más información, consulte [Cómo coloca Amazon ECS las tareas en las instancias de contenedor](task-placement.md).

  El siguiente ejemplo lanza una tarea en una instancia de contenedor `g4dn.xlarge` en el clúster predeterminado.

  ```
  aws ecs run-task --cluster default --task-definition ecs-gpu-task-def \
       --placement-constraints type=memberOf,expression="attribute:ecs.instance-type ==  g4dn.xlarge" --region us-east-2
  ```
+ Para cada contenedor que tiene un requisito de recursos de GPU especificado en la definición de contenedor, Amazon ECS establece el tiempo de ejecución del contenedor en el tiempo de ejecución del contenedor de NVIDIA.
+ Para que el tiempo de ejecución del contenedor NVIDIA funcione correctamente, es preciso establecer algunas variables de entorno en el contenedor. Para obtener una lista de estas variables de entorno, consulte [Specialized Configurations with Docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html?highlight=environment%20variable). Amazon ECS establece el valor de las variables de entorno `NVIDIA_VISIBLE_DEVICES` en una lista de los ID de dispositivo de GPU que Amazon ECS asigna al contenedor. Amazon ECS no establece las demás variables de entorno necesarias. Por tanto, asegúrese de que la imagen del contenedor las establezca o que estén configuradas en la definición de contenedor.
+ La familia del tipo de instancias p5 es compatible con la versión `20230929` y versiones posteriores de la AMI de Amazon ECS optimizada para GPU. 
+ La familia de tipo de instancias g4 es compatible con la versión `20230913` y versiones posteriores de la AMI de Amazon ECS optimizada para GPU. Para obtener más información, consulte [AMI de Linux optimizadas para Amazon ECS](ecs-optimized_AMI.md). No es admitido en el flujo de trabajo de Create Cluster (Crear clúster) en la consola de Amazon ECS. Para utilizar estos tipos de instancias, debe utilizar la consola de Amazon EC2, la AWS CLI o la API, y registrar manualmente las instancias en el clúster.
+ El tipo de instancias p4d.24xlarge solo funciona con CUDA 11 o posterior.
+ La AMI de Amazon ECS optimizada para GPU está habilitada para IPv6, lo que provoca problemas cuando se utiliza `yum`. Para resolverlo, puede configurar que `yum` utilice IPv4 con el siguiente comando.

  ```
  echo "ip_resolve=4" >> /etc/yum.conf
  ```
+  Cuando crea una imagen de contenedor que no utiliza las imágenes base NVIDIA/CUDA, debe establecer la variable de tiempo de ejecución de contenedor `NVIDIA_DRIVER_CAPABILITIES` en uno de los siguientes valores:
  + `utility,compute`
  + `all`

  Para obtener información acerca de cómo establecer la variable, consulte [Control del tiempo de ejecución del contenedor NVIDIA](https://sarus.readthedocs.io/en/stable/user/custom-cuda-images.html#controlling-the-nvidia-container-runtime) en el sitio web de NVIDIA.
+ Las GPU no son compatibles con los contenedores de Windows.

# Lanzamiento de una instancia de contenedor de GPU para Amazon ECS
<a name="gpu-launch"></a>

Para utilizar una instancia de GPU en Amazon ECS en Amazon EC2, debe crear una plantilla de lanzamiento, un archivo de datos de usuario y lanzar la instancia.

A continuación, puede ejecutar una tarea que utilice una definición de tarea configurada para la GPU.

## Uso de una plantilla de inicialización
<a name="gpu-launch-template"></a>

Puede crear una plantilla de lanzamiento.
+ Cree una plantilla de lanzamiento que utilice el identificador de AMI de GPU optimizado para Amazon ECS para la AMI. Para obtener información sobre cómo crear una plantilla de lanzamiento, consulte [Create a new launch template using parameters you define](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-launch-template.html#create-launch-template-define-parameters) en la *Guía del usuario de Amazon EC2*.

  Utilice el ID de AMI del paso anterior para la **imagen de máquina de Amazon**. Para información sobre cómo especificar el identificador de AMI con el parámetro de Systems Manager, consulte [Specify a Systems Manager parameter in a launch template](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-launch-template.html#use-an-ssm-parameter-instead-of-an-ami-id) en la *Guía del usuario de Amazon EC2*.

  Agregue lo siguiente a **Datos de usuario** en la plantilla de lanzamiento. Sustituya *cluster-name* por el nombre de su clúster.

  ```
  #!/bin/bash
  echo ECS_CLUSTER=cluster-name >> /etc/ecs/ecs.config;
  echo ECS_ENABLE_GPU_SUPPORT=true >> /etc/ecs/ecs.config
  ```

## Utilizar AWS CLI
<a name="gpu-launch-cli"></a>

Puede utilizar la AWS CLI para iniciar una instancia de contenedor.

1. Cree un archivo denominado `userdata.toml`. Este archivo se utiliza para los datos de usuario de la instancia. Sustituya *cluster-name* por el nombre de su clúster.

   ```
   #!/bin/bash
   echo ECS_CLUSTER=cluster-name >> /etc/ecs/ecs.config;
   echo ECS_ENABLE_GPU_SUPPORT=true >> /etc/ecs/ecs.config
   ```

1. Ejecute el siguiente comando para obtener el identificador de la IAM de la GPU. Utilice esto en el siguiente paso.

   ```
   aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/gpu/recommended --region us-east-1
   ```

1. Ejecute el siguiente comando para lanzar una instancia de la GPU. Recuerde reemplazar los siguientes parámetros:
   + Sustituya la *subred* por el ID de la subred pública o privada en la que se lanzará la instancia.
   + Sustituya *gpu\$1ami* por el identificador de la AMI del paso anterior.
   + Sustituya *t3.large* por el tipo de instancia que desee usar.
   + Sustituya *región* por su código de región.

   ```
   aws ec2 run-instances --key-name ecs-gpu-example \
      --subnet-id subnet \
      --image-id gpu_ami \
      --instance-type t3.large \
      --region region \
      --tag-specifications 'ResourceType=instance,Tags=[{Key=GPU,Value=example}]' \
      --user-data file://userdata.toml \
      --iam-instance-profile Name=ecsInstanceRole
   ```

1. Ejecute el siguiente comando para comprobar que la instancia de contenedor está registrada en el clúster. Al ejecutar este comando, recuerde reemplazar los siguientes parámetros:
   + Sustituya *clúster* por el nombre del clúster.
   + Sustituya *región* por el código de región.

   ```
   aws ecs list-container-instances --cluster cluster-name --region region
   ```

# Especificación de GPU en una definición de tareas de Amazon ECS
<a name="ecs-gpu-specifying"></a>

Para utilizar las GPU en una instancia de contenedor y el tiempo de ejecución de GPU de Docker, asegúrese de designar el número de GPU que requiere el contenedor en la definición de tareas. Cuando haya contenedores que admiten GPU, el agente de contenedores de Amazon ECS fijará el número deseado de GPU físicas en el contenedor correspondiente. El número de unidades GPU reservadas para todos los contenedores de una tarea no puede superar el número de GPU disponibles en la instancia de contenedor en la que se lanza la tarea. Para obtener más información, consulte [Creación de una definición de tareas de Amazon ECS mediante la consola](create-task-definition.md).

**importante**  
Si los requisitos de GPU no se especifican en la definición de tareas, la tarea utilizará el tiempo de ejecución predeterminado de Docker.

A continuación, se muestra el formato JSON de los requisitos de GPU en una definición de tareas:

```
{
  "containerDefinitions": [
     {
        ...
        "resourceRequirements" : [
            {
               "type" : "GPU", 
               "value" : "2"
            }
        ],
     },
...
}
```

El ejemplo siguiente muestra la sintaxis de un contenedor Docker que especifica un requisito de GPU. Este contenedor utiliza dos GPU, ejecuta la utilidad `nvidia-smi` y, luego, se cierra.

```
{
  "containerDefinitions": [
    {
      "memory": 80,
      "essential": true,
      "name": "gpu",
      "image": "nvidia/cuda:11.0.3-base",
      "resourceRequirements": [
         {
           "type":"GPU",
           "value": "2"
         }
      ],
      "command": [
        "sh",
        "-c",
        "nvidia-smi"
      ],
      "cpu": 100
    }
  ],
  "family": "example-ecs-gpu"
}
```

El siguiente ejemplo de definición de tarea muestra un contenedor de TensorFlow que imprime el número de GPU disponibles. La tarea se pone en marcha en instancias administradas de Amazon ECS, requiere una GPU y utiliza una instancia de `g4dn.xlarge`.

```
{
  "family": "tensorflow-gpu",
  "networkMode": "awsvpc",
  "executionRoleArn": "arn:aws:iam::account-id:role/ecsTaskExecutionRole",
  "containerDefinitions": [
    {
      "name": "tensorflow",
      "image": "tensorflow/tensorflow:latest-gpu",
      "essential": true,
      "command": [
        "python",
        "-c",
        "import tensorflow as tf; print('Num GPUs Available: ', len(tf.config.list_physical_devices('GPU')))"
      ],
      "resourceRequirements": [
        {
          "type": "GPU",
          "value": "1"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/tensorflow-gpu",
          "awslogs-region": "region",
          "awslogs-stream-prefix": "ecs"
        }
      }
    }
  ],
  "requiresCompatibilities": [
    "MANAGED_INSTANCES"
  ],
  "cpu": "4096",
  "memory": "8192",
}
```

## Uso compartido de GPU
<a name="share-gpu"></a>

Si quiere compartir las GPU, tiene que configurar lo siguiente:

1. Elimine los requisitos de recursos de GPU de las definiciones de tareas para que Amazon ECS no reserve ninguna GPU que deba compartirse.

1. Agregue los siguientes datos de usuario a las instancias cuando quiera compartir las GPU. Esto hará que nvidia sea el tiempo de ejecución predeterminado del contenedor de Docker en la instancia de contenedor, de modo que todos los contenedores de Amazon ECS puedan usar las GPU. Para obtener más información acerca de los scripts de datos de usuario, consulte [Ejecución de comandos al lanzar una instancia de EC2 con la entrada de datos de usuario](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html) en la *Guía del usuario de Amazon EC2*.

   ```
   const userData = ec2.UserData.forLinux();
    userData.addCommands(
    'sudo rm /etc/sysconfig/docker',
    'echo DAEMON_MAXFILES=1048576 | sudo tee -a /etc/sysconfig/docker',
    'echo OPTIONS="--default-ulimit nofile=32768:65536 --default-runtime nvidia" | sudo tee -a /etc/sysconfig/docker',
    'echo DAEMON_PIDFILE_TIMEOUT=10 | sudo tee -a /etc/sysconfig/docker',
    'sudo systemctl restart docker',
   );
   ```

1. Configure la variable de entorno `NVIDIA_VISIBLE_DEVICES` en el contenedor. Para hacerlo, especifique la variable de entorno en la definición de tareas. Para obtener información sobre los valores válidos, consulte la [Enumeración de GPU](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html#gpu-enumeration) en el sitio de documentación de NVIDIA.

## Qué hacer si necesita una instancia P2
<a name="p2-instance"></a>

Si necesita utilizar la instancia P2, puede usar una de las siguientes opciones para continuar usando las instancias.

Debe modificar los datos de usuario de la instancia para ambas opciones. Para obtener más información acerca de los scripts de datos de usuario, consulte [Ejecución de comandos al lanzar una instancia de EC2 con la entrada de datos de usuario](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html) en la *Guía del usuario de Amazon EC2*.

**Utilizar la última AMI optimizada para GPU compatible**

Puede usar la versión `20230906` de la AMI optimizada para GPU y agregar lo siguiente a los datos de usuario de la instancia.

Sustituya cluster-name por el nombre de su clúster.

```
#!/bin/bash
echo "exclude=*nvidia* *cuda*" >> /etc/yum.conf
echo "ECS_CLUSTER=cluster-name" >> /etc/ecs/ecs.config
```

**Utilizar la última AMI optimizada para GPU y actualizar los datos de usuario**

Puede agregar lo siguiente a los datos de usuario de la instancia. Esto desinstala los controladores Nvidia 535/Cuda12.2 y, a continuación, instala los controladores Nvidia 470/Cuda11.4 y corrige la versión.

```
#!/bin/bash
yum remove -y cuda-toolkit* nvidia-driver-latest-dkms*
tmpfile=$(mktemp)
cat >$tmpfile <<EOF
[amzn2-nvidia]
name=Amazon Linux 2 Nvidia repository
mirrorlist=\$awsproto://\$amazonlinux.\$awsregion.\$awsdomain/\$releasever/amzn2-nvidia/latest/\$basearch/mirror.list
priority=20
gpgcheck=1
gpgkey=https://developer.download.nvidia.com/compute/cuda/repos/rhel7/x86_64/7fa2af80.pub
enabled=1
exclude=libglvnd-*
EOF

mv $tmpfile /etc/yum.repos.d/amzn2-nvidia-tmp.repo
yum install -y system-release-nvidia cuda-toolkit-11-4 nvidia-driver-latest-dkms-470.182.03
yum install -y libnvidia-container-1.4.0 libnvidia-container-tools-1.4.0 nvidia-container-runtime-hook-1.4.0 docker-runtime-nvidia-1

echo "exclude=*nvidia* *cuda*" >> /etc/yum.conf
nvidia-smi
```

**Crear su propia AMI optimizada para GPU compatible con P2**

Puede crear su propia AMI optimizada para la GPU de Amazon ECS personalizada que sea compatible con las instancias P2 y, a continuación, lanzar las instancias P2 mediante la AMI.

1. Ejecute el siguiente comando para clonar el `amazon-ecs-ami repo`.

   ```
   git clone https://github.com/aws/amazon-ecs-ami
   ```

1. Configure el agente de Amazon ECS requerido y las versiones de la AMI de Amazon Linux de origen en `release.auto.pkrvars.hcl` o `overrides.auto.pkrvars.hcl`.

1. Ejecute el siguiente comando para crear una AMI de EC2 privada compatible con P2.

   Sustituya la región por la región de la instancia.

   ```
   REGION=region make al2keplergpu
   ```

1. Utilice la AMI con los siguientes datos de usuario de la instancia para conectarse al clúster de Amazon ECS.

   Sustituya cluster-name por el nombre de su clúster.

   ```
   #!/bin/bash
   echo "ECS_CLUSTER=cluster-name" >> /etc/ecs/ecs.config
   ```

# Definiciones de tareas de Amazon ECS para cargas de trabajo de transcodificación de video
<a name="ecs-vt1"></a>

Para utilizar cargas de trabajo de transcodificación de video en Amazon ECS, registre las instancias [VT1 de Amazon EC2](https://aws.amazon.com/ec2/instance-types/vt1/). Una vez registradas estas instancias, puede ejecutar cargas de trabajo de transcodificación de video en directo preprocesadas como tareas en Amazon ECS. Las instancias VT1 de Amazon EC2 utilizan tarjetas de transcodificación multimedia Xilinx U30 para acelerar las cargas de trabajo de transcodificación de video en directo preprocesadas.

**nota**  
Para obtener instrucciones sobre cómo ejecutar cargas de trabajo de transcodificación de video en contenedores que no sean de Amazon ECS, consulte la [documentación de Xilinx](https://xilinx.github.io/video-sdk/v1.5/container_setup.html#working-with-docker-vt1).

## Consideraciones
<a name="ecs-vt1-considerations"></a>

Antes de comenzar a implementar instancias VT1 en Amazon ECS, considere lo siguiente:
+ Los clústeres pueden contener instancias VT1 y no VT1 combinadas.
+ Necesita una aplicación Linux que utilice tarjetas de transcodificación multimedia Xilinx U30 con códecs AVC (H.264) y HEVC (H.265) acelerados.
**importante**  
Es posible que las aplicaciones que utilizan otros códecs no tengan un rendimiento mejorado en las instancias VT1.
+ En una tarjeta U30 solo se puede ejecutar una tarea de transcodificación. Cada tarjeta tiene dos dispositivos asociados a ella. Puede ejecutar tantas tareas de transcodificación como tarjetas haya para cada instancia VT1.
+ Cuando cree un servicio o ejecute una tarea independiente, puede utilizar los atributos de tipo de instancia al configurar las restricciones de ubicación de tareas. Esto garantiza que la tarea se lance en la instancia de contenedor que especifique. Al hacerlo, puede asegurarse de que utiliza los recursos de forma eficaz y de que las tareas de las cargas de trabajo de transcodificación de video se encuentran en las instancias VT1. Para obtener más información, consulte [Cómo coloca Amazon ECS las tareas en las instancias de contenedor](task-placement.md).

  En el ejemplo siguiente, se ejecuta una tarea en una instancia `vt1.3xlarge` del clúster `default`.

  ```
  aws ecs run-task \
       --cluster default \
       --task-definition vt1-3xlarge-xffmpeg-processor \
       --placement-constraints type=memberOf,expression="attribute:ecs.instance-type == vt1.3xlarge"
  ```
+ Configura un contenedor para que utilice la tarjeta U30 específica disponible en la instancia de contenedor del host. Para ello, utilice el parámetro `linuxParameters` y especifique los detalles del dispositivo. Para obtener más información, consulte [Requisitos de definición de tareas](#ecs-vt1-requirements).

## Uso de una AMI VT1
<a name="ecs-vt1-ami"></a>

Tiene dos opciones para ejecutar una AMI en Amazon EC2 para instancias de contenedores de Amazon ECS. La primera opción es utilizar la AMI oficial de Xilinx en AWS Marketplace. La segunda opción es crear su propia AMI desde el repositorio de muestra.
+ [Xilinx ofrece AMI en AWS Marketplace](https://aws.amazon.com/marketplace/pp/prodview-phvk6d4mq3hh6).
+ Amazon ECS proporciona un repositorio de muestra que puede utilizar para crear una AMI para cargas de trabajo de transcodificación de video. Esta AMI viene con los controladores Xilinx U30. Puede encontrar el repositorio que contiene scripts de Packer en [GitHub](https://github.com/aws-samples/aws-vt-baseami-pipeline). Para obtener más información sobre Packer, consulte la [documentación de Packer](https://developer.hashicorp.com/packer/docs).

## Requisitos de definición de tareas
<a name="ecs-vt1-requirements"></a>

Para ejecutar contenedores de transcodificación de video en Amazon ECS, la definición de tareas debe contener una aplicación de transcodificación de video que utilice los códecs H.264/AVC y H.265/HEVC acelerados. Para crear una imagen de contenedor, siga los pasos que se indican en el [GitHub de Xilinx](https://xilinx.github.io/video-sdk/v1.5/container_setup.html#creating-a-docker-image-for-vt1-usage).

La definición de tareas debe ser específica del tipo de instancia. Los tipos de instancias son 3xlarge, 6xlarge y 24xlarge. Debe configurar un contenedor para que utilice los dispositivos Xilinx U30 específicos disponibles en la instancia de contenedor del host. Para ello, utilice el parámetro `linuxParameters`. En la tabla que se muestra a continuación se detallan las tarjetas y los SoC de dispositivos específicos de cada tipo de instancia.


| Tipo de instancia | vCPU | RAM (GiB) | Tarjetas aceleradoras U30 | Dispositivos SoC XCU30 direccionables | Rutas del dispositivo | 
| --- | --- | --- | --- | --- | --- | 
| vt1.3xlarge | 12 | 24 | 1 | 2 | /dev/dri/renderD128,/dev/dri/renderD129 | 
| vt1.6xlarge | 24 | 48 | 2 | 4 | /dev/dri/renderD128,/dev/dri/renderD129,/dev/dri/renderD130,/dev/dri/renderD131 | 
| vt1.24xlarge | 96 | 182 | 8 | 16 | /dev/dri/renderD128,/dev/dri/renderD129,/dev/dri/renderD130,/dev/dri/renderD131,/dev/dri/renderD132,/dev/dri/renderD133,/dev/dri/renderD134,/dev/dri/renderD135,/dev/dri/renderD136,/dev/dri/renderD137,/dev/dri/renderD138,/dev/dri/renderD139,/dev/dri/renderD140,/dev/dri/renderD141,/dev/dri/renderD142,/dev/dri/renderD143 | 

**importante**  
Si la definición de tareas enumera los dispositivos que la instancia de EC2 no tiene, la tarea no se ejecuta. Cuando se produce·un·error·en la tarea, aparece el siguiente mensaje de error en `stoppedReason`: `CannotStartContainerError: Error response from daemon: error gathering device information while adding custom device "/dev/dri/renderD130": no such file or directory`.

# Especificación de la transcodificación de video en una definición de tareas de Amazon ECS
<a name="task-def-video-transcode"></a>

En el siguiente ejemplo, se proporciona la sintaxis que se utiliza para la definición de tareas de un contenedor de Linux en Amazon EC2. Esta definición de tareas se usa para imágenes de contenedor que se crean siguiendo el procedimiento proporcionado en la [documentación de Xilinx](https://xilinx.github.io/video-sdk/v1.5/container_setup.html#creating-a-docker-image-for-vt1-usage). Si utiliza este ejemplo, reemplace `image` con su propia imagen y copie los archivos de video en la instancia del directorio `/home/ec2-user`.

------
#### [ vt1.3xlarge ]

1. Cree un archivo de texto denominado `vt1-3xlarge-ffmpeg-linux.json` con el siguiente contenido.

   ```
   {
       "family": "vt1-3xlarge-xffmpeg-processor",
       "requiresCompatibilities": ["EC2"],
       "placementConstraints": [
           {
               "type": "memberOf",
               "expression": "attribute:ecs.os-type == linux"
           },
           {
               "type": "memberOf",
               "expression": "attribute:ecs.instance-type == vt1.3xlarge"
           }
       ],
       "containerDefinitions": [
           {
               "entryPoint": [
                   "/bin/bash",
                   "-c"
               ],
               "command": ["/video/ecs_ffmpeg_wrapper.sh"],
               "linuxParameters": {
                   "devices": [
                       {
                           "containerPath": "/dev/dri/renderD128",
                           "hostPath": "/dev/dri/renderD128",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD129",
                           "hostPath": "/dev/dri/renderD129",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       }
                   ]
               },
               "mountPoints": [
                   {
                       "containerPath": "/video",
                       "sourceVolume": "video_file"
                   }
               ],
               "cpu": 0,
               "memory": 12000,
               "image": "0123456789012.dkr.ecr.us-west-2.amazonaws.com/aws/xilinx-xffmpeg",
               "essential": true,
               "name": "xilinix-xffmpeg"
           }
       ],
       "volumes": [
           {
               "name": "video_file",
               "host": {"sourcePath": "/home/ec2-user"}
           }
       ]
   }
   ```

1. Registre la definición de tareas.

   ```
   aws ecs register-task-definition --family vt1-3xlarge-xffmpeg-processor --cli-input-json file://vt1-3xlarge-xffmpeg-linux.json --region us-east-1
   ```

------
#### [ vt1.6xlarge ]

1. Cree un archivo de texto denominado `vt1-6xlarge-ffmpeg-linux.json` con el siguiente contenido.

   ```
   {
       "family": "vt1-6xlarge-xffmpeg-processor",
       "requiresCompatibilities": ["EC2"],
       "placementConstraints": [
           {
               "type": "memberOf",
               "expression": "attribute:ecs.os-type == linux"
           },
           {
               "type": "memberOf",
               "expression": "attribute:ecs.instance-type == vt1.6xlarge"
           }
       ],
       "containerDefinitions": [
           {
               "entryPoint": [
                   "/bin/bash",
                   "-c"
               ],
               "command": ["/video/ecs_ffmpeg_wrapper.sh"],
               "linuxParameters": {
                   "devices": [
                       {
                           "containerPath": "/dev/dri/renderD128",
                           "hostPath": "/dev/dri/renderD128",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD129",
                           "hostPath": "/dev/dri/renderD129",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD130",
                           "hostPath": "/dev/dri/renderD130",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD131",
                           "hostPath": "/dev/dri/renderD131",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       }
                   ]
               },
               "mountPoints": [
                   {
                       "containerPath": "/video",
                       "sourceVolume": "video_file"
                   }
               ],
               "cpu": 0,
               "memory": 12000,
               "image": "0123456789012.dkr.ecr.us-west-2.amazonaws.com/aws/xilinx-xffmpeg",
               "essential": true,
               "name": "xilinix-xffmpeg"
           }
       ],
       "volumes": [
           {
               "name": "video_file",
               "host": {"sourcePath": "/home/ec2-user"}
           }
       ]
   }
   ```

1. Registre la definición de tareas.

   ```
   aws ecs register-task-definition --family vt1-6xlarge-xffmpeg-processor --cli-input-json file://vt1-6xlarge-xffmpeg-linux.json --region us-east-1
   ```

------
#### [ vt1.24xlarge ]

1. Cree un archivo de texto denominado `vt1-24xlarge-ffmpeg-linux.json` con el siguiente contenido.

   ```
   {
       "family": "vt1-24xlarge-xffmpeg-processor",
       "requiresCompatibilities": ["EC2"],
       "placementConstraints": [
           {
               "type": "memberOf",
               "expression": "attribute:ecs.os-type == linux"
           },
           {
               "type": "memberOf",
               "expression": "attribute:ecs.instance-type == vt1.24xlarge"
           }
       ],
       "containerDefinitions": [
           {
               "entryPoint": [
                   "/bin/bash",
                   "-c"
               ],
               "command": ["/video/ecs_ffmpeg_wrapper.sh"],
               "linuxParameters": {
                   "devices": [
                       {
                           "containerPath": "/dev/dri/renderD128",
                           "hostPath": "/dev/dri/renderD128",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD129",
                           "hostPath": "/dev/dri/renderD129",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD130",
                           "hostPath": "/dev/dri/renderD130",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD131",
                           "hostPath": "/dev/dri/renderD131",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD132",
                           "hostPath": "/dev/dri/renderD132",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD133",
                           "hostPath": "/dev/dri/renderD133",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD134",
                           "hostPath": "/dev/dri/renderD134",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD135",
                           "hostPath": "/dev/dri/renderD135",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD136",
                           "hostPath": "/dev/dri/renderD136",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD137",
                           "hostPath": "/dev/dri/renderD137",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD138",
                           "hostPath": "/dev/dri/renderD138",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD139",
                           "hostPath": "/dev/dri/renderD139",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD140",
                           "hostPath": "/dev/dri/renderD140",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD141",
                           "hostPath": "/dev/dri/renderD141",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD142",
                           "hostPath": "/dev/dri/renderD142",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD143",
                           "hostPath": "/dev/dri/renderD143",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       }
                   ]
               },
               "mountPoints": [
                   {
                       "containerPath": "/video",
                       "sourceVolume": "video_file"
                   }
               ],
               "cpu": 0,
               "memory": 12000,
               "image": "0123456789012.dkr.ecr.us-west-2.amazonaws.com/aws/xilinx-xffmpeg",
               "essential": true,
               "name": "xilinix-xffmpeg"
           }
       ],
       "volumes": [
           {
               "name": "video_file",
               "host": {"sourcePath": "/home/ec2-user"}
           }
       ]
   }
   ```

1. Registre la definición de tareas.

   ```
   aws ecs register-task-definition --family vt1-24xlarge-xffmpeg-processor --cli-input-json file://vt1-24xlarge-xffmpeg-linux.json --region us-east-1
   ```

------

# Definiciones de tareas de Amazon ECS para cargas de trabajo de machine learning de AWS Neuron
<a name="ecs-inference"></a>

Puede registrar instancias [Trn1 de Amazon EC2](https://aws.amazon.com/ec2/instance-types/trn1/), [Trn2 de Amazon EC2](https://aws.amazon.com/ec2/instance-types/trn2/), [Inf1 de Amazon EC2](https://aws.amazon.com/ec2/instance-types/inf1/) e [Inf2 de Amazon EC2](https://aws.amazon.com/ec2/instance-types/inf2/) en los clústeres para cargas de trabajo de machine learning.

Las instancias Trn1 y Trn2 de Amazon EC2 funcionan con chips de [AWS Trainium](https://aws.amazon.com/ai/machine-learning/trainium/). Estas instancias proporcionan capacitación de alto rendimiento y bajo costo para el machine learning en la nube. Puede entrenar un modelo de inferencia de machine learning mediante un marco de machine learning con AWS Neuron en una instancia de Trn1 y Trn2. A continuación, puede ejecutar el modelo en una instancia de Inf1 o de Inf2 para usar la aceleración de los chips de AWS Inferentia.

Las instancias Inf1 e Inf2 de Amazon EC2 funcionan con chips de [AWS Inferentia](https://aws.amazon.com/ai/machine-learning/inferentia/), que proporcionan un alto rendimiento y una inferencia de menor costo en la nube.

Los modelos de machine learning se implementan en contenedores mediante [AWS Neuron](https://aws.amazon.com/ai/machine-learning/neuron/), que es un kit de desarrollo de software (SDK) especializado. SDK consiste en un compilador, tiempo de ejecución y herramientas de perfilado que optimizan el rendimiento de machine learning de los chips de AWS. AWS Neuron admite marcos de machine learning populares como TensorFlow, PyTorch y Apache MXNet.

## Consideraciones
<a name="ecs-inference-considerations"></a>

Antes de comenzar a implementar Neuron en Amazon ECS, tenga en cuenta lo siguiente:
+ Los clústeres pueden contener una combinación de instancias Trn1, Trn2, Inf1, Inf2 y otras instancias.
+ Necesita una aplicación de Linux en un contenedor que use un marco de machine learning compatible con AWS Neuron.
**importante**  
Es posible que las aplicaciones que utilizan otros marcos no tengan un rendimiento mejorado en las instancias Trn1, Trn2, Inf1 e Inf2.
+ Solo se puede ejecutar una tarea de inferencia o entrenamiento de inferencias en cada chip [AWS Trainium](https://aws.amazon.com/ai/machine-learning/trainium/) o [AWS Inferentia](https://aws.amazon.com/ai/machine-learning/inferentia/). Para Inf1, cada chip tiene 4 NeuronCore. Para Trn1, Trn2 e Inf2, cada chip tiene 2 NeuronCore. Puede ejecutar tantas tareas como chips haya para cada instancia de Trn1, Trn2, Inf1 e Inf2.
+ Cuando cree un servicio o ejecute una tarea independiente, puede utilizar los atributos de tipo de instancia al configurar las restricciones de ubicación de tareas. Esto garantiza que la tarea se lance en la instancia de contenedor que especifique. Al hacerlo, puede optimizar la utilización general de los recursos y garantizar que las tareas de las cargas de trabajo de inferencia se encuentren en las instancias Trn1, Trn2, Inf1 e Inf2. Para obtener más información, consulte [Cómo coloca Amazon ECS las tareas en las instancias de contenedor](task-placement.md).

  En el ejemplo siguiente, se ejecuta una tarea en una instancia `Inf1.xlarge` del clúster `default`.

  ```
  aws ecs run-task \
       --cluster default \
       --task-definition ecs-inference-task-def \
       --placement-constraints type=memberOf,expression="attribute:ecs.instance-type == Inf1.xlarge"
  ```
+ Los requisitos de recursos de Neuron no se pueden definir en una definición de tareas. En su lugar, configure un contenedor para que use chips de AWS Trainium o de AWS Inferentia específicos disponibles en la instancia de contenedor del host. Para ello, use el parámetro `linuxParameters` y especifique los detalles del dispositivo. Para obtener más información, consulte [Requisitos de definición de tareas](#ecs-inference-requirements).

## Uso de la AMI de Amazon Linux 2023 (Neuron) optimizada para Amazon ECS
<a name="ecs-inference-ami2023"></a>

Amazon ECS proporciona una AMI optimizada para Amazon ECS que se basa en Amazon Linux 2023 para cargas de trabajo de AWS Trainium y AWS Inferentia. Viene con los controladores AWS Neuron y el tiempo de ejecución para Docker. Esta AMI facilita la ejecución de cargas de trabajo de inferencia de machine learning en Amazon ECS.

Recomendamos utilizar la AMI de Amazon Linux 2023 (Neuron) optimizada para Amazon ECS cuando se lanzan las instancias Trn1, Inf1 e Inf2 de Amazon EC2. 

Puede recuperar la AMI actual de Amazon Linux 2023 (Neuron) optimizada para Amazon ECS a través de la AWS CLI con el siguiente comando.

```
aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2023/neuron/recommended
```

## Requisitos de definición de tareas
<a name="ecs-inference-requirements"></a>

Para implementar Neuron en Amazon ECS, la definición de tareas debe contener la definición de contenedor correspondiente a un contenedor prefabricado que atienda al modelo de inferencia para TensorFlow. Este es proporcionado por AWS Deep Learning Containers. Dentro del contenedor, se incluye el tiempo de ejecución de AWS Neuron y la aplicación TensorFlow Serving. Al iniciarse, este contenedor obtiene su modelo de Amazon S3, lanza Neuron TensorFlow Serving con el modelo guardado y espera las solicitudes de predicción. En el ejemplo a continuación, la imagen de contenedor contiene TensorFlow 1.15 y Ubuntu 18.04. Se conserva una lista completa de Deep Learning Containers prefabricados optimizados para Neuron en GitHub. Para obtener más información, consulte [Utilizar AWS Neuron TensorFlow Serving](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-inferentia-tf-neuron-serving.html).

```
763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-neuron:1.15.4-neuron-py37-ubuntu18.04
```

Como alternativa, puede crear su propia imagen de contenedor de sidecar de Neuron. Para obtener más información, consulte [Tutorial: Neuron TensorFlow Serving](https://github.com/aws-neuron/aws-neuron-sdk/blob/master/frameworks/tensorflow/tensorflow-neuron/tutorials/tutorials-tensorflow-utilizing-neuron-capabilities.rst) en la *Guía para desarrolladores de AWS Deep Learning AMIs*.

La definición de la tarea debe ser específica para un único tipo de instancia. Debe configurar un contenedor para que use los dispositivos AWS Trainium o AWS Inferentia específicos disponibles en la instancia de contenedor del host. Para ello, utilice el parámetro `linuxParameters`. Para una definición de una tarea de ejemplo, consulte [Especificación de machine learning de AWS Neuron en una definición de tareas de Amazon ECS](ecs-inference-task-def.md). En la tabla que se muestra a continuación se detallan los chips específicos de cada tipo de instancia.


| Tipo de instancia | vCPU | RAM (GiB) | Chips de aceleradores AWS ML | Rutas del dispositivo | 
| --- | --- | --- | --- | --- | 
| trn1.2xlarge | 8 | 32 | 1 | /dev/neuron0 | 
| trn1.32xlarge | 128 | 512 | 16 |  /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5, /dev/neuron6, /dev/neuron7, /dev/neuron8, /dev/neuron9, /dev/neuron10, /dev/neuron11, /dev/neuron12, /dev/neuron13, /dev/neuron14, /dev/neuron15  | 
| trn2.48xlarge | 192 | 1536 | 16 |  /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5, /dev/neuron6, /dev/neuron7, /dev/neuron8, /dev/neuron9, /dev/neuron10, /dev/neuron11, /dev/neuron12, /dev/neuron13, /dev/neuron14, /dev/neuron15  | 
| inf1.xlarge | 4 | 8 | 1 | /dev/neuron0 | 
| inf1.2xlarge | 8 | 16 | 1 | /dev/neuron0 | 
| inf1.6xlarge | 24 | 48 | 4 | /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3 | 
| inf1.24xlarge | 96 | 192 | 16 |  /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5, /dev/neuron6, /dev/neuron7, /dev/neuron8, /dev/neuron9, /dev/neuron10, /dev/neuron11, /dev/neuron12, /dev/neuron13, /dev/neuron14, /dev/neuron15  | 
| inf2.xlarge | 8 | 16 | 1 | /dev/neuron0 | 
| inf2.8xlarge | 32 | 64 | 1 | /dev/neuron0 | 
| inf2.24xlarge | 96 | 384 | 6 | /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5,  | 
| inf2.48xlarge | 192 | 768 | 12 | /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5, /dev/neuron6, /dev/neuron7, /dev/neuron8, /dev/neuron9, /dev/neuron10, /dev/neuron11 | 

# Especificación de machine learning de AWS Neuron en una definición de tareas de Amazon ECS
<a name="ecs-inference-task-def"></a>

A continuación, se muestra un ejemplo de definición de tarea de Linux para `inf1.xlarge` en el que se muestra la sintaxis que se va a usar.

```
{
    "family": "ecs-neuron",
    "requiresCompatibilities": ["EC2"],
    "placementConstraints": [
        {
            "type": "memberOf",
            "expression": "attribute:ecs.os-type == linux"
        },
        {
            "type": "memberOf",
            "expression": "attribute:ecs.instance-type == inf1.xlarge"
        }
    ],
    "executionRoleArn": "${YOUR_EXECUTION_ROLE}",
    "containerDefinitions": [
        {
            "entryPoint": [
                "/usr/local/bin/entrypoint.sh",
                "--port=8500",
                "--rest_api_port=9000",
                "--model_name=resnet50_neuron",
                "--model_base_path=s3://amzn-s3-demo-bucket/resnet50_neuron/"
            ],
            "portMappings": [
                {
                    "hostPort": 8500,
                    "protocol": "tcp",
                    "containerPort": 8500
                },
                {
                    "hostPort": 8501,
                    "protocol": "tcp",
                    "containerPort": 8501
                },
                {
                    "hostPort": 0,
                    "protocol": "tcp",
                    "containerPort": 80
                }
            ],
            "linuxParameters": {
                "devices": [
                    {
                        "containerPath": "/dev/neuron0",
                        "hostPath": "/dev/neuron0",
                        "permissions": [
                            "read",
                            "write"
                        ]
                    }
                ],
                "capabilities": {
                    "add": [
                        "IPC_LOCK"
                    ]
                }
            },
            "cpu": 0,
            "memoryReservation": 1000,
            "image": "763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-neuron:1.15.4-neuron-py37-ubuntu18.04",
            "essential": true,
            "name": "resnet50"
        }
    ]
}
```

# Definiciones de tareas de Amazon ECS para instancias de aprendizaje profundo
<a name="ecs-dl1"></a>

Para utilizar cargas de trabajo de aprendizaje profundo en Amazon ECS, registre las instancias [DL1 de Amazon EC2](https://aws.amazon.com/ec2/instance-types/dl1/) en los clústeres. Las instancias DL1 de Amazon EC2 funcionan con aceleradores Gaudi de Habana Labs (una empresa de Intel). Utilice el SDK de Habana SynapseAI para conectarse a los aceleradores Gaudi de Habana. El SDK admite los marcos de machine learning populares TensorFlow y PyTorch.

## Consideraciones
<a name="ecs-dl1-considerations"></a>

Antes de comenzar a implementar instancias DL1 en Amazon ECS, tenga en cuenta lo siguiente:
+ Los clústeres pueden contener instancias DL1 y no DL1 combinadas.
+ Cuando crea un servicio o ejecuta una tarea independiente, puede utilizar los atributos de tipo de instancias concretamente al configurar las restricciones de ubicación de tareas para asegurarse de que la tarea se lance en la instancia de contenedor que especifique. Al hacerlo, se asegura de que los recursos se utilizan de manera eficaz y de que las tareas de las cargas de trabajo de aprendizaje profundo se encuentran en las instancias DL1. Para obtener más información, consulte [Cómo coloca Amazon ECS las tareas en las instancias de contenedor](task-placement.md).

  En el ejemplo siguiente, se ejecuta una tarea en una instancia `dl1.24xlarge` del clúster `default`.

  ```
  aws ecs run-task \
       --cluster default \
       --task-definition ecs-dl1-task-def \
       --placement-constraints type=memberOf,expression="attribute:ecs.instance-type == dl1.24xlarge"
  ```

## Uso de una AMI DL1
<a name="ecs-dl1-ami"></a>

Tiene tres opciones para ejecutar una AMI en instancias DL1 de Amazon EC2 para Amazon ECS:
+ AMI de AWS Marketplace proporcionadas por Habana [aquí](https://aws.amazon.com/marketplace/pp/prodview-h24gzbgqu75zq).
+ AMI de aprendizaje profundo de Habana proporcionadas por Amazon Web Services. Como no está incluido, debe instalar el agente de contenedor de Amazon ECS por separado.
+ Utilice Packer para crear una AMI personalizada proporcionada por el [repositorio de GitHub](https://github.com/aws-samples/aws-habana-baseami-pipeline). Para obtener más información, consulte la [documentación de Packer](https://developer.hashicorp.com/packer/docs).

# Especificación del aprendizaje profundo en una definición de tareas de Amazon ECS
<a name="ecs-dl1-requirements"></a>

Para ejecutar contenedores de aprendizaje profundo acelerados Gaudi de Habana en Amazon ECS, la definición de tareas debe contener la definición de contenedor de un contenedor prefabricado que atienda el modelo de aprendizaje profundo de TensorFlow o PyTorch utilizando el software SynapseAI de Habana proporcionado por AWS Deep Learning Containers.

La siguiente imagen de contenedor contiene TensorFlow 2.7.0 y Ubuntu 20.04. En GitHub se conserva una lista completa de contenedores de aprendizaje profundo prefabricados optimizados para aceleradores Gaudi de Habana. Para obtener más información, consulte [Habana Training Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#habana-training-containers) (Contenedores de capacitación de Habana).

```
763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-training-habana:2.7.0-hpu-py38-synapseai1.2.0-ubuntu20.04
```

A continuación, se muestra un ejemplo de definición de tareas de contenedores Linux en Amazon EC2 en el que se muestra la sintaxis que se va a utilizar. En este ejemplo se utiliza una imagen que contiene la herramienta de interfaz de administración del sistema de Habana Labs (HL-SMI) que se encuentra aquí: `vault.habana.ai/gaudi-docker/1.1.0/ubuntu20.04/habanalabs/tensorflow-installer-tf-cpu-2.6.0:1.1.0-614`

```
{
    "family": "dl-test",
    "requiresCompatibilities": ["EC2"],
    "placementConstraints": [
        {
            "type": "memberOf",
            "expression": "attribute:ecs.os-type == linux"
        },
        {
            "type": "memberOf",
            "expression": "attribute:ecs.instance-type == dl1.24xlarge"
        }
    ],
    "networkMode": "host",
    "cpu": "10240",
    "memory": "1024",
    "containerDefinitions": [
        {
            "entryPoint": [
                "sh",
                "-c"
            ],
            "command": ["hl-smi"],
            "cpu": 8192,
            "environment": [
                {
                    "name": "HABANA_VISIBLE_DEVICES",
                    "value": "all"
                }
            ],
            "image": "vault.habana.ai/gaudi-docker/1.1.0/ubuntu20.04/habanalabs/tensorflow-installer-tf-cpu-2.6.0:1.1.0-614",
            "essential": true,
            "name": "tensorflow-installer-tf-hpu"
        }
    ]
}
```

# Definiciones de tareas de Amazon ECS para cargas de trabajo de ARM de 64 bits
<a name="ecs-arm64"></a>

Amazon ECS admite el uso de aplicaciones ARM de 64 bits. Puede ejecutar las aplicaciones en la plataforma con la tecnología de los [procesadores de AWS Graviton](https://aws.amazon.com/ec2/graviton/). Es adecuada para una gran variedad de cargas de trabajo. Entre ellas se incluyen cargas de trabajo tales como servidores de aplicaciones, microservicios, computación de alto rendimiento, inferencia de machine learning basada en CPU, codificación de video, automatización de diseño electrónico, juegos, bases de datos de código abierto y cachés en memoria.

## Consideraciones
<a name="ecs-arm64-considerations"></a>

Antes de comenzar a implementar definiciones de tareas que utilizan la arquitectura de ARM de 64 bits, tenga en cuenta lo siguiente:
+ Las aplicaciones pueden utilizar Fargate o EC2.
+ Las aplicaciones solo pueden utilizar el sistema operativo Linux.
+ Para el tipo Fargate, las aplicaciones deben utilizar la versión de plataforma Fargate `1.4.0` o posterior.
+ Las aplicaciones pueden utilizar Fluent Bit o CloudWatch para supervisión.
+ Para Fargate, las siguientes Regiones de AWS no admiten cargas de trabajo ARM de 64 bits:
  + Este de EE. UU. (Norte de Virginia), la zona de disponibilidad `use1-az3`
+  Para EC2, consulte lo siguiente para comprobar que la región en la que se encuentra admite el tipo de instancia que desea utilizar:
  + [Instancias M6g de Amazon EC2](https://aws.amazon.com/ec2/instance-types/m6)
  +  [Instancias T4g de Amazon EC2](https://aws.amazon.com/ec2/instance-types/t4/)
  +  [Instancias C6g de Amazon EC2](https://aws.amazon.com/ec2/instance-types/c6g/)
  +  [Instancias R6gd de Amazon EC2](https://aws.amazon.com/ec2/instance-types/r6/)
  +  [Instancias X2gd de Amazon EC2](https://aws.amazon.com/ec2/instance-types/x2/)

  También puede utilizar el comando `describe-instance-type-offerings` de Amazon EC2 con un filtro para ver la oferta de instancias de su región. 

  ```
  aws ec2 describe-instance-type-offerings --filters Name=instance-type,Values=instance-type --region region
  ```

  En el siguiente ejemplo, se comprueba la disponibilidad del tipo de instancia M6 en la región Este de EE. UU. (Norte de Virginia) (us-east-1).

  ```
  aws ec2 describe-instance-type-offerings --filters "Name=instance-type,Values=m6*" --region us-east-1
  ```

  Para obtener más información, consulte [describe-instance-type-offerings](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instance-type-offerings.html) en la *Referencia de la línea de comandos de Amazon EC2*.

# Especificación de la arquitectura de ARM en la definición de tareas de Amazon ECS
<a name="ecs-arm-specifying"></a>

Para utilizar la arquitectura de ARM, especifique `ARM64` para el parámetro de definición de tareas `cpuArchitecture`. 

En el siguiente ejemplo, la arquitectura de ARM se especifica en una definición de tareas. Está en formato JSON.

```
{
    "runtimePlatform": {
        "operatingSystemFamily": "LINUX",
        "cpuArchitecture": "ARM64"
    },
...
}
```

En el siguiente ejemplo, una definición de tarea para la arquitectura de ARM muestra “hello world”.

```
{
 "family": "arm64-testapp",
 "networkMode": "awsvpc",
 "containerDefinitions": [
    {
        "name": "arm-container",
        "image": "public.ecr.aws/docker/library/busybox:latest",
        "cpu": 100,
        "memory": 100,
        "essential": true,
        "command": [ "echo hello world" ],
        "entryPoint": [ "sh", "-c" ]
    }
 ],
 "requiresCompatibilities": [ "EC2" ],
 "cpu": "256",
 "memory": "512",
 "runtimePlatform": {
        "operatingSystemFamily": "LINUX",
        "cpuArchitecture": "ARM64"
  },
 "executionRoleArn": "arn:aws:iam::123456789012:role/ecsTaskExecutionRole"
}
```

# Envío de registros de Amazon ECS a CloudWatch
<a name="using_awslogs"></a>

Puede configurar los contenedores de las tareas para que envíen información de registro a CloudWatch Logs. Si utiliza Fargate para las tareas, puede ver los registros de los contenedores. Si utiliza EC2, esto le permite ver distintos registros desde los contenedores en una ubicación cómoda y evita que los registros de contenedor ocupen espacio en disco en las instancias de contenedor. 

**nota**  
El tipo de información que registran los contenedores de la tarea depende en gran medida del comando `ENTRYPOINT`. De forma predeterminada, los registros que se capturan muestran la salida del comando que aparecería normalmente en un terminal interactivo si el contenedor se ejecutara localmente, que son los flujos de E/S `STDOUT` y `STDERR`. El controlador del registros `awslogs` simplemente transfiere estos registros de Docker a CloudWatch Logs. Para obtener más información acerca de cómo se procesan los registros de Docker, incluidas formas alternativas de capturar diferentes datos de archivo o flujos, consulte la página sobre cómo [Ver los registros de un contenedor o servicio](https://docs.docker.com/engine/logging/) en la documentación de Docker.

Para enviar registros del sistema desde las instancias de contenedor de Amazon ECS a CloudWatch Logs, consulte [Supervisar archivos de registro](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatchLogs.html) y [Cuotas de registros de CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html) en la *Guía del usuario de registros de Amazon CloudWatch*.

## Fargate
<a name="enable_awslogs"></a>

Si utiliza de Fargate para las tareas, debe agregar los parámetros `logConfiguration` necesarios a la definición de tareas para activar el controlador de registros `awslogs`. Para obtener más información, consulte [Definición de tareas de Amazon ECS de ejemplo: enrutar registros a CloudWatch](specify-log-config.md).

Para el contenedor de Windows en Fargate, siga una de las siguientes opciones cuando alguno de los parámetros de definición de tareas tenga caracteres especiales como, por ejemplo, `& \ < > ^ |`:
+ Agregue un carácter de escape (`\`) con comillas dobles alrededor de toda la cadena de parámetros.

  Ejemplo

  ```
  "awslogs-multiline-pattern": "\"^[|DEBUG|INFO|WARNING|ERROR\"",
  ```
+ Agregue un carácter de escape (`^`) alrededor de cada carácter especial.

  Ejemplo

  ```
  "awslogs-multiline-pattern": "^^[^|DEBUG^|INFO^|WARNING^|ERROR",
  ```

## EC2
<a name="ec2-considerations"></a>

Si utiliza EC2 para las tareas y desea activar el controlador de registros `awslogs`, las instancias de contenedor de Amazon ECS requieren al menos la versión 1.9.0 del agente de contenedor. Para obtener información acerca de cómo comprobar la versión del agente y actualizar a la versión más reciente, consulte [Actualización del agente de contenedor de Amazon ECS](ecs-agent-update.md).

**nota**  
Debe utilizar una AMI optimizada para Amazon ECS o una AMI personalizada con al menos la versión `1.9.0-1` del paquete `ecs-init`. Cuando utilice una AMI personalizada, debe especificar que el controlador del registro `awslogs` esté disponible en la instancia de Amazon EC2 al iniciar el agente mediante la siguiente variable de entorno en la instrucción **docker run** o el archivo de variables de entorno.  

```
ECS_AVAILABLE_LOGGING_DRIVERS=["json-file","awslogs"]
```

Las instancias de contenedor de Amazon ECS también requieren el permiso `logs:CreateLogStream` y `logs:PutLogEvents` en el rol de IAM con el que se pueden lanzar las instancias de contenedor. Si creó el rol de instancia de contenedor de Amazon ECS antes de que se habilitara la compatibilidad con el controlador de registros `awslogs` en Amazon ECS, es posible que tenga que agregar este permiso. El `ecsTaskExecutionRole` se utiliza cuando se asigna a la tarea y probablemente contenga los permisos correctos. Para obtener información acerca del rol de ejecución de tareas, consulte [Rol de IAM de ejecución de tareas de Amazon ECS](task_execution_IAM_role.md). Si las instancias de contenedor utilizan la política de IAM administrada para instancias de contenedor, probablemente tengan los permisos correctos. Para obtener información acerca de la política de IAM administrada para las instancias de contenedor, consulte [Rol de IAM de instancia de contenedor de Amazon ECS](instance_IAM_role.md).

# Definición de tareas de Amazon ECS de ejemplo: enrutar registros a CloudWatch
<a name="specify-log-config"></a>

Antes de que los contenedores puedan enviar registros a CloudWatch, debe especificar el controlador de registros `awslogs` para los contenedores de la definición de tarea. Para obtener más información sobre los parámetros de registros, consulte [Almacenamiento y registro](task_definition_parameters.md#container_definition_storage).

El JSON de definición de tareas a continuación tiene un objeto `logConfiguration` especificado para cada contenedor. Uno es para el contenedor de WordPress que envía registros a un grupo de registro denominado `awslogs-wordpress`. El otro es para un contenedor MySQL que envía registros a un grupo de registro denominado `awslogs-mysql`. Ambos contenedores utilizan el prefijo de flujo de registros `awslogs-example`.

```
{
    "containerDefinitions": [
        {
            "name": "wordpress",
            "links": [
                "mysql"
            ],
            "image": "public.ecr.aws/docker/library/wordpress:latest",
            "essential": true,
            "portMappings": [
                {
                    "containerPort": 80,
                    "hostPort": 80
                }
            ],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-create-group": "true",
                    "awslogs-group": "awslogs-wordpress",
                    "awslogs-region": "us-west-2",
                    "awslogs-stream-prefix": "awslogs-example"
                }
            },
            "memory": 500,
            "cpu": 10
        },
        {
            "environment": [
                {
                    "name": "MYSQL_ROOT_PASSWORD",
                    "value": "password"
                }
            ],
            "name": "mysql",
            "image": "public.ecr.aws/docker/library/mysql:latest",
            "cpu": 10,
            "memory": 500,
            "essential": true,
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-create-group": "true",
                    "awslogs-group": "awslogs-mysql",
                    "awslogs-region": "us-west-2",
                    "awslogs-stream-prefix": "awslogs-example",
                    "mode": "non-blocking", 
                    "max-buffer-size": "25m" 
                }
            }
        }
    ],
    "family": "awslogs-example"
}
```

## Siguientes pasos
<a name="specify-log-config-next-steps"></a>
+ Si lo desea, puede establecer una política de retención para el grupo de registros mediante la AWS CLI de CloudWatch o la API. Para obtener más información, consulte [put-retention-policy](https://docs.aws.amazon.com/cli/latest/reference/logs/put-retention-policy.html) en la *Referencia de comandos de la AWS Command Line Interface*.
+ Después de haber registrado una definición de tarea con el controlador de registros `awslogs` en una configuración de registros de definición de contenedor, puede ejecutar una tarea o crear un servicio con dicha definición de tarea para comenzar a enviar registros a CloudWatch Logs. Para obtener más información, consulte [Ejecución de una aplicación como tarea de Amazon ECS](standalone-task-create.md) y [Creación de una implementación de actualización continua de Amazon ECS](create-service-console-v2.md).

# Envío de registros de Amazon ECS a un servicio de AWS o AWS Partner
<a name="using_firelens"></a>

Puede utilizar FireLens para Amazon ECS para utilizar parámetros de definición de tareas para dirigir registros a un servicio de AWS o a un destino de AWS Partner Network (APN) para el almacenamiento y el análisis de registros. La AWS Partner Network es una comunidad global de socios que aprovecha los programas, el conocimiento técnico y los recursos para crear, comercializar y vender ofertas para los clientes. Para obtener más información, consulte [AWS Partner](https://aws.amazon.com/partners/work-with-partners/). FireLens trabaja con [Fluentd](https://www.fluentd.org/) y [Fluent Bit](https://fluentbit.io/). Proporcionamos AWS para la imagen de Fluent Bit o puede utilizar su propia imagen de Fluentd o Fluent Bit.

De forma predeterminada, Amazon ECS configura la dependencia del contenedor para que el contenedor Firelens se inicie antes que cualquier contenedor que lo utilice. El contenedor Firelens también se detiene después de que se detengan todos los contenedores que lo utilizan.

Para utilizar esta característica, debe crear un rol de IAM para las tareas, que proporcione los permisos necesarios para utilizar los servicios de AWS que las tareas requieran. Por ejemplo, si un contenedor dirige los registros a Firehose, la tarea necesita permiso para llamar a la API `firehose:PutRecordBatch`. Para obtener más información, consulte [Adición y eliminación de permisos de identidad de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) en la *Guía del usuario de IAM*.

Es posible que la tarea también requiera el rol de ejecución de tareas de Amazon ECS en las condiciones que se describen a continuación. Para obtener más información, consulte [Rol de IAM de ejecución de tareas de Amazon ECS](task_execution_IAM_role.md).
+ Si la tarea está alojada en Fargate y se están extrayendo imágenes de contenedor de Amazon ECR o haciendo referencia a información confidencial de AWS Secrets Manager en la configuración de registro, debe incluir el rol de IAM de ejecución de tareas.
+ Si utiliza un archivo de configuración personalizado alojado en Amazon S3, el rol de IAM de ejecución de tareas debe incluir el permiso `s3:GetObject`.

Al utilizar FireLens para Amazon ECS, tenga en cuenta lo siguiente:
+ Se recomienda agregar `my_service_` al nombre del contenedor de registros para poder distinguir fácilmente los nombres de los contenedores en la consola.
+ Amazon ECS agrega una dependencia de orden de contenedores inicial entre los contenedores de la aplicación y el contenedor de FireLens de manera predeterminada. Al especificar un orden de contenedores entre los contenedores de la aplicación y el contenedor de FireLens, se anula el orden de contenedores inicial predeterminado.
+ FireLens para Amazon ECS es compatible con tareas que están alojadas en AWS Fargate en Linux y Amazon EC2 en Linux. Los contenedores de Windows no son compatibles con FireLens.

  Para obtener información sobre cómo configurar el registro centralizado para contenedores de Windows, consulte [Centralized logging for Windows containers on Amazon ECS using Fluent Bit](https://aws.amazon.com/blogs/containers/centralized-logging-for-windows-containers-on-amazon-ecs-using-fluent-bit/) (Registro centralizado para contenedores de Windows en Amazon ECS con Fluent Bit).
+ Puede utilizar plantillas de CloudFormation para configurar FireLens para Amazon ECS. Para obtener más información, consulte [FirelensConfiguration de <shared id="AWS"/>::ECS::TaskDefinition](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-firelensconfiguration.html) en la *Guía del usuario de AWS CloudFormation*.
+ FireLens escucha en el puerto `24224`, para asegurarse de que el direccionador de registros FireLens no sea accesible fuera de la tarea, no debe permitir la entrada de tráfico en el puerto `24224` en el grupo de seguridad que utiliza la tarea. Para tareas que utilizan el modo de red `awsvpc`, es el grupo de seguridad asociado a la tarea. Para tareas que utilizan el modo de red `host`, es el grupo de seguridad asociado a la instancia de Amazon EC2 que aloja la tarea. Para tareas que utilizan el modo de red `bridge`, no cree asignaciones de puertos que utilicen el puerto `24224`.
+ Para las tareas que utilizan el modo de red `bridge`, el contenedor con la configuración de FireLens debe iniciarse antes de que se inicie cualquier contenedor de aplicación que se base en él. Para controlar el orden de inicio de los contenedores, utilice las condiciones de dependencia en la definición de la tarea. Para obtener más información, consulte [Dependencia de contenedor](task_definition_parameters.md#container_definition_dependson).
**nota**  
Si utiliza parámetros de condición de dependencia en definiciones de contenedor con una configuración de FireLens, asegúrese de que cada contenedor tenga un requisito de condición `START` o `HEALTHY`.
+ Por defecto, FireLens agrega el nombre de definición de clúster y tarea y el nombre de recurso de Amazon (ARN) del clúster como claves de metadatos a los registros de contenedor de stdout/stderr. A continuación se muestra un ejemplo del formato de los metadatos.

  ```
  "ecs_cluster": "cluster-name",
  "ecs_task_arn": "arn:aws:ecs:region:111122223333:task/cluster-name/f2ad7dba413f45ddb4EXAMPLE",
  "ecs_task_definition": "task-def-name:revision",
  ```

  Si no quiere que los metadatos estén en los registros, establezca `enable-ecs-log-metadata` en `false` en la `firelensConfiguration` de la definición de tareas.

  ```
  "firelensConfiguration":{
     "type":"fluentbit",
     "options":{
        "enable-ecs-log-metadata":"false",
        "config-file-type":"file",
        "config-file-value":"/extra.conf"
  }
  ```

Puede configurar el contenedor FireLens para que se ponga en marcha como usuario no raíz. Considere lo siguiente:
+  Para configurar el contenedor FireLens para que se ponga en marcha como un usuario no raíz, debe especificar el usuario en uno de los formatos siguientes:
  + `uid`
  + `uid:gid`
  + `uid:group`

  Para obtener más información acerca de la especificación de un usuario en una definición de contenedor, consulte [ContainerDefinition](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html) en la *Referencia de la API de Amazon Elastic Container Service*.

  El contenedor FireLens recibe los registros de la aplicación a través de un socket UNIX. El agente de Amazon ECS utiliza el parámetro `uid` para asignar la responsabilidad del directorio de sockets al contenedor FireLens.
+ La configuración del contenedor FireLens para que se ponga en marcha como un usuario no raíz se admite en la versión `1.96.0` del agente de Amazon ECS y posteriores, y en la versión `v20250716` de AMI optimizada para Amazon ECS y posteriores.
+ Al especificar un usuario para el contenedor FireLens, el parámetro `uid` debe ser único y no se debe utilizar para otros procesos que pertenezcan a otros contenedores de la tarea o de la instancia de contenedor.

Para obtener información sobre cómo usar varios archivos de configuración con Amazon ECS, incluidos los archivos que usted aloja o los archivos en Amazon S3, consulte [Init process for Fluent Bit on ECS, multi-config support](https://github.com/aws/aws-for-fluent-bit/tree/mainline/use_cases/init-process-for-fluent-bit).

Para obtener información acerca de las configuraciones de ejemplo, consulte [Definición de tareas de Amazon ECS de ejemplo: enrutar registros a FireLens](firelens-taskdef.md).

Para obtener más información acerca de la configuración de registros de rendimiento alto, consulte [Configuración de los registros de Amazon ECS para conseguir un alto rendimiento](firelens-docker-buffer-limit.md).

# Configuración de los registros de Amazon ECS para conseguir un alto rendimiento
<a name="firelens-docker-buffer-limit"></a>

Para escenarios de alto rendimiento de registros, recomendamos utilizar el controlador de registro `awsfirelens` con Firelens y Fluent Bit. Fluent Bit es un procesador de registro ligero que es eficiente con los recursos y puede gestionar millones de registros. Sin embargo, para lograr un rendimiento óptimo a escala es necesario ajustar su configuración.

En esta sección se describen las técnicas de optimización de Fluent Bit avanzadas para gestionar un alto rendimiento de los registros y, al mismo tiempo, mantener la estabilidad del sistema y garantizar que no se pierdan datos.

Para obtener información acerca de cómo utilizar archivos de configuración personalizados con FireLens, consulte [Uso de un archivo de configuración personalizado](firelens-taskdef.md#firelens-taskdef-customconfig). Para ver más ejemplos, consulte [Ejemplos de FireLens en Amazon ECS](https://github.com/aws-samples/amazon-ecs-firelens-examples) en GitHub.

**nota**  
Algunas opciones de configuración de esta sección, como `workers` y `threaded`, requieren AWS para la versión 3 o posterior de Fluent Bit. Para obtener información sobre las versiones disponibles, consulte [Versiones de AWS para Fluent Bit](https://github.com/aws/aws-for-fluent-bit/releases).

## Utilizar el almacenamiento en búfer del sistema de archivos
<a name="firelens-filesystem-buffering"></a>

De forma predeterminada, Fluent Bit almacena en búfer todos los datos de la memoria. Cuando los datos se ingieren más rápido de lo que pueden transferirse a las salidas, el búfer se llena. Una vez lleno, el complemento de entrada se detiene hasta que hay espacio disponible en el búfer, lo que puede provocar una contrapresión y ralentizar la aplicación.

Para escenarios de alto rendimiento, recomendamos utilizar el almacenamiento en búfer del sistema de archivos. Para obtener más información sobre cómo Fluent Bit gestiona el almacenamiento en búfer y el almacenamiento, consulte [Almacenamiento en búfer y almacenamiento en la documentación](https://docs.fluentbit.io/manual/administration/buffering-and-storage) de Fluent Bit.

El uso del almacenamiento en búfer del sistema de archivos proporciona los siguientes beneficios:
+ **Mayor capacidad de búfer**: el espacio en disco suele ser más abundante que la memoria.
+ **Persistencia**: los datos almacenados en búfer sobreviven a los reinicios de Fluent Bit.
+ **Degradación gradual**: durante los errores de salida, los datos se acumulan en el disco en lugar de agotar la memoria.

Para activar el almacenamiento en búfer del sistema de archivos, proporciona un archivo de configuración personalizado de Fluent Bit. A continuación se muestra un ejemplo de configuración recomendada:

```
[SERVICE]
    # Flush logs every 1 second
    Flush 1
    # Wait 120 seconds during shutdown to flush remaining logs
    Grace 120
    # Directory for filesystem buffering
    storage.path             /var/log/flb-storage/
    # Limit chunks stored 'up' in memory (reduce for memory-constrained environments)
    storage.max_chunks_up    32
    # Flush backlog chunks to destinations during shutdown (prevents log loss)
    storage.backlog.flush_on_shutdown On

[INPUT]
    Name forward
    unix_path /var/run/fluent.sock
    # Run input in separate thread to prevent blocking
    threaded true
    # Enable filesystem buffering for persistence
    storage.type filesystem

[OUTPUT]
    Name cloudwatch_logs
    Match *
    region us-west-2
    log_group_name /aws/ecs/my-app
    log_stream_name $(ecs_task_id)
    # Use multiple workers for parallel processing
    workers 2
    # Retry failed flushes up to 15 times
    retry_limit 15
    # Maximum disk space for buffered data for this output
    storage.total_limit_size 10G
```

Parámetros principales de configuración:

`storage.path`  
El directorio donde Fluent Bit almacena los fragmentos almacenados en búfer en el disco.

`storage.backlog.flush_on_shutdown`  
Cuando está activado, Fluent Bit intenta vaciar todos los fragmentos del sistema de archivos pendientes y llevarlos a sus destinos durante el apagado. Esto ayuda a garantizar la entrega de los datos antes de que Fluent Bit se detenga, pero puede aumentar el tiempo de apagado.

`storage.max_chunks_up`  
El número de fragmentos que permanecen en la memoria. El valor predeterminado es de 128 fragmentos, que pueden consumir más de 500 MB de memoria, ya que cada bloque puede utilizar entre 4 y 5 MB. En entornos con limitaciones de memoria, reduzca este valor. Por ejemplo, si tiene 50 MB disponibles para almacenar en búfer, configúrelo entre 8 y 10 fragmentos.

`storage.type filesystem`  
Active el almacenamiento en el sistema de archivos para el complemento de entrada. A pesar del nombre, Fluent Bit utiliza `mmap` para asignar fragmentos tanto en la memoria como en el disco, lo que proporciona persistencia sin sacrificar el rendimiento.

`threaded true`  
Ejecuta la entrada en su propio hilo, separado del bucle de eventos principal de Fluent Bit. Esto evita que las entradas lentas bloqueen toda la canalización.

## Optimizar configuración de salida
<a name="firelens-output-optimization"></a>

Los problemas de red, las interrupciones del servicio y la limitación del destino pueden impedir que se entreguen los registros. La configuración de salida adecuada garantiza la resiliencia sin pérdida de datos.

Cuando se produce un error al vaciar la salida, Fluent Bit puede volver a intentar la operación. Los clústeres de la región pueden obtener los siguientes beneficios.

`retry_limit`  
El número máximo de reintentos antes de eliminar registros. El valor predeterminado es 1. Para los entornos de producción, recomendamos 15 o más, lo que cubre varios minutos de interrupción con un retraso exponencial.

`scheduler.base`  
El mínimo de segundos entre reintentos. Recomendamos 10 segundos.

`scheduler.cap`  
El máximo de segundos entre reintentos cuando se utiliza un retroceso exponencial. Recomendamos 60 segundos.

`workers`  
El número de hilos para el procesamiento de salida en paralelo. Varios trabajos permiten vaciados concurrentes, lo que mejora el rendimiento al procesar muchos fragmentos.

El parámetro `Grace` de la sección `[SERVICE]` establece el tiempo de espera de Fluent Bit durante el apagado para vaciar los datos almacenados en el búfer. El período de `Grace` debe coordinarse con el valor de `stopTimeout` del contenedor. Asegúrese de que el valor `stopTimeout` supere el período `Grace` para permitir que Fluent Bit complete la descarga antes de recibir `SIGKILL`. Por ejemplo, si el valor de `Grace` es de 120 segundos, establezca el de `stopTimeout` en 150 segundos.

El siguiente ejemplo muestra una configuración de Fluent Bit completa con todos los ajustes recomendados para escenarios de alto rendimiento:

```
[SERVICE]
    # Flush logs every 1 second
    Flush 1
    # Wait 120 seconds during shutdown to flush remaining logs
    Grace 120
    # Directory for filesystem buffering
    storage.path             /var/log/flb-storage/
    # Limit chunks stored 'up' in memory (reduce for memory-constrained environments)
    storage.max_chunks_up    32
    # Flush backlog chunks to destinations during shutdown (prevents log loss)
    storage.backlog.flush_on_shutdown On
    # Minimum seconds between retries
    scheduler.base           10
    # Maximum seconds between retries (exponential backoff cap)
    scheduler.cap            60

[INPUT]
    Name forward
    unix_path /var/run/fluent.sock
    # Run input in separate thread to prevent blocking
    threaded true
    # Enable filesystem buffering for persistence
    storage.type filesystem

[OUTPUT]
    Name cloudwatch_logs
    Match *
    region us-west-2
    log_group_name /aws/ecs/my-app
    log_stream_name $(ecs_task_id)
    # Use multiple workers for parallel processing
    workers 2
    # Retry failed flushes up to 15 times
    retry_limit 15
    # Maximum disk space for buffered data for this output
    storage.total_limit_size 10G
```

## Utilice el registro multidestino para garantizar la fiabilidad
<a name="firelens-multi-destination"></a>

El envío de registros a varios destinos elimina los puntos únicos de error. Por ejemplo, si Registros de CloudWatch sufre una interrupción, los registros seguirán llegando a Amazon S3.

El registro multidestino ofrece los siguientes beneficios. El complemento de salida de Amazon S3 también admite opciones de compresión como los formatos .gzip y Parquet, lo que puede reducir los costos de almacenamiento. Para obtener más información, consulte [Compresión de S3](https://docs.fluentbit.io/manual/pipeline/outputs/s3#compression) en la documentación de Fluent Bit.

El registro multidestino puede ofrecer los siguientes beneficios:
+ **Redundancia**: si un destino falla, los registros siguen llegando al otro.
+ **Recuperación**: reconstruya las brechas en un sistema respecto al otro.
+ **Durabilidad**: archive registros en Amazon S3 para la retención a largo plazo.
+ **Optimización de costos**: guarde los registros recientes en un servicio de consultas rápido como Registros de CloudWatch con una retención más corta y, al mismo tiempo, archive todos los registros en un almacenamiento de Amazon S3 de menor costo para conservarlos a largo plazo.

La siguiente configuración de Fluent Bit envía registros tanto a Registros de CloudWatch como a Amazon S3:

```
[OUTPUT]
    Name cloudwatch_logs
    Match *
    region us-west-2
    log_group_name /aws/ecs/my-app
    log_stream_name $(ecs_task_id)
    workers 2
    retry_limit 15

[OUTPUT]
    Name s3
    Match *
    bucket my-logs-bucket
    region us-west-2
    total_file_size 100M
    s3_key_format /fluent-bit-logs/$(ecs_task_id)/%Y%m%d/%H/%M/$UUID
    upload_timeout 10m
    # Maximum disk space for buffered data for this output
    storage.total_limit_size 5G
```

Ambas salidas utilizan el mismo patrón de `Match *`, por lo que todos los registros se envían a ambos destinos de forma independiente. Durante una interrupción en un destino, los registros siguen fluyendo hacia el otro, mientras que las descargas fallidas se acumulan en el búfer del sistema de archivos para volver a intentarlo más adelante.

## Utilice el registro basado en archivos con el complemento de entrada trasera
<a name="firelens-tail-input"></a>

Para escenarios de alto rendimiento en los que la pérdida de registros es un problema fundamental, puede utilizar un enfoque alternativo: haga que la aplicación escriba los registros en los archivos del disco y configure Fluent Bit para leerlos mediante el complemento de entrada `tail`. Este enfoque evita por completo la capa del controlador de registro de Docker.

El registro basado en archivos con el complemento de entrada trasera proporciona los siguientes beneficios:
+ **Seguimiento del desplazamiento**: el complemento de entrada trasera puede almacenar los desplazamientos de los archivos en un archivo de base de datos (mediante la opción `DB`), lo que proporciona durabilidad tras los reinicios de Fluent Bit. Esto ayuda a evitar la pérdida de registros al reiniciar el contenedor.
+ **Almacenamiento en búfer a nivel de entrada**: puede configurar los límites del búfer de memoria directamente en el complemento de entrada mediante `Mem_Buf_Limit`, lo que proporciona un control más detallado del uso de la memoria.
+ **Evita la sobrecarga de Docker**: los registros pasan directamente de un archivo a Fluent Bit, sin pasar por los búferes de registro de Docker.

Para utilizar este enfoque, la aplicación debe escribir los registros en los archivos en lugar de hacerlo `stdout`. Tanto el contenedor de aplicaciones como el contenedor de Fluent Bit montan un volumen compartido donde se almacenan los archivos de registro.

El siguiente ejemplo muestra una configuración de entrada secundaria con las mejores prácticas:

```
[INPUT]
    Name tail
    # File path or glob pattern to tail
    Path /var/log/app.log
    # Database file for storing file offsets (enables resuming after restart)
    DB /var/log/flb_tail.db
    # when true, controls that only fluent-bit will access the database (improves performance)
    DB.locking true
    # Skip long lines instead of skipping the entire file
    Skip_Long_Lines On
    # How often (in seconds) to check for new files matching the glob pattern
    Refresh_Interval 10
    # Extra seconds to monitor a file after rotation to account for pending flush
    Rotate_Wait 30
    # Maximum size of the buffer for a single line
    Buffer_Max_Size 10MB
    # Initial allocation size for reading file data
    Buffer_Chunk_Size 1MB
    # Maximum memory buffer size (tail pauses when full)
    Mem_Buf_Limit 75MB
```

Cuando utilice el complemento de entrada trasera, tenga en cuenta lo siguiente:
+ Implemente la rotación de registros en los registros de sus aplicaciones para evitar que se agote el disco. Supervise las métricas de volumen subyacentes para medir el rendimiento.
+ Considere configuraciones como `Ignore_Older`, `Read_from_Head` y analizadores multilínea según el formato de registro.

Para obtener más información, consulte [Entrada trasera](https://docs.fluentbit.io/manual/pipeline/inputs/tail) en la documentación de Fluent Bit. Si desea conocer las prácticas recomendadas, consulte la sección [Configuración de entrada trasera con las prácticas recomendadas](https://github.com/aws/aws-for-fluent-bit/blob/mainline/troubleshooting/debugging.md#tail-config-with-best-practices) en la guía de solución de problemas de AWS para Fluent Bit.

## Iniciar sesión directamente en FireLens
<a name="firelens-environment-variables"></a>

Cuando se especifica el controlador de registros `awsfirelens` en una definición de tarea, el agente de contenedor de Amazon ECS introduce las siguientes variables de entorno en el contenedor:

`FLUENT_HOST`  
La dirección IP que está asignada al contenedor FireLens.  
Si utiliza EC2 con el modo de red `bridge`, la variable de entorno `FLUENT_HOST` del contenedor de aplicaciones puede dejar de ser precisa tras reiniciar el contenedor del router de registro de FireLens (el contenedor con el objeto `firelensConfiguration` en su definición de contenedor). Esto se debe a que `FLUENT_HOST` es una dirección IP dinámica y puede cambiar tras un reinicio. El registro directo desde el contenedor de la aplicación en la dirección IP `FLUENT_HOST` puede empezar a fallar después de que la dirección cambie. Para obtener más información acerca de cómo reiniciar contenedores individuales, consulte [Reinicio de contenedores individuales en tareas de Amazon ECS con políticas de reinicio de contenedores](container-restart-policy.md).

`FLUENT_PORT`  
El puerto en el que se está escuchando el protocolo Fluent Forward.

Puede utilizar estas variables de entorno para enviar registros directamente al enrutador de registro de Fluent Bit desde el código de su aplicación mediante el protocolo Fluent Forward, en lugar de escribir en `stdout`. Este enfoque evita la capa de controladores de registro de Docker, lo que proporciona las siguientes ventajas:
+ **Menor latencia**: los registros se transfieren directamente a Fluent Bit sin pasar por la infraestructura de registro de Docker.
+ **Registro estructurado**: envíe datos de registro estructurados de forma nativa sin sobrecargas de codificación JSON.
+ **Mejor control**: su aplicación puede implementar su propia lógica de almacenamiento en búfer y gestión de errores.

Las siguientes bibliotecas de registradores de Fluent son compatibles con el protocolo Fluent Forward y se pueden utilizar para enviar los registros directamente a Fluent Bit:
+ **Go**: [fluent-logger-golang](https://github.com/fluent/fluent-logger-golang)
+ **Python**: [fluent-logger-python](https://github.com/fluent/fluent-logger-python)
+ **Java**: [fluent-logger-java](https://github.com/fluent/fluent-logger-java)
+ **Node.js**: [fluent-logger-node](https://github.com/fluent/fluent-logger-node)
+ **Ruby**: [fluent-logger-ruby](https://github.com/fluent/fluent-logger-ruby)

## Configurar el límite de búfer de Docker
<a name="firelens-buffer-limit"></a>

Al crear una definición de tareas, puede indicar el número de líneas de registro que se almacenan en búfer en la memoria mediante la especificación del valor en `log-driver-buffer-limit`. Esto controla el búfer entre Docker y Fluent Bit. Para obtener más información, consulte [Controladores de registro Fluentd](https://docs.docker.com/engine/logging/drivers/fluentd/) en la documentación de Docker.

Utilice esta opción cuando haya un alto rendimiento, ya que Docker podría quedarse sin memoria de búfer y descartar mensajes de búfer para poder agregar nuevos mensajes.

Tenga en cuenta lo siguiente cuando utilice esta opción:
+ Esta opción se admite en el tipo de EC2 y de Fargate con la versión de la plataforma `1.4.0` o posterior.
+ La opción solo es válida cuando `logDriver` se establece en `awsfirelens`.
+ El límite de búfer predeterminado es de `1048576` líneas de registro.
+ El límite del búfer debe ser igual o mayor que `0` y menor que las líneas de registro `536870912`.
+ La cantidad máxima de memoria utilizada para este búfer es el producto del tamaño de cada línea de registro y el tamaño del búfer. Por ejemplo, si las líneas de registro de la aplicación tienen un promedio de `2` KiB, un límite de búfer de 4096 utilizaría como máximo `8` MiB. La cantidad total de memoria asignada a nivel de tarea debe ser superior a la cantidad de memoria asignada a todos los contenedores, además del búfer de memoria del controlador de registro.

La siguiente definición de tarea muestra cómo configurar `log-driver-buffer-limit`:

```
{
    "containerDefinitions": [
        {
            "name": "my_service_log_router",
            "image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:3",
            "cpu": 0,
            "memoryReservation": 51,
            "essential": true,
            "firelensConfiguration": {
                "type": "fluentbit"
            }
        },
        {
            "essential": true,
            "image": "public.ecr.aws/docker/library/httpd:latest",
            "name": "app",
            "logConfiguration": {
                "logDriver": "awsfirelens",
                "options": {
                    "Name": "firehose",
                    "region": "us-west-2",
                    "delivery_stream": "my-stream",
                    "log-driver-buffer-limit": "52428800"
                }
            },
            "dependsOn": [
                {
                    "containerName": "my_service_log_router",
                    "condition": "START"
                }
            ],
            "memoryReservation": 100
        }
    ]
}
```

# AWS para repositorios de imágenes de Fluent Bit para Amazon ECS
<a name="firelens-using-fluentbit"></a>

AWS proporciona una imagen de Fluent Bit con complementos para Registros de CloudWatch y Firehose. Recomendamos usar Fluent Bit como router de registro porque tiene una tasa de utilización de recursos más baja que Fluentd. Para obtener más información, consulte [CloudWatch Logs para Fluent Bit](https://github.com/aws/amazon-cloudwatch-logs-for-fluent-bit) y [Amazon Kinesis Firehose para Fluent Bit](https://github.com/aws/amazon-kinesis-firehose-for-fluent-bit).

La imagen de **AWS para Fluent Bit** está disponible en Galería pública de Amazon ECR y en un repositorio de Amazon ECR para lograr una alta disponibilidad.

## Galería pública de Amazon ECR
<a name="firelens-image-ecrpublic"></a>

La imagen de AWS para Fluent Bit está disponible en la galería pública de Amazon ECR. Esta es la ubicación recomendada para descargar la imagen de AWS para Fluent Bit, ya que es un repositorio público y está disponible para su uso desde todas las Regiones de AWS. Para obtener más información, consulte [aws-por-fluent-bit](https://gallery.ecr.aws/aws-observability/aws-for-fluent-bit) en la galería pública de Amazon ECR.

### Linux
<a name="firelens-image-ecrpublic-linux"></a>

La imagen de AWS para Fluent Bit de la galería pública de Amazon ECR es compatible con el sistema operativo Amazon Linux con la arquitectura `ARM64` o `x86-64`.

Para extraer la imagen de AWS para Fluent Bit de la galería pública de Amazon ECR, puede especificar la URL del repositorio con la etiqueta de imagen deseada. Para ver las etiquetas de imágenes disponibles, consulte la pestaña **Image tags** (Etiquetas de imágenes) en la galería pública de Amazon ECR.

A continuación, se muestra la sintaxis que se debe usar para la CLI de Docker.

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:tag
```

Por ejemplo, puede extraer la imagen más reciente de la familia “3.x” de versiones de AWS para Fluent Bit mediante este comando de la CLI de Docker.

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:3
```

**nota**  
Se permiten extracciones sin autenticación, pero tienen un límite de tasa inferior al de las extracciones autenticadas. Para autenticar el uso de la cuenta de AWS antes de la extracción, utilice el comando a continuación.  

```
aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
```

#### AWS para Fluent Bit 3.0.0
<a name="firelens-image-ecrpublic-linux-3.0.0"></a>

Además de las versiones `2.x` existentes de AWS para Fluent Bit, AWS para Fluent Bit admite una nueva versión `3.x` principal. La nueva versión principal incluye la actualización de imágenes de Amazon Linux 2 a Amazon Linux 2023 y de la versión de Fluent Bit `1.9.10` a la `4.1.1`. Para obtener más información, consulte el [repositorio de AWS para Fluent Bit](https://github.com/aws/aws-for-fluent-bit/blob/mainline/VERSIONS.md) en GitHub.

En los ejemplos siguientes se muestran las etiquetas actualizadas de las imágenes de AWS para Fluent Bit `3.x`.

Puede utilizar etiquetas de la arquitectura múltiple para la imagen de AWS para Fluent Bit.

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:3
```

### Windows
<a name="firelens-image-ecrpublic-windows"></a>

La imagen Fluent Bit de AWS de la galería pública de Amazon ECR es compatible con la arquitectura `AMD64` con los siguientes sistemas operativos:
+ Windows Server 2022 Full
+ Windows Server 2022 Core
+ Windows Server 2019 Full
+ Windows Server 2019 Core

Los contenedores de Windows que están en AWS Fargate no admiten FireLens.

Para extraer la imagen de AWS para Fluent Bit de la galería pública de Amazon ECR, puede especificar la URL del repositorio con la etiqueta de imagen deseada. Para ver las etiquetas de imágenes disponibles, consulte la pestaña **Image tags** (Etiquetas de imágenes) en la galería pública de Amazon ECR.

A continuación, se muestra la sintaxis que se debe usar para la CLI de Docker.

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:tag
```

Por ejemplo, para extraer la imagen de AWS para Fluent Bit estable más nueva, puede utilizar este comando de la CLI de Docker.

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:windowsservercore-stable
```

**nota**  
Se permiten extracciones sin autenticación, pero tienen un límite de tasa inferior al de las extracciones autenticadas. Para autenticar el uso de la cuenta de AWS antes de la extracción, utilice el comando a continuación.  

```
aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
```

## Amazon ECR
<a name="firelens-image-ecr"></a>

La imagen de AWS para Fluent Bit está disponible en Amazon ECR para lograr alta disponibilidad. Los comandos siguientes se pueden utilizar para recuperar los URI de las imágenes y establecer la disponibilidad de las imágenes en una Región de AWS determinada.

### Linux
<a name="firelens-image-ecr-linux"></a>

Para recuperar la URI de la imagen de AWS para Fluent Bit más estable, utilice el siguiente comando.

```
aws ssm get-parameters \
      --names /aws/service/aws-for-fluent-bit/stable \
      --region us-east-1
```

Para obtener una lista de todas las versiones de la imagen de AWS para Fluent Bit y consultar el parámetro del Parameter Store de Systems Manager, utilice el siguiente comando.

```
aws ssm get-parameters-by-path \
      --path /aws/service/aws-for-fluent-bit \
      --region us-east-1
```

Para consultar la imagen de AWS para Fluent Bit estable más nueva en una plantilla de CloudFormation, puede hacer referencia al nombre del almacén de parámetros de Systems Manager. A continuación, se muestra un ejemplo:

```
Parameters:
  FireLensImage:
    Description: Fluent Bit image for the FireLens Container
    Type: AWS::SSM::Parameter::Value<String>
    Default: /aws/service/aws-for-fluent-bit/stable
```

**nota**  
Si se produce un error en el comando o no hay ningún resultado, la imagen no está disponible en la Región de AWS en la que se llama al comando.

### Windows
<a name="firelens-image-ecr-windows"></a>

Para recuperar la URI de la imagen de AWS para Fluent Bit más estable, utilice el siguiente comando.

```
aws ssm get-parameters \
      --names /aws/service/aws-for-fluent-bit/windowsservercore-stable \
      --region us-east-1
```

Para obtener una lista de todas las versiones de la imagen de AWS para Fluent Bit y consultar el parámetro del Parameter Store de Systems Manager, utilice el siguiente comando.

```
aws ssm get-parameters-by-path \
      --path /aws/service/aws-for-fluent-bit/windowsservercore \
      --region us-east-1
```

Para consultar la imagen de AWS para Fluent Bit más estable en una plantilla de CloudFormation, puede hacer referencia al nombre del Parameter Store de Systems Manager. A continuación, se muestra un ejemplo:

```
Parameters:
  FireLensImage:
    Description: Fluent Bit image for the FireLens Container
    Type: AWS::SSM::Parameter::Value<String>
    Default: /aws/service/aws-for-fluent-bit/windowsservercore-stable
```

# Definición de tareas de Amazon ECS de ejemplo: enrutar registros a FireLens
<a name="firelens-taskdef"></a>

Para utilizar el enrutamiento de registros personalizado con FireLens, debe especificar lo siguiente en la definición de tareas:
+ Un contenedor del enrutador de registros que incluye una configuración de FireLens. Recomendamos que el contenedor se marque como `essential`.
+ Uno o varios contenedores de aplicaciones que incluyen una configuración de registro que especifica el controlador de registros `awsfirelens`.
+ Un nombre de recurso de Amazon (ARN) de rol de IAM de tarea que incluya los permisos necesarios para que la tarea envíe los registros.

Al crear una nueva definición de tarea mediante la Consola de administración de AWS, hay una sección de integración de FireLens que permite añadir fácilmente un contenedor de router de registros. Para obtener más información, consulte [Creación de una definición de tareas de Amazon ECS mediante la consola](create-task-definition.md).

Amazon ECS convierte la configuración de registros y genera la configuración de salida de Fluentd o Fluent Bit. La configuración de salida se monta en el contenedor de enrutamiento de registros en `/fluent-bit/etc/fluent-bit.conf` para Fluent Bit y `/fluentd/etc/fluent.conf` para Fluentd.

**importante**  
FireLens escucha en el puerto `24224`. Por lo tanto, para asegurarse de que el direccionador de registros FireLens no sea accesible fuera de la tarea, debe permitir la entrada de tráfico en el puerto `24224` en el grupo de seguridad que utiliza la tarea. Para tareas que utilizan el modo de red `awsvpc`, es el grupo de seguridad asociado a la tarea. Para tareas que utilizan el modo de red `host`, es el grupo de seguridad asociado a la instancia de Amazon EC2 que aloja la tarea. Para tareas que utilizan el modo de red `bridge`, no cree asignaciones de puertos que utilicen el puerto `24224`.

De forma predeterminada, Amazon ECS agrega campos adicionales a las entradas de registro, que ayudan a identificar su origen. 
+ `ecs_cluster`: el nombre del clúster del que forma parte la tarea.
+ `ecs_task_arn`: nombre de recurso de Amazon (ARN) de la tarea de la que el contenedor forma parte.
+ `ecs_task_definition`: el nombre y la revisión de la definición de tareas que utiliza la tarea.
+ `ec2_instance_id`: el ID de la instancia de Amazon EC2 en la que está alojado el contenedor. Este campo solo es válido para las tareas que utilizan el tipo de lanzamiento EC2.

Puede establecer `enable-ecs-log-metadata` en `false` si no quiere los metadatos.

En el siguiente ejemplo de definición de tarea, se define un contenedor de enrutamiento de registros que utiliza Fluent Bit para enrutar sus registros a CloudWatch Logs. También define un contenedor de aplicaciones que utiliza una configuración de registros para dirigirlos a Amazon Data Firehose y establecer en 2 MiB la memoria que se utiliza para guardar en búfer los eventos.

**nota**  
Para ver más ejemplos de definiciones de tareas, consulte [Ejemplos de FireLens en Amazon ECS](https://github.com/aws-samples/amazon-ecs-firelens-examples) en GitHub.

```
{
  "family": "firelens-example-firehose",
  "taskRoleArn": "arn:aws:iam::123456789012:role/ecs_task_iam_role",
  "containerDefinitions": [
    {
            "name": "log_router",
            "image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:3",
            "cpu": 0,
            "memoryReservation": 51,
            "portMappings": [],
            "essential": true,
            "environment": [],
            "mountPoints": [],
            "volumesFrom": [],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-group": "/ecs/ecs-aws-firelens-sidecar-container",
                    "mode": "non-blocking",
                    "awslogs-create-group": "true",
                    "max-buffer-size": "25m",
                    "awslogs-region": "us-east-1",
                    "awslogs-stream-prefix": "firelens"
                },
                "secretOptions": []
            },
            "systemControls": [],
            "firelensConfiguration": {
                "type": "fluentbit"
            }
        },
    {
      "essential": true,
      "image": "public.ecr.aws/docker/library/httpd:latest",
      "name": "app",
      "logConfiguration": {
        "logDriver": "awsfirelens",
        "options": {
          "Name": "firehose",
          "region": "us-west-2",
          "delivery_stream": "my-stream",
          "log-driver-buffer-limit": "1048576"
        }
      },
      "memoryReservation": 100
    }
  ]
}
```

Los pares de clave-valor especificados como opciones en el objeto `logConfiguration` se utilizan para generar la configuración de salida de Fluentd o Fluent Bit. A continuación, se muestra un ejemplo de código de una definición de salida de Fluent Bit.

```
[OUTPUT]
    Name   firehose
    Match  app-firelens*
    region us-west-2
    delivery_stream my-stream
```

**nota**  
FireLens administra la configuración `match`. No se especifica la configuración de `match` en la definición de tarea. 

## Uso de un archivo de configuración personalizado
<a name="firelens-taskdef-customconfig"></a>

Puede especificar un archivo de configuración personalizado. El formato del archivo de configuración es el formato nativo del enrutador de registros que está utilizando. Para obtener más información, consulte [Fluentd Config File Syntax](https://docs.fluentd.org/configuration/config-file) y [YAML Configuration](https://docs.fluentbit.io/manual/administration/configuring-fluent-bit/yaml).

En el archivo de configuración personalizado, en el caso de las tareas que utilizan el modo de red `bridge` o `awsvpc`, no establezca una entrada directa Fluentd o Fluent Bit a través de TCP porque FireLens la agrega a la configuración de entrada.

La configuración de FireLens debe incluir las siguientes opciones para especificar un archivo de configuración personalizado:

`config-file-type`  
La ubicación de origen del archivo de configuración personalizado. Las opciones disponibles son `s3` o `file`.  
Las tareas que están alojadas en AWS Fargate solo admiten el tipo de archivo de configuración `file`. Sin embargo, puede usar los archivos de configuración alojados en Amazon S3 en AWS Fargate mediante el contenedor init de AWS para Fluent Bit. Para obtener más información, consulte [Proceso de init para Fluent Bit en ECS, compatibilidad con configuraciones múltiples](https://github.com/aws/aws-for-fluent-bit/blob/mainline/use_cases/init-process-for-fluent-bit/README.md) en GitHub.

`config-file-value`  
El origen del archivo de configuración personalizado. Si se utiliza el tipo de archivo de configuración `s3`, el valor del archivo de configuración es el ARN completo del bucket y el archivo de Amazon S3. Si se utiliza el tipo de archivo de configuración `file`, el valor del archivo de configuración es la ruta completa del archivo de configuración que existe en la imagen del contenedor o en un volumen que se monta en el contenedor.  
Cuando se utilice un archivo de configuración personalizado, se debe especificar una ruta diferente a la que utiliza FireLens. Amazon ECS reserva la ruta de archivo `/fluent-bit/etc/fluent-bit.conf` para Fluent Bit y la `/fluentd/etc/fluent.conf` para Fluentd.

En el ejemplo siguiente se muestra la sintaxis necesaria al especificar una configuración personalizada.

**importante**  
Para especificar un archivo de configuración personalizado alojado en Amazon S3, asegúrese de haber creado un rol de IAM de ejecución de tareas con los permisos adecuados. 

A continuación se muestra la sintaxis necesaria al especificar una configuración personalizada.

```
{
  "containerDefinitions": [
    {
      "essential": true,
      "image": "906394416424.dkr.ecr.us-west-2.amazonaws.com/aws-for-fluent-bit:3",
      "name": "log_router",
      "firelensConfiguration": {
        "type": "fluentbit",
        "options": {
          "config-file-type": "s3 | file",
          "config-file-value": "arn:aws:s3:::amzn-s3-demo-bucket/fluent.conf | filepath"
        }
      }
    }
  ]
}
```

**nota**  
Las tareas alojadas en AWS Fargate solo admiten el tipo de archivo de configuración `file`. Sin embargo, puede usar los archivos de configuración alojados en Amazon S3 en AWS Fargate mediante el contenedor init de AWS para Fluent Bit. Para obtener más información, consulte [Proceso de init para Fluent Bit en ECS, compatibilidad con configuraciones múltiples](https://github.com/aws/aws-for-fluent-bit/blob/mainline/use_cases/init-process-for-fluent-bit/README.md) en GitHub.

# Uso de imágenes de contenedor que no sean de AWS en Amazon ECS
<a name="private-auth"></a>

Utilice el registro privado para almacenar las credenciales en AWS Secrets Manager y hacer referencia a ellas en la definición de tarea. Esto proporciona una forma de hacer referencia a las imágenes de contenedores que existen en registros privados fuera de AWS que requieren autenticación en las definiciones de tareas. Esta función es compatible con tareas alojadas en Fargate, Amazon EC2 instances (Instancias de Amazon EC2) e instancias externas que utilizan Amazon ECS Anywhere.

**importante**  
Si la definición de la tarea hace referencia a una imagen que está almacenada en Amazon ECR, este tema no es válido. Para obtener más información, consulte [Utilización de imágenes de Amazon ECR con Amazon ECS](https://docs.aws.amazon.com/AmazonECR/latest/userguide/ECR_on_ECS.html) en la *Guía del usuario de Amazon Elastic Container Registry*.

Para las tareas alojadas en instancias de Amazon EC2, esta característica requiere la versión `1.19.0` del agente de contenedor o una posterior. No obstante, recomendamos utilizar la versión del agente de contenedor más reciente. Para obtener información acerca de cómo comprobar la versión del agente y actualizar a la versión más reciente, consulte [Actualización del agente de contenedor de Amazon ECS](ecs-agent-update.md).

Para las tareas alojadas en Fargate, esta función requiere la versión de plataforma `1.2.0` o posterior. Para obtener más información, consulte [Versiones de la plataforma Fargate para Amazon ECS](platform-fargate.md).

En la definición de contenedor, especifique el objeto `repositoryCredentials` con los detalles del secreto que ha creado. El secreto al que se hace referencia puede proceder de una Región de AWS o cuenta distintas de la tarea que lo utiliza.

**nota**  
Cuando se utiliza la API de Amazon ECS, la AWS CLI o el SDK de AWS, si el secreto existe en la misma Región de AWS que la tarea que se va a lanzar, se puede utilizar el ARN completo o el nombre del secreto. Si el secreto existe en otra cuenta, debe especificarse el ARN completo del secreto. Cuando se utiliza la Consola de administración de AWS, siempre debe especificarse el ARN completo del secreto.

A continuación, se incluye un fragmento de definición de tareas que muestra los parámetros necesarios:

Sustituya los siguientes parámetros:
+ *private-repo* con el nombre de host del repositorio privado 
+ *private-image* con el nombre de la imagen
+ *arn:aws:secretsmanager:region:aws\$1account\$1id:secret:secret\$1name* con el nombre de recurso de Amazon (ARN) secreto

```
"containerDefinitions": [
    {
        "image": "private-repo/private-image",
        "repositoryCredentials": {
            "credentialsParameter": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name"
        }
    }
]
```

**nota**  
Otro método para habilitar la autenticación de registros privados consiste en utilizar las variables de entorno del agente de contenedor de Amazon ECS para la autenticación en registros privados. Este método solo se admite para tareas alojadas en Amazon EC2 instances (Instancias de Amazon EC2). Para obtener más información, consulte [Configuración de instancias de contenedor de Amazon ECS para imágenes de Docker privadas](private-auth-container-instances.md).

**Para utilizar el registro privado**

1. La definición de tareas debe tener un rol de ejecución de tareas. Esto permite que el agente de contenedor extraiga la imagen del contenedor. Para obtener más información, consulte [Rol de IAM de ejecución de tareas de Amazon ECS](task_execution_IAM_role.md).

   La autenticación de registro privado permite que sus tareas de Amazon ECS obtengan imágenes de contenedores de registros privados externos a AWS (como Docker Hub, Quay.io, o su propio registro privado) que requieren credenciales de autenticación. Esta característica utiliza Secrets Manager para almacenar de forma segura las credenciales de registro, que luego se referencian en la definición de la tarea mediante el parámetro `repositoryCredentials`.

   Para obtener más información sobre la configuración de la autenticación de registro privado, consulte [Uso de imágenes de contenedor no AWS en Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/private-auth.html).

   Para proporcionar acceso a los secretos que contienen las credenciales de su registro privado, agregue los siguientes permisos como una política insertada al rol de ejecución de tareas. Para obtener más información, consulte [Adición y eliminación de políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
   + `secretsmanager:GetSecretValue`: obligatorio para recuperar las credenciales de registro privado de Secrets Manager.
   + `kms:Decrypt`: obligatorio solo si el secreto utiliza una clave de KMS personalizada y no la clave predeterminada. Se debe agregar el nombre de recurso de Amazon (ARN) de la clave de personalizada como un recurso.

   Es siguiente es un ejemplo de política insertada que agrega los permisos.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "kms:Decrypt",
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": [
                   "arn:aws:secretsmanager:us-east-1:111122223333:secret:secret_name",
                   "arn:aws:kms:us-east-1:111122223333:key/key_id"
               ]
           }
       ]
   }
   ```

------

1. Utilice AWS Secrets Manager para crear un secreto para sus credenciales de registros privados. Para obtener información acerca de la creación de un secreto, consulte [Create an AWS Secrets Manager secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) en la *Guía del usuario de AWS Secrets Manager*.

   Ingrese las credenciales de registros privados con el siguiente formato:

   ```
   {
     "username" : "privateRegistryUsername",
     "password" : "privateRegistryPassword"
   }
   ```

1. Registre una definición de tareas. Para obtener más información, consulte [Creación de una definición de tareas de Amazon ECS mediante la consola](create-task-definition.md).

# Reinicio de contenedores individuales en tareas de Amazon ECS con políticas de reinicio de contenedores
<a name="container-restart-policy"></a>

Puede habilitar las políticas de reinicio para los contenedores esenciales y no esenciales definidas en la definición de su tarea para superar los errores transitorios con mayor rapidez y mantener la disponibilidad de las tareas. Al habilitar una política de reinicio para un contenedor, Amazon ECS puede reiniciar el contenedor si se cierra, sin necesidad de reemplazar la tarea.

Las políticas de reinicio no están habilitadas para los contenedores de forma predeterminada. Al habilitar una política de reinicio para un contenedor, puede especificar códigos de salida en los que no se reiniciará el contenedor. Pueden ser códigos de salida que indican que la realización ha sido correcta, como códigos de salida `0`, que no requieren un reinicio. También puede especificar durante cuánto tiempo debe funcionar correctamente un contenedor antes de intentar su reinicio. Para obtener más información sobre estos parámetros, consulte [Política de reinicio](task_definition_parameters.md#container_definition_restart_policy). Para ver un ejemplo de definición de tarea que especifique estos valores, consulte [Especificación de una política de reinicio de contenedor en una definición de tarea de Amazon ECS](container-restart-policy-example.md).

Puede utilizar el punto de conexión de metadatos de tareas de Amazon ECS o CloudWatch Container Insights para supervisar el número de veces que se ha reiniciado un contenedor. Para más información sobre el punto de conexión de los metadatos de la tarea, consulte [Versión 4 del punto de conexión de metadatos de tareas de Amazon ECS](task-metadata-endpoint-v4.md) y [Versión 4 del punto de conexión de los metadatos de tareas de Amazon ECS para tareas en Fargate](task-metadata-endpoint-v4-fargate.md). Para obtener más información sobre las métricas de Container Insights, consulte [Métricas de Amazon ECS Container Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Container-Insights-metrics-ECS.html) en la *Guía del usuario de Amazon CloudWatch*.

Las políticas de reinicio del contenedor son compatibles con tareas alojadas en Fargate, Instancias de Amazon EC2 e instancias externas que utilizan Amazon ECS Anywhere.

## Consideraciones
<a name="container-restart-policy-considerations"></a>

Tenga en cuenta lo siguiente antes de habilitar una política de reinicio para su contenedor:
+ Las políticas de reinicio no son compatibles con contenedores de Windows en Fargate.
+ Para las tareas alojadas en instancias de Amazon EC2, esta característica requiere la versión `1.86.0` del agente de contenedor o una posterior. No obstante, recomendamos utilizar la versión del agente de contenedor más reciente. Para obtener información acerca de cómo comprobar la versión del agente y actualizar a la versión más reciente, consulte [Actualización del agente de contenedor de Amazon ECS](ecs-agent-update.md).
+ Si utiliza EC2 con el modo de red `bridge`, la variable de entorno `FLUENT_HOST` del contenedor de aplicaciones puede dejar de ser precisa tras reiniciar el contenedor del router de registro de FireLens (el contenedor con el objeto `firelensConfiguration` en su definición de contenedor). Esto se debe a que `FLUENT_HOST` es una dirección IP dinámica y puede cambiar tras un reinicio. El registro directo desde el contenedor de la aplicación en la dirección IP `FLUENT_HOST` puede empezar a fallar después de que la dirección cambie. Para obtener más información acerca de `FLUENT_HOST`, consulte [Configuración de los registros de Amazon ECS para conseguir un alto rendimiento](firelens-docker-buffer-limit.md).
+ El agente de Amazon ECS gestiona las políticas de reinicio de contenedores. Si, por alguna razón inesperada, el agente de Amazon ECS falla o deja de ejecutarse, el contenedor no se reiniciará.
+  El período de intento de reinicio definido en su política determina el período de tiempo (en segundos) que debe funcionar el contenedor antes de que Amazon ECS lo reinicie.

# Especificación de una política de reinicio de contenedor en una definición de tarea de Amazon ECS
<a name="container-restart-policy-example"></a>

Para especificar una política de reinicio para un contenedor en una definición de tarea, dentro de la definición del contenedor, se debe especificar el objeto `restartPolicy`. Para obtener más información sobre el objeto de nodo `restartPolicy`, consulte [Política de reinicio](task_definition_parameters.md#container_definition_restart_policy).

A continuación, se muestra una definición de tarea que utiliza los contenedores Linux en Fargate y que configura un servidor web. La definición del contenedor incluye el objeto `restartPolicy`, y `enabled` establecido en verdadero para habilitar una política de reinicio para el contenedor. El contenedor debe funcionar durante 180 segundos antes del reinicio y no se reiniciará si sale con el código de salida `0`, lo que indica éxito.

```
{
  "containerDefinitions": [
    {
      "command": [
        "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
      ],
      "entryPoint": ["sh", "-c"],
      "essential": true,
      "image": "public.ecr.aws/docker/library/httpd:2.4",
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/fargate-task-definition",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "ecs"
        }
      },
      "name": "sample-fargate-app",
      "portMappings": [
        {
          "containerPort": 80,
          "hostPort": 80,
          "protocol": "tcp"
        }
      ],
      "restartPolicy": {
        "enabled": true,
        "ignoredExitCodes": [0],
        "restartAttemptPeriod": 180
      }
    }
  ],
  "cpu": "256",
  "executionRoleArn": "arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
  "family": "fargate-task-definition",
  "memory": "512",
  "networkMode": "awsvpc",
  "runtimePlatform": {
    "operatingSystemFamily": "LINUX"
  },
  "requiresCompatibilities": ["FARGATE"]
}
```

Después de haber registrado una definición de tarea con el objeto `restartPolicy` en una definición de contenedor, puede ejecutar una tarea o crear un servicio con dicha definición de tarea. Para obtener más información, consulte [Ejecución de una aplicación como tarea de Amazon ECS](standalone-task-create.md) y [Creación de una implementación de actualización continua de Amazon ECS](create-service-console-v2.md).

# Transferencia de datos confidenciales a un contenedor de Amazon ECS
<a name="specifying-sensitive-data"></a>

Puede transferir de forma segura datos confidenciales, como las credenciales de una base de datos, a su contenedor. 

Las aplicaciones suelen utilizar secretos, como las claves de API y las credenciales de las bases de datos, para acceder a otros sistemas. Suelen consistir en un nombre de usuario y una contraseña, un certificado o una clave de API. El acceso a estos secretos debe restringirse a las entidades principales de IAM específicas que utilizan IAM e deben inyectarse en los contenedores durante el tiempo de ejecución.

Los secretos se pueden introducir sin problemas en los contenedores desde AWS Secrets Manager y Parameter Store de Amazon EC2 Systems Manager. Puede hacer referencia a estos secretos en su tarea mediante cualquiera de las siguientes formas.

1. Se hace referencia a ellos como variables de entorno que utilizan el parámetro de definición del contenedor de `secrets`.

1. Se hace referencia a ellos como `secretOptions` si su plataforma de registro requiriera autenticación. Para obtener más información, consulte las [opciones de configuración del registro](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_LogConfiguration.html#API_LogConfiguration_Contents).

1. Se hace referencia a ellos como secretos y se extraen mediante imágenes que utilizan el parámetro de definición del contenedor `repositoryCredentials` si el registro del que se extrae el contenedor requiere autenticación. Utilice este método cuando extraiga imágenes de la galería pública de Amazon ECR. Para obtener más información, consulte [Autenticación de registros privados para tareas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/private-auth.html).

Se recomienda que realice las siguientes acciones al configurar la administración de secretos.

## Utilización del almacén de parámetros AWS Secrets Manager o AWS Systems Manager para el almacenamiento de materiales secretos
<a name="security-secrets-management-recommendations-storing-secret-materials"></a>

Debe almacenar de forma segura las claves de la API, las credenciales de bases de datos y otros materiales secretos en Secrets Manager o como un parámetro cifrado en el almacén de parámetros de Systems Manager. Estos servicios son similares porque ambos son almacenes clave-valor administrados que utilizan AWS KMS para cifrar información confidencial. Secrets Manager, sin embargo, también incluye la capacidad de rotar de forma automática los secretos, generar secretos aleatorios y compartirlos entre las cuentas. Para utilizar estas características, use Secrets Manager. De lo contrario, utilice parámetros cifrados en el Almacén de parámetros de Systems Manager.

**importante**  
Si su secreto cambia, debe forzar una nueva implementación o iniciar una nueva tarea para recuperar el valor secreto más reciente. Para obtener más información, consulte los temas siguientes:  
Tareas: detenga la tarea y, luego, iníciela. Para obtener más información, consulte [Detención de una tarea de Amazon ECS](standalone-task-stop.md) y [Ejecución de una aplicación como tarea de Amazon ECS](standalone-task-create.md).
Servicio: actualice el servicio y utilice la opción de forzar una nueva implementación. Para obtener más información, consulte [Actualización de un servicio de Amazon ECS](update-service-console-v2.md).

## Recuperación de datos de un bucket cifrado de Amazon S3
<a name="security-secrets-management-recommendations-encrypted-s3-buckets"></a>

Debe almacenar los secretos en un bucket cifrado de Amazon S3 y utilizar roles de tareas para restringir el acceso a esos secretos. Esto evita que los valores de las variables de entorno se filtre de manera inadvertida en los registros y se revelen al ejecutar `docker inspect`. De este modo, la aplicación debe escribirse para leer el secreto del bucket de Amazon S3. Para obtener instrucciones, consulte [Establecer el comportamiento predeterminado de cifrado del lado del servidor para buckets de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-encryption.html).

## Montar el secreto en un volumen utilizando un contenedor sidecar
<a name="security-secrets-management-recommendations-mount-secret-volumes"></a>

Dado que existe un riesgo elevado de filtración de datos con las variables de entorno, debe utilizar un contenedor sidecar que lea sus secretos de AWS Secrets Manager y los escriba en un volumen compartido. Este contenedor puede ejecutarse y salir antes que el contenedor de la aplicación mediante [pedidos de contenedores de Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDependency.html). De este modo, el contenedor de la aplicación monta posteriormente el volumen en el que se escribió el secreto. Al igual que el método de bucket de Amazon S3, la aplicación debe escribirse para leer el secreto del volumen compartido. Como el volumen se limita a la tarea, este se elimina automáticamente cuando la tarea se detiene. Para ver un ejemplo, consulte el proyecto [task-def.json](https://github.com/aws-samples/aws-secret-sidecar-injector/blob/master/ecs-task-def/task-def.json).

En Amazon EC2, el volumen en el que está escrito el secreto se puede cifrar con una clave administrada por el cliente de AWS KMS. En AWS Fargate, el almacenamiento por volumen se cifra automáticamente mediante una clave administrada por el servicio. 

# Transferencia de una variable de entorno individual a un contenedor de Amazon ECS
<a name="taskdef-envfiles"></a>

**importante**  
Recomendamos almacenar la información confidencial en cualquiera de los secretos de AWS Secrets Manager o en los parámetros AWS Systems Manager Parameter Store. Para obtener más información, consulte [Transferencia de datos confidenciales a un contenedor de Amazon ECS](specifying-sensitive-data.md).  
Las variables de entorno especificadas en la definición de tarea son aptas para que las lean todos los usuarios y roles a los que se les permite la acción `DescribeTaskDefinition` para la definición de tareas.

Puede transferir variables de entorno a sus contenedores de las siguientes maneras:
+ Individualmente con el parámetro de definición de contenedor `environment`. Se asigna a la opción `--env` de [https://docs.docker.com/reference/cli/docker/container/run/](https://docs.docker.com/reference/cli/docker/container/run/).
+ En bloque, mediante el parámetro de definición de contenedor de `environmentFiles` para enumerar uno o más archivos que contienen las variables de entorno. El archivo debe estar alojado en Amazon S3. Se asigna a la opción `--env-file` de [https://docs.docker.com/reference/cli/docker/container/run/](https://docs.docker.com/reference/cli/docker/container/run/).

A continuación, se presenta un fragmento de una definición de tarea que muestra cómo especificar variables de entorno individuales.

```
{
    "family": "",
    "containerDefinitions": [
        {
            "name": "",
            "image": "",
            ...
            "environment": [
                {
                    "name": "variable",
                    "value": "value"
                }
            ],
            ...
        }
    ],
    ...
}
```

# Transferencia de variables de entorno a un contenedor de Amazon ECS
<a name="use-environment-file"></a>

**importante**  
Recomendamos almacenar la información confidencial en cualquiera de los secretos de AWS Secrets Manager o en los parámetros AWS Systems Manager Parameter Store. Para obtener más información, consulte [Transferencia de datos confidenciales a un contenedor de Amazon ECS](specifying-sensitive-data.md).  
Los archivos de variables de entorno son objetos de Amazon S3 y se aplican todas las consideraciones de seguridad de Amazon S3.   
No puede utilizar el parámetro `environmentFiles` en los contenedores de Windows ni en los contenedores de Windows en Fargate.

Puede crear un archivo de variables de entorno y almacenarlo en Amazon S3 para pasar las variables de entorno a su contenedor.

Al especificar variables de entorno en un archivo, puede introducir variables de entorno en bloque. En la definición de contenedor, especifique el objeto `environmentFiles` con una lista de buckets de Amazon S3 con los archivos de variables de entorno.

Amazon ECS no aplica un límite de tamaño a las variables de entorno, pero un archivo de variables de entorno grande podría llenar el espacio en el disco. Cada tarea que utiliza un archivo de variables de entorno hace que se descargue una copia del archivo en el disco. Amazon ECS elimina el archivo como parte de la limpieza de tareas.

Para obtener información sobre las variables de entorno compatibles, consulte [Parámetros de definición avanzada de contenedores: entorno](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#container_definition_environment).

Tenga en cuenta lo siguiente al especificar un archivo de variable de entorno en una definición de contenedor.
+ Para las tareas de Amazon ECS en Amazon EC2, las instancias de contenedor requieren la versión `1.39.0` del agente de contenedor o una posterior para utilizar esta característica. Para obtener información acerca de cómo comprobar la versión del agente y actualizar a la versión más reciente, consulte [Actualización del agente de contenedor de Amazon ECS](ecs-agent-update.md).
+ Para realizar tareas de Amazon ECS en AWS Fargate, sus tareas deben utilizar la versión `1.4.0` de la plataforma o una posterior (para Linux) a fin de utilizar esta característica. Para obtener más información, consulte [Versiones de la plataforma Fargate para Amazon ECS](platform-fargate.md).

  Compruebe que la variable sea compatible con la plataforma del sistema operativo. Para obtener más información, consulte [Definiciones de contenedores](task_definition_parameters.md#container_definitions) y [Otros parámetros de definición de tarea](task_definition_parameters.md#other_task_definition_params).
+ El archivo debe usar la extensión de archivo `.env` y la codificación UTF-8.
+ Se requiere el rol de ejecución de tareas para utilizar esta característica con los permisos adicionales para Amazon S3. De este modo el agente de contenedor puede extraer el archivo de variables de entorno de Amazon S3. Para obtener más información, consulte [Rol de IAM de ejecución de tareas de Amazon ECS](task_execution_IAM_role.md).
+ Hay un límite de 10 archivos por definición de tarea.
+ Cada línea de un archivo de entorno debe contener una variable de entorno con el formato `VARIABLE=VALUE`. Los espacios o las comillas **se incluyen** como parte de los valores para los archivos de Amazon ECS. Las líneas que comienzan por `#` se tratan como comentarios y se ignoran. Para obtener más información acerca de la sintaxis del archivo de variables de entorno, consulte [Establecimiento de variables de entorno (-e, --env, --env-file)](https://docs.docker.com/reference/cli/docker/container/run/#env) en la documentación de Docker.

  A continuación, se presenta la sintaxis adecuada.

  ```
  #This is a comment and will be ignored
  VARIABLE=VALUE
  ENVIRONMENT=PRODUCTION
  ```
+ Si hay variables de entorno especificadas mediante el parámetro `environment` en una definición de contenedor, tienen prioridad sobre las variables incluidas en un archivo de entorno.
+ Si se especifican varios archivos de entorno que contienen la misma variable, se procesan en orden de entrada. Esto significa que se utiliza el primer valor de la variable y se ignoran los valores posteriores de las variables duplicadas. Le recomendamos que utilice nombres de variables únicos.
+ Si se especifica un archivo de entorno como anulación de un contenedor, se utiliza. Además, se omite cualquier otro archivo de entorno especificado en la definición de contenedor.
+ Las siguientes reglas se aplican a Fargate:
  + El archivo se gestiona como un archivo .env-file nativo de Docker.
  + Las definiciones de contenedor que hacen referencia a variables de entorno que están en blanco y almacenadas en Amazon S3 no aparecen en el contenedor.
  + No se admite la gestión del escape del intérprete de comandos.
  + El punto de entrada del contenedor interpreta los valores `VARIABLE`.

## Ejemplo
<a name="environment-file-example"></a>

A continuación, se presenta un fragmento de una definición de tarea que muestra cómo especificar un archivo de variable de entorno.

```
{
    "family": "",
    "containerDefinitions": [
        {
            "name": "",
            "image": "",
            ...
            "environmentFiles": [
                {
                    "value": "arn:aws:s3:::amzn-s3-demo-bucket/envfile_object_name.env",
                    "type": "s3"
                }
            ],
            ...
        }
    ],
    ...
}
```

# Transmisión de secretos de Secrets Manager mediante programación en Amazon ECS
<a name="secrets-app-secrets-manager"></a>

En lugar de codificar la información confidencial en texto sin formato en la aplicación, puede utilizar Secrets Manager para almacenar los datos confidenciales.

Recomendamos este método para recuperar datos confidenciales porque si el secreto de Secrets Manager se actualiza luego, la aplicación recuperará automáticamente la versión más reciente del secreto.

Cree un secreto en Secrets Manager. Después de crear un secreto de Secrets Manager, actualice el código de la aplicación para recuperar el secreto.

Revise las siguientes consideraciones antes de proteger datos confidenciales en Secrets Manager.
+ Solo se admiten los secretos que almacenan datos de texto, que son secretos creados con el parámetro `SecretString` de la API [CreateSecret](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_CreateSecret.html). No son compatibles los secretos que almacenan datos binarios, que son secretos creados con el parámetro `SecretBinary` de la API [CreateSecret](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_CreateSecret.html).
+ Utilice los puntos de conexión de VPC de interfaz para mejorar los controles de seguridad. Debe crear los puntos de conexión de VPC de interfaz para Secrets Manager. Para obtener información sobre el punto de conexión de VPC, consulte [Crear puntos de conexión de VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/setup-create-vpc.html) en la *Guía del usuario de AWS Secrets Manager*.
+ La VPC que utiliza la tarea debe usar la resolución de DNS.
+ En la definición de tareas se debe utilizar un rol de tareas con los permisos adicionales para Secrets Manager. Para obtener más información, consulte [Rol de IAM de tarea de Amazon ECS](task-iam-roles.md).

## Creación de secretos de Secrets Manager
<a name="secrets-app-secrets-manager-create-secret"></a>

Puede utilizar la consola de Secrets Manager para crear un secreto con su información confidencial. Para obtener información acerca de la creación de secretos, consulte [Crear un secreto de AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) en la *Guía del usuario de AWS Secrets Manager*.

## Actualice la aplicación para que recupere secretos de Secrets Manager mediante programación
<a name="secrets-app-secrets-manager-update-app"></a>

Puede recuperar secretos mediante una llamada a las API de Secrets Manager directamente desde la aplicación. Para información, consulte [Retrieve secrets from AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html) en la *Guía del usuario de AWS Secrets Manager*.

Para recuperar los datos confidenciales almacenados en el AWS Secrets Manager, consulte [Ejemplos de código para AWS Secrets Manager mediante SDK de AWS](https://docs.aws.amazon.com/code-library/latest/ug/secrets-manager_code_examples.html) en la *Biblioteca de ejemplos de código del SDK de AWS*.

# Transmisión de secretos de Almacén de parámetros de Systems Manager mediante programación en Amazon ECS
<a name="secrets-app-ssm-paramstore"></a>

El almacén de parámetros de Systems Manager proporciona almacenamiento y administración seguros de secretos. Puede almacenar datos como contraseñas, cadenas de base de datos, ID de instancias de EC2 e ID de AMI y códigos de licencia como valores de parámetros, en lugar de integrar con codificación rígida esta información en la aplicación. Puede almacenar valores como texto sin formato o como datos cifrados.

Recomendamos este método para recuperar datos confidenciales porque si el parámetro del Almacén de parámetros de Systems Manager se actualiza posteriormente, la aplicación recuperará automáticamente la versión más reciente.

Revise las siguientes consideraciones antes de proteger datos confidenciales en el almacén de parámetros de Systems Manager.
+ Solo se admiten secretos que almacenan datos de texto. No se admiten los secretos que almacenan datos binarios.
+ Utilice los puntos de conexión de VPC de interfaz para mejorar los controles de seguridad.
+ La VPC que utiliza la tarea debe usar la resolución de DNS.
+ En el caso de las tareas que utilizan EC2, debe utilizar la variable `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE=true` de configuración del agente de Amazon ECS para utilizar esta característica. Puede añadirla al archivo `/etc/ecs/ecs.config` durante la creación de la instancia de contenedor o puede añadirla a una instancia existente y, a continuación, reiniciar el agente de ECS. Para obtener más información, consulte [Configuración del agente de contenedor de Amazon ECS](ecs-agent-config.md).
+ En la definición de tareas se debe utilizar un rol de tareas con los permisos adicionales para el almacén de parámetros de Systems Manager. Para obtener más información, consulte [Rol de IAM de tarea de Amazon ECS](task-iam-roles.md).

## Cree el parámetro de
<a name="secrets-app-ssm-paramstore-create-secret"></a>

Puede utilizar la consola de Systems Manager para crear un parámetro del almacén de parámetros de Systems Manager para la información confidencial. Para obtener más información, consulte [Creación de un parámetro de Systems Manager (consola)](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-create-console.html) o [Creación de un parámetro de Systems Manager (AWS CLI)](https://docs.aws.amazon.com/systems-manager/latest/userguide/param-create-cli.html) en la *Guía del usuario de AWS Systems Manager*.

## Actualice la aplicación para que recupere secretos del almacén de parámetros de Systems Manager mediante programación
<a name="secrets-app-ssm-paramstore-update-app"></a>

Para recuperar los datos confidenciales almacenados en el parámetro de Parameter Store de Systems Manager, consulte [Ejemplos de código de Systems Manager mediante SDK de AWS](https://docs.aws.amazon.com/code-library/latest/ug/ssm_code_examples.html) en la *Biblioteca de ejemplos de código del SDK de AWS*.

# Transmisión de secretos de Secrets Manager a través de variables de entorno de Amazon ECS
<a name="secrets-envvar-secrets-manager"></a>

Cuando introduce un secreto como una variable de entorno, puede especificar el contenido completo de un secreto, una clave JSON específica dentro de un secreto. Este proceso ayuda a controlar la información confidencial expuesta al contenedor. Para obtener más información sobre el control de versiones secreto, consulte [¿Qué hay en un secreto de Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/whats-in-a-secret.html#term_version) en la *Guía del usuario de AWS Secrets Manager*.

Al utilizar una variable de entorno para introducir un secreto de Secrets Manager en un contenedor, se debe tener en cuenta lo siguiente.
+ Los datos confidenciales se inyectan en el contenedor al iniciar el contenedor. Si el secreto se actualiza posteriormente o se rota, el contenedor no recibirá automáticamente el valor actualizado. Debe lanzar una nueva tarea o, si su tarea forma parte de un servicio, puede actualizar el servicio y utilizar la opción **Force new deployment (Forzar nueva implementación)** para forzar que el servicio lance una nueva tarea.
+ Las aplicaciones que se ejecutan en el contenedor, los registros del contenedor y las herramientas de depuración tienen acceso a las variables de entorno.
+ Para las tareas de Amazon ECS alojadas en AWS Fargate, tenga en cuenta lo siguiente:
  + Para introducir el contenido completo de un secreto como variable de entorno o en una configuración de registro, debe usar la versión `1.3.0` de la plataforma o una posterior. Para obtener más información, consulte [Versiones de la plataforma Fargate para Amazon ECS](platform-fargate.md).
  + Para introducir una versión o clave JSON específica de un secreto como variable de entorno o en una configuración de registro, debe usar la versión `1.4.0` o posterior (Linux) o `1.0.0` (Windows) de la plataforma. Para obtener más información, consulte [Versiones de la plataforma Fargate para Amazon ECS](platform-fargate.md).
+ Para las tareas de Amazon ECS alojadas en EC2, se debe tener en cuenta lo siguiente:
  + Para introducir un secreto utilizando una versión o clave JSON específica de un secreto, la instancia de contenedor debe tener la versión `1.37.0` del agente de contenedor o una posterior. No obstante, recomendamos utilizar la versión del agente de contenedor más reciente. Para obtener información sobre la comprobación de la versión del agente y la actualización a la versión más reciente, consulte [Actualización del agente de contenedor de Amazon ECS](ecs-agent-update.md).

    Para introducir el contenido completo de un secreto como variable de entorno o un secreto en una configuración de registro, la instancia de contenedor debe tener la versión `1.22.0` del agente de contenedor o una posterior.
+ Utilice los puntos de conexión de VPC de interfaz para mejorar los controles de seguridad y conectarse a Secrets Manager a través de una subred privada. Debe crear los puntos de conexión de VPC de interfaz para Secrets Manager. Para obtener información sobre el punto de conexión de VPC, consulte [Crear puntos de conexión de VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/setup-create-vpc.html) en la *Guía del usuario de AWS Secrets Manager*. Para obtener más información sobre el uso de Secrets Manager y Amazon VPC, consulte [How to connect to Secrets Manager service within a Amazon VPC](https://aws.amazon.com/blogs//security/how-to-connect-to-aws-secrets-manager-service-within-a-virtual-private-cloud/).
+ Para las tareas de Windows configuradas para utilizar el controlador de registros `awslogs`, debe también establecer la variable de entorno `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE` en la instancia del contenedor. Utilice la siguiente sintaxis:

  ```
  <powershell>
  [Environment]::SetEnvironmentVariable("ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE", $TRUE, "Machine")
  Initialize-ECSAgent -Cluster <cluster name> -EnableTaskIAMRole -LoggingDrivers '["json-file","awslogs"]'
  </powershell>
  ```
+ En la definición de tareas se debe utilizar un rol de ejecución de tareas con los permisos adicionales para Secrets Manager. Para obtener más información, consulte [Rol de IAM de ejecución de tareas de Amazon ECS](task_execution_IAM_role.md).

## Cree el secreto de AWS Secrets Manager
<a name="secrets-envvar-secrets-manager-create-secret"></a>

Puede utilizar la consola de Secrets Manager para crear un secreto con su información confidencial. Para obtener más información, consulte [Crear un secreto de AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) en la *Guía del usuario de AWS Secrets Manager*.

## Adición de la variable de entorno a la definición del contenedor
<a name="secrets-envvar-secrets-manager-update-container-definition"></a>

Dentro de la definición de contenedor, puede especificar lo siguiente:
+ El objeto `secrets` que contiene el nombre de la variable de entorno que se va a establecer en el contenedor
+ Nombre de recurso de Amazon (ARN) del secreto de Secrets Manager
+ Parámetros adicionales que contienen información confidencial que se debe presentar al contenedor

En el ejemplo siguiente, se muestra la sintaxis completa que se debe especificar para el secreto de Secrets Manager.

```
arn:aws:secretsmanager:region:aws_account_id:secret:secret-name:json-key:version-stage:version-id
```

En la siguiente sección se describen los parámetros adicionales. Estos parámetros son opcionales, pero si no los utiliza, debe incluir los dos puntos y coma `:` para utilizar los valores predeterminados. A continuación se ofrecen ejemplos para obtener más contexto.

`json-key`  
Especifica el nombre de la clave en un par clave-valor con el valor que desea establecer como valor de variable de entorno. Solo se admiten valores en formato JSON. Si no especifica una clave JSON, se usa el contenido completo del secreto.

`version-stage`  
Especifica la etiqueta de ensayo de la versión de un secreto que desea utilizar. Si se especifica una etiqueta de ensayo de versión, no se puede especificar un ID de versión. Si no se especifica ninguna etapa de versión, el comportamiento predeterminado consiste en recuperar el secreto con la etiqueta de ensayo `AWSCURRENT`.  
Las etiquetas de ensayo se utilizan para realizar un seguimiento de las distintas versiones de un secreto cuando se actualizan o rotan. Cada versión de un secreto tiene una o varias etiquetas de ensayo y un ID.

`version-id`  
Especifica el identificador único de la versión del secreto que desea utilizar. Si se especifica un ID de versión, no se puede especificar una etiqueta de ensayo de versión. Si no se especifica ningún ID de versión, el comportamiento predeterminado consiste en recuperar el secreto con la etiqueta de ensayo `AWSCURRENT`.  
Los ID de versión se utilizan para realizar un seguimiento de las distintas versiones de un secreto cuando se actualizan o rotan. Cada versión de un secreto tiene un ID. Para obtener más información, consulte [Términos y conceptos clave para AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/terms-concepts.html#term_secret) en la *Guía del usuario de AWS Secrets Manager*.

### Definiciones de contenedor de ejemplo
<a name="secrets-examples"></a>

En los siguientes ejemplos, se muestran las formas en las que se pueden referenciar secretos de Secrets Manager en las definiciones de contenedor.

**Example hacer referencia a un secreto completo**  
A continuación, se incluye un fragmento de código de una definición de tarea que muestra el formato cuando se referencia el texto completo de un secreto de Secrets Manager.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
    }]
  }]
}
```
Para acceder al valor de este secreto desde el contenedor, deberá llamar a `$environment_variable_name`.

**Example referencia de secretos completos**  
A continuación, se incluye un fragmento de código de una definición de tarea que muestra el formato cuando se referencia el texto completo de múltiples secretos de Secrets Manager.  

```
{
  "containerDefinitions": [{
     "secrets": [
      {
        "name": "environment_variable_name1",
         "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
      },
      {
        "name": "environment_variable_name2",
         "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-abcdef"
      },
      {
        "name": "environment_variable_name3",
        "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-ABCDEF"
      }
    ]
  }]
}
```
Para acceder al valor de este secreto desde el contenedor, deberá llamar a `$environment_variable_name1`, `$environment_variable_name2` y `$environment_variable_name3`.

**Example hacer referencia a una clave específica dentro de un secreto**  
A continuación se muestra un ejemplo de salida de un comando [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html) que muestra el contenido de un secreto junto con la etiqueta de ensayo de versión y el ID de versión asociados con ella.  

```
{
    "ARN": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf",
    "Name": "appauthexample",
    "VersionId": "871d9eca-18aa-46a9-8785-981ddEXAMPLE",
    "SecretString": "{\"username1\":\"password1\",\"username2\":\"password2\",\"username3\":\"password3\"}",
    "VersionStages": [
        "AWSCURRENT"
    ],
    "CreatedDate": 1581968848.921
}
```
Haga referencia a una clave específica de la salida anterior en una definición de contenedor especificando el nombre de clave al final del ARN.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1::"
    }]
  }]
}
```

**Example hacer referencia a una versión de secreto específica**  
A continuación se muestra una salida de ejemplo de un comando [describe-secret](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/describe-secret.html) que muestra el contenido sin cifrar de un secreto junto con los metadatos de todas las versiones del secreto.  

```
{
    "ARN": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf",
    "Name": "appauthexample",
    "Description": "Example of a secret containing application authorization data.",
    "RotationEnabled": false,
    "LastChangedDate": 1581968848.926,
    "LastAccessedDate": 1581897600.0,
    "Tags": [],
    "VersionIdsToStages": {
        "871d9eca-18aa-46a9-8785-981ddEXAMPLE": [
            "AWSCURRENT"
        ],
        "9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE": [
            "AWSPREVIOUS"
        ]
    }
}
```
Haga referencia a una etiqueta de ensayo de versión específica de la salida anterior en una definición de contenedor especificando el nombre de clave al final del ARN.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf::AWSPREVIOUS:"
    }]
  }]
}
```
Haga referencia a un ID de versión específico de la salida anterior en una definición de contenedor especificando el nombre de clave al final del ARN.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:::9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE"
    }]
  }]
}
```

**Example hacer referencia a una clave específica y una etiqueta de ensayo de versión de un secreto**  
A continuación se muestra cómo hacer referencia tanto a una clave específica dentro de un secreto como a una etiqueta de ensayo de versión específica.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1:AWSPREVIOUS:"
    }]
  }]
}
```
Para especificar una clave y un ID de versión específicos, utilice la sintaxis siguiente.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1::9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE"
    }]
  }]
}
```

Para obtener información sobre cómo crear una definición de tareas con el secreto especificado en una variable de entorno, consulte [Creación de una definición de tareas de Amazon ECS mediante la consola](create-task-definition.md). 

# Transmisión de parámetros de Systems Manager a través de variables de entorno de Amazon ECS
<a name="secrets-envvar-ssm-paramstore"></a>

Amazon ECS le permite ingresar información confidencial en los contenedores al almacenarla en parámetros de Almacén de parámetros de AWS Systems Manager y, a continuación, hacer referencia a ella en la definición de los contenedores.

Tenga en cuenta lo siguiente cuando utilice una variable de entorno para ingresar un secreto de Systems Manager en un contenedor.
+ Los datos confidenciales se inyectan en el contenedor al iniciar el contenedor. Si el secreto se actualiza posteriormente o se rota, el contenedor no recibirá automáticamente el valor actualizado. Debe lanzar una nueva tarea o, si su tarea forma parte de un servicio, puede actualizar el servicio y utilizar la opción **Force new deployment (Forzar nueva implementación)** para forzar que el servicio lance una nueva tarea.
+ Para las tareas de Amazon ECS alojadas en AWS Fargate, se debe tener en cuenta lo siguiente:
  + Para introducir el contenido completo de un secreto como variable de entorno o en una configuración de registro, debe usar la versión `1.3.0` de la plataforma o una posterior. Para obtener más información, consulte [Versiones de la plataforma Fargate para Amazon ECS](platform-fargate.md).
  + Para introducir una versión o clave JSON específica de un secreto como variable de entorno o en una configuración de registro, debe usar la versión `1.4.0` o posterior (Linux) o `1.0.0` (Windows) de la plataforma. Para obtener más información, consulte [Versiones de la plataforma Fargate para Amazon ECS](platform-fargate.md).
+ Para las tareas de Amazon ECS alojadas en EC2, se debe tener en cuenta lo siguiente:
  + Para introducir un secreto utilizando una versión o clave JSON específica de un secreto, la instancia de contenedor debe tener la versión `1.37.0` del agente de contenedor o una posterior. No obstante, recomendamos utilizar la versión del agente de contenedor más reciente. Para obtener información sobre la comprobación de la versión del agente y la actualización a la versión más reciente, consulte [Actualización del agente de contenedor de Amazon ECS](ecs-agent-update.md).

    Para introducir el contenido completo de un secreto como variable de entorno o un secreto en una configuración de registro, la instancia de contenedor debe tener la versión `1.22.0` del agente de contenedor o una posterior.
+ Utilice los puntos de conexión de VPC de interfaz para mejorar los controles de seguridad. Debe crear los puntos de conexión de VPC de interfaz para Systems Manager. Para obtener información sobre cómo crear un punto de conexión de VPC, consulte [Mejora de la seguridad de las instancias de EC2 mediante puntos de conexión de VPC para Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/setup-create-vpc.html) en la *Guía del usuario de AWS Systems Manager*.
+ En la definición de tareas se debe utilizar un rol de ejecución de tareas con los permisos adicionales para el almacén de parámetros de Systems Manager. Para obtener más información, consulte [Rol de IAM de ejecución de tareas de Amazon ECS](task_execution_IAM_role.md).
+ Para las tareas de Windows configuradas para utilizar el controlador de registros `awslogs`, debe también establecer la variable de entorno `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE` en la instancia del contenedor. Utilice la siguiente sintaxis:

  ```
  <powershell>
  [Environment]::SetEnvironmentVariable("ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE", $TRUE, "Machine")
  Initialize-ECSAgent -Cluster <cluster name> -EnableTaskIAMRole -LoggingDrivers '["json-file","awslogs"]'
  </powershell>
  ```

## Creación del parámetro de Systems Manager
<a name="secrets-envvar-ssm-paramstore-create-parameter"></a>

Puede utilizar la consola de Systems Manager para crear un parámetro del almacén de parámetros de Systems Manager para la información confidencial. Para obtener más información, consulte [Creación de un parámetro de Systems Manager (consola)](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-create-console.html) o [Creación de un parámetro de Systems Manager (AWS CLI)](https://docs.aws.amazon.com/systems-manager/latest/userguide/param-create-cli.html) en la *Guía del usuario de AWS Systems Manager*.

## Adición de la variable de entorno a la definición del contenedor
<a name="secrets-ssm-paramstore-update-container-definition"></a>

Dentro de la definición de contenedor en la definición de tareas, especifique `secrets` con el nombre de la variable de entorno que se va a establecer en el contenedor y el ARN completo del parámetro del almacén de parámetros de Systems Manager que contiene la información confidencial que se va a presentar al contenedor. Para obtener más información, consulte [secrets](task_definition_parameters.md#ContainerDefinition-secrets).

A continuación, se incluye un fragmento de código de una definición de tarea que muestra el formato cuando se hace referencia a un parámetro del Parameter Store de Systems Manager. Si el parámetro del Parameter Store de Systems Manager está en la misma región que la tarea que se va a lanzar, se puede utilizar el ARN completo o el nombre del parámetro. Si el parámetro existe en una región distinta, debe especificar el ARN completo.

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter/parameter_name"
    }]
  }]
}
```

Para obtener información sobre cómo crear una definición de tareas con el secreto especificado en una variable de entorno, consulte [Creación de una definición de tareas de Amazon ECS mediante la consola](create-task-definition.md).

## Actualice la aplicación para que recupere secretos del almacén de parámetros de Systems Manager mediante programación
<a name="secrets-ssm-paramstore-update-app"></a>

Para recuperar los datos confidenciales almacenados en el parámetro de Parameter Store de Systems Manager, consulte [Ejemplos de código de Systems Manager mediante SDK de AWS](https://docs.aws.amazon.com/code-library/latest/ug/ssm_code_examples.html) en la *Biblioteca de ejemplos de código del SDK de AWS*.

# Transmisión de secretos para la configuración de registro de Amazon ECS
<a name="secrets-logconfig"></a>

Puede utilizar el parámetro `secretOptions` en `logConfiguration` para transferir los datos confidenciales que se utilizan para los registros.

Puede almacenar el secreto en Secrets Manager o Systems Manager.

## Uso de Secrets Manager
<a name="secrets-logconfig-secrets-manager"></a>

En la definición de contenedor, al especificar una `logConfiguration`, puede especificar `secretOptions` con el nombre de la opción del controlador de registros para definir el contenedor y el ARN completo del secreto de Secrets Manager que contiene la información confidencial que se va a presentar al contenedor. Para obtener más información acerca de cómo crear secretos, consulte [Creación de un AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

A continuación, se incluye un fragmento de código de una definición de tarea que muestra el formato cuando se referencia un secreto de Secrets Manager.

```
{
  "containerDefinitions": [{
    "logConfiguration": [{
      "logDriver": "splunk",
      "options": {
        "splunk-url": "https://your_splunk_instance:8088"
      },
      "secretOptions": [{
        "name": "splunk-token",
        "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
      }]
    }]
  }]
}
```

## Adición de la variable de entorno a la definición del contenedor
<a name="secrets-envvar-ssm-paramstore-update-container-definition"></a>

En la definición de contenedor, especifique `secrets` con el nombre de la variable de entorno que se va a establecer en el contenedor y el ARN completo del parámetro del Parameter Store de Systems Manager que contiene la información confidencial que se va a presentar al contenedor. Para obtener más información, consulte [secrets](task_definition_parameters.md#ContainerDefinition-secrets).

A continuación, se incluye un fragmento de código de una definición de tarea que muestra el formato cuando se hace referencia a un parámetro del Parameter Store de Systems Manager. Si el parámetro del Parameter Store de Systems Manager está en la misma región que la tarea que se va a lanzar, se puede utilizar el ARN completo o el nombre del parámetro. Si el parámetro existe en una región distinta, debe especificar el ARN completo.

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter/parameter_name"
    }]
  }]
}
```

Para obtener información sobre cómo crear una definición de tareas con el secreto especificado en una variable de entorno, consulte [Creación de una definición de tareas de Amazon ECS mediante la consola](create-task-definition.md).

## Uso de Systems Manager
<a name="secrets-logconfig-ssm-paramstore"></a>

Puede introducir información confidencial en una configuración de registros. En la definición de contenedor, al especificar una `logConfiguration`, puede especificar `secretOptions` con el nombre de la opción del controlador de registros que va a definir en el contenedor y el ARN completo del parámetro del Parameter Store de Systems Manager que contiene la información confidencial que se va a presentar al contenedor.

**importante**  
Si el parámetro del Parameter Store de Systems Manager está en la misma región que la tarea que se va a lanzar, se puede utilizar el ARN completo o el nombre del parámetro. Si el parámetro existe en una región distinta, debe especificar el ARN completo.

A continuación, se incluye un fragmento de código de una definición de tarea que muestra el formato cuando se hace referencia a un parámetro del Parameter Store de Systems Manager.

```
{
  "containerDefinitions": [{
    "logConfiguration": [{
      "logDriver": "fluentd",
      "options": {
        "tag": "fluentd demo"
      },
      "secretOptions": [{
        "name": "fluentd-address",
        "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter:/parameter_name"
      }]
    }]
  }]
}
```

# Especificación de información confidencial mediante secretos de Secrets Manager en Amazon ECS
<a name="specifying-sensitive-data-tutorial"></a>

Amazon ECS permite introducir información confidencial en los contenedores, la almacena en secretos de AWS Secrets Manager y, a continuación, la referencia en la definición de contenedor. Para obtener más información, consulte [Transferencia de datos confidenciales a un contenedor de Amazon ECS](specifying-sensitive-data.md).

Obtenga información sobre cómo crear un secreto de Secrets Manager, hacer referencia al secreto en una definición de tareas de Amazon ECS y, luego, comprobar que funciona al consultar la variable de entorno dentro de un contenedor que muestra el contenido del secreto.

## Requisitos previos
<a name="specifying-sensitive-data-tutorial-prereqs"></a>

En este tutorial se supone que los siguientes requisitos previos se han completado:
+ Se han completado los pasos que se indican en [Configuración para utilizar Amazon ECS](get-set-up-for-amazon-ecs.md).
+ El usuario dispone de los permisos de IAM requeridos para crear los recursos de Secrets Manager y Amazon ECS.

## Paso 1: Crear un secreto de Secrets Manager
<a name="specifying-sensitive-data-tutorial-create-secret"></a>

Puede utilizar la consola de Secrets Manager para crear un secreto con su información confidencial. En este tutorial se creará un secreto básico para almacenar un nombre de usuario y una contraseña para referencia futura en un contenedor. Para obtener más información, consulte [Creación de un secreto de AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) en la *Guía del usuario de AWS Secrets Manager*.

Los pares clave/valor que se almacenarán en este secreto (**key/value pairs to be stored in this secret**) son el valor de la variable de entorno en el contenedor al final del tutorial.

Guarde el **Secret ARN** (ARN del secreto) para hacer referencia en su política de IAM de ejecución de tareas y la definición de tarea en pasos posteriores.

## Paso 2: agregue los permisos secretos al rol de ejecución de tareas.
<a name="specifying-sensitive-data-tutorial-update-iam"></a>

Para que Amazon ECS recupere la información confidencial de su secreto de Secrets Manager, debe contar con los permisos secretos para el rol de ejecución de tareas. Para obtener más información, consulte [Permisos de Secrets Manager o Systems Manager](task_execution_IAM_role.md#task-execution-secrets).

## Paso 3: Cree una definición de tarea
<a name="specifying-sensitive-data-tutorial-create-taskdef"></a>

Puede utilizar la consola de Amazon ECS para crear una definición de tareas que haga referencia a un secreto de Secrets Manager.

**Para crear una definición de tarea que especifique un secreto**

Utilice la consola de IAM para actualizar el rol de ejecución de tareas con los permisos requeridos.

1. Abra la consola en [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. En el panel de navegación, elija **Task Definitions** (Definiciones de tareas).

1. Elija **Create new task definition** (Crear nueva definición de tarea) y **Create new task definition with JSON** (Crear nueva definición de tarea con JSON).

1. En el cuadro del editor JSON, ingrese el siguiente texto JSON de definición de tareas y asegúrese de especificar el ARN completo del secreto de Secrets Manager que creó en el paso 1 y el rol de ejecución de tareas que actualizó en el paso 2. Seleccione **Save**.

1. 

   ```
   {
       "executionRoleArn": "arn:aws:iam::aws_account_id:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "entryPoint": [
                   "sh",
                   "-c"
               ],
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ],
               "command": [
                   "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
               ],
               "cpu": 10,
               "secrets": [
                   {
                       "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:username_value",
                       "name": "username_value"
                   }
               ],
               "memory": 300,
               "image": "public.ecr.aws/docker/library/httpd:2.4",
               "essential": true,
               "name": "ecs-secrets-container"
           }
       ],
       "family": "ecs-secrets-tutorial"
   }
   ```

1. Seleccione **Crear**.

## Paso 4: cree un clúster
<a name="specifying-sensitive-data-tutorial-create-cluster"></a>

Puede utilizar la consola de Amazon ECS para crear un clúster que contenga una instancia de contenedor en la que se va a ejecutar la tarea. Si tiene un clúster existente con al menos una instancia de contenedor registrada en ella, con los recursos disponibles para ejecutar una instancia de la definición de tarea creada para este tutorial, puede pasar al siguiente paso.

Para este tutorial, vamos a crear un clúster con una instancia de contenedor `t2.micro` mediante la AMI de Amazon Linux 2 optimizada para Amazon ECS.

Para obtener información acerca de cómo crear un clúster para EC2, consulte [Creación de un clúster de Amazon ECS para cargas de trabajo de Amazon EC2](create-ec2-cluster-console-v2.md).

## Paso 5: ejecute una tarea
<a name="specifying-sensitive-data-tutorial-run-task"></a>

Puede utilizar la consola de Amazon ECS para ejecutar una tarea mediante la definición de tareas creada. En este tutorial, pondremos en marcha una tarea mediante EC2, con el clúster que creamos en el paso anterior. 

Para obtener información sobre cómo ejecutar una tarea, consulte [Ejecución de una aplicación como tarea de Amazon ECS](standalone-task-create.md).

## Paso 6: Verificar
<a name="specifying-sensitive-data-tutorial-verify"></a>

Puede verificar que todos los pasos se han completado correctamente y que la variable de entorno se ha creado correctamente en el contenedor con los pasos que se describen a continuación.

**Para verificar que se ha creado la variable de entorno**

1. Busque la dirección IP o DNS pública para su instancia de contenedor.

   1. Abra la consola en [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

   1. En el panel de navegación, elija **Clústeres** y, a continuación, elija el clúster que creó.

   1. Elija **Infraestructura** y, a continuación, elija la instancia de contenedor.

   1. Registre la **IP pública** o el **DNS público** para su instancia.

1. Si está utilizando un equipo con macOS o Linux, conéctese a la instancia con el siguiente comando, sustituyendo la ruta por su clave privada y la dirección pública para su instancia:

   ```
   $ ssh -i /path/to/my-key-pair.pem ec2-user@ec2-198-51-100-1.compute-1.amazonaws.com
   ```

   Para obtener más información acerca del uso de una computadora con Windows, consulte [Conexión a la instancia de Linux con PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-linux-inst-from-windows.html) en la *Guía del usuario de Amazon EC2*.
**importante**  
Para obtener más información acerca de los problemas que pueden surgir al conectarse a la instancia, consulte [Solucione el problema de conectar la instancia](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html) en la *Guía del usuario de Amazon EC2*.

1. Obtenga la lista de los contenedores que se ejecutan en la instancia. Anote el ID del contenedor `ecs-secrets-tutorial`.

   ```
   docker ps
   ```

1. Conéctese al contenedor `ecs-secrets-tutorial` con el ID de contenedor desde la salida del paso anterior.

   ```
   docker exec -it container_ID /bin/bash
   ```

1. Utilice el comando `echo` para imprimir el valor de la variable del entorno.

   ```
   echo $username_value
   ```

   Si el tutorial no se ha realizado correctamente, debería ver el siguiente resultado:

   ```
   password_value
   ```
**nota**  
Si lo prefiere, puede mostrar todas las variables de entorno en su contenedor con el comando `env` (o `printenv`).

## Paso 7: limpiar
<a name="specifying-sensitive-data-tutorial-cleanup"></a>

Cuando termine este tutorial, debe limpiar los recursos asociados para evitar incurrir en cargos generados por recursos sin utilizar.

**Para limpiar los recursos.**

1. Abra la consola en [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. En el panel de navegación, seleccione **Clusters (Clústeres)**.

1. En la página **Clusters** (Clústeres), elija el clúster.

1. Elija **Delete cluster**. 

1. En el cuadro de confirmación, ingrese **Eliminar *cluster-name*** y, a continuación, elija **Eliminar**.

1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Seleccione **Roles** en el panel de navegación. 

1. En la lista de roles, busque `ecsTaskExecutionRole` y selecciónelo.

1. Elija **Permisos** y, a continuación, elija la **X** junto a **ECSSecretsTutorial**. Elija **Eliminar**.

1. Abra la consola de Secrets Manager en[https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).

1. Seleccione el secreto **username\$1value** creado y elija **Actions (Acciones)**, **Delete secret (Eliminar secreto)**.