# Tutoriales para Amazon ECS
<a name="ecs-tutorials"></a>

En los siguientes tutoriales, aprenderá a realizar tareas comunes mediante Amazon ECS.

Puede utilizar cualquiera de los siguientes tutoriales para obtener más información sobre cómo empezar a utilizar Amazon ECS.


| Información general del tutorial | Más información | 
| --- | --- | 
|  Introducción a Amazon ECS en Fargate.  |  [Información sobre cómo crear una tarea de Linux de Amazon ECS para Fargate](getting-started-fargate.md)  | 
|  Introducción a los contenedores de Windows en Fargate.  |  [Información sobre cómo crear una tarea de Windows de Amazon ECS para Fargate](Windows_fargate-getting_started.md)  | 
|  Introducción a los contenedores Windows para EC2.  |  [Información sobre cómo crear una tarea de Windows de Amazon ECS para EC2](getting-started-ecs-ec2-v2.md)  | 

Puede utilizar cualquiera de los siguientes tutoriales para implementar tareas en Amazon ECS mediante la AWS CLI.


| Información general del tutorial | Más información | 
| --- | --- | 
|  Cree una tarea de Linux para Fargate.  |  [Creación de una tarea de Linux de Amazon ECS para Fargate con AWS CLI](ECS_AWSCLI_Fargate.md)  | 
|  Cree una tarea de Windows para Fargate.  |  [Creación de una tarea de Amazon ECS de Windows para Fargate con AWS CLI](ECS_AWSCLI_Fargate_windows.md)  | 
|  Cree una tarea de Linux para EC2.  |  [Creación de una tarea de Amazon ECS para EC2 con AWS CLI](ECS_AWSCLI_EC2.md)  | 

Puede utilizar cualquiera de los siguientes tutoriales para obtener más información sobre la supervisión y el registro.


| Información general del tutorial | Más información | 
| --- | --- | 
|  Configure una función de Lambda simple que escuche los eventos de tareas y los escriba en un flujo de registro de Registros de CloudWatch.  |  [Configuración de Amazon ECS para escuchar los eventos de Eventos de CloudWatch](ecs_cwet.md)  | 
|  Configure una regla de eventos de Amazon EventBridge que solo capture eventos de tareas en los que la tarea dejó de ejecutarse porque uno de sus contenedores esenciales finalizó.   |  [Envío de alertas de Amazon Simple Notification Service para eventos de tareas detenidas de Amazon ECS](ecs_cwet2.md)  | 
|  Concatene mensajes de registro que originalmente pertenecen a un contexto, pero que se dividieron en varios registros o líneas de registro.  |  [Concatenación de mensajes de registro de Amazon ECS de seguimiento de pila o de varias líneas](firelens-concatanate-multiline.md)  | 
|  Implemente contenedores de Fluent Bit en sus instancias de Windows que se ejecutan en Amazon ECS para transmitir los registros generados por las tareas de Windows a Amazon CloudWatch a fin de obtener un registro centralizado.  |  [Implementación de Fluent Bit en contenedores de Amazon ECS para Windows](tutorial-deploy-fluentbit-on-windows.md)  | 

Puede utilizar cualquiera de los siguientes tutoriales para obtener más información sobre cómo utilizar la autenticación de Active Directory con una cuenta de servicio administrada de grupo en Amazon ECS.


| Información general del tutorial | Más información | 
| --- | --- | 
|  Utilice una cuenta de servicio administrada de grupo con contenedores de Linux en EC2.  |  [Uso de gMSA para contenedores de EC2 Linux en Amazon ECS](linux-gmsa.md)  | 
|  Utilice una cuenta de servicio administrada de grupo con contenedores de Windows en EC2.  |  [Obtenga información sobre cómo utilizar gMSA para contenedores de EC2 para Windows en Amazon ECS.](windows-gmsa.md)  | 
|  Utilice una cuenta de servicio administrada de grupo con contenedores de Linux en Fargate.  |  [Uso de gMSA para contenedores de Linux en Fargate](fargate-linux-gmsa.md)  | 
|  Cree una tarea que ejecute un contenedor de Windows que tenga credenciales para acceder a Active Directory con una cuenta de servicio administrada de grupo sin dominio.  |  [Uso de contenedores de Amazon ECS para Windows con gMSA sin dominio mediante la AWS CLI](tutorial-gmsa-windows.md)  | 

# Creación de una tarea de Linux de Amazon ECS para Fargate con AWS CLI
<a name="ECS_AWSCLI_Fargate"></a>

Los siguientes pasos le ayudan a configurar un clúster, registrar una definición de tarea, ejecutar una tarea Linux y llevar a cabo otros escenarios comunes en Amazon ECS con la AWS CLI. Utilice la versión más reciente de la AWS CLI. Para obtener más información acerca de cómo actualizar a la versión más reciente, consulte [Instalación o actualización de la versión más reciente de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

**nota**  
Puede utilizar puntos de conexión de servicio de doble pila para interactuar con Amazon ECS desde la AWS CLI, los SDK y la API de Amazon ECS a través de IPv4 e IPv6. Para obtener más información, consulte [Uso de puntos de conexión de doble pila en Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [Requisitos previos](#ECS_AWSCLI_Fargate_prereq)
+ [Paso 1: Crear un clúster](#ECS_AWSCLI_Fargate_create_cluster)
+ [Paso 2: Registrar una definición de tarea Linux](#ECS_AWSCLI_Fargate_register_task_definition)
+ [Paso 3: Mostrar la lista de definiciones de tareas](#ECS_AWSCLI_Fargate_list_task_definitions)
+ [Paso 4: Crear un servicio](#ECS_AWSCLI_Fargate_create_service)
+ [Paso 5: Mostrar la lista de los servicios](#ECS_AWSCLI_Fargate_list_services)
+ [Paso 6: Describir el servicio en ejecución](#ECS_AWSCLI_Fargate_describe_service)
+ [Paso 7: Prueba](#ECS_AWSCLI_Fargate_test)
+ [Paso 8: eliminación](#ECS_AWSCLI_Fargate_clean_up)

## Requisitos previos
<a name="ECS_AWSCLI_Fargate_prereq"></a>

En este tutorial se supone que los siguientes requisitos previos se han realizado.
+ La última versión de la AWS CLI está instalada y configurada. Para obtener información acerca de cómo instalar o actualizar la AWS CLI, consulte [Instalación o actualización de la versión más reciente de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Se han completado los pasos que se indican en [Configuración para utilizar Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Su usuario de IAM dispone de los permisos requeridos que se especifican en la política de IAM [AmazonECS\$1FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) de ejemplo.
+ Tiene una VPC y un grupo de seguridad creados para utilizarlos. En este tutorial se utiliza una imagen de contenedor alojada en Amazon ECR Public por lo que su tarea debe tener acceso a Internet. Para que su tarea tenga una ruta a Internet, utilice una de las siguientes opciones.
  + Utilice una subred privada con una gateway NAT que tenga una dirección IP elástica.
  + Utilice una subred pública y asigne una dirección IP pública a la tarea.

  Para obtener más información, consulte [Creación de una nube virtual privada](get-set-up-for-amazon-ecs.md#create-a-vpc).

  Para obtener información sobre las reglas y los grupos de seguridad, consulte [Default security groups for your VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#DefaultSecurityGroup) (Grupos de seguridad predeterminados para sus VPC) y [Example rules](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#security-group-rule-examples) (Reglas de ejemplo) en la *Guía del usuario de Amazon Virtual Private Cloud*.
+  Si sigue este tutorial utilizando una subred privada, puede utilizar Amazon ECS Exec para interactuar directamente con el contenedor y probar la implementación. Necesitará crear un rol de IAM en una tarea para usar ECS Exec. Para obtener más información acerca del rol de IAM de la tarea y otros requisitos previos, consulte [Supervisión de los contenedores de Amazon ECS con Amazon ECS Exec](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html).
+ (Opcional) AWS CloudShell es una herramienta que proporciona a los clientes una línea de comandos sin necesidad de crear su propia instancia de EC2. Para obtener más información, consulte [¿Qué es AWS CloudShell?](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) en la *Guía del usuario de AWS CloudShell*.

## Paso 1: Crear un clúster
<a name="ECS_AWSCLI_Fargate_create_cluster"></a>

De forma predeterminada, la cuenta recibe un clúster `default`.

**nota**  
El beneficio de utilizar el clúster `default` que se le facilita es que no tiene que especificar la opción `--cluster cluster_name` en los comandos siguientes. Si crea su propio clúster no predeterminado, tiene que especificar `--cluster cluster_name` para cada comando que pretenda utilizar con dicho clúster.

Cree su propio clúster con un nombre único con el comando siguiente:

```
aws ecs create-cluster --cluster-name fargate-cluster
```

Salida:

```
{
    "cluster": {
        "status": "ACTIVE", 
        "defaultCapacityProviderStrategy": [], 
        "statistics": [], 
        "capacityProviders": [], 
        "tags": [], 
        "clusterName": "fargate-cluster", 
        "settings": [
            {
                "name": "containerInsights", 
                "value": "disabled"
            }
        ], 
        "registeredContainerInstancesCount": 0, 
        "pendingTasksCount": 0, 
        "runningTasksCount": 0, 
        "activeServicesCount": 0, 
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster"
    }
}
```

## Paso 2: Registrar una definición de tarea Linux
<a name="ECS_AWSCLI_Fargate_register_task_definition"></a>

Antes de poder ejecutar una tarea en su clúster de ECS, debe registrar una definición de tareas. Las definiciones de tareas son listas de contenedores agrupadas. El siguiente ejemplo es una definición de tarea simple que crea una aplicación web PHP usando la imagen del contenedor httpd alojada en Docker Hub. Para obtener más información acerca de los parámetros de definición de tareas disponibles, consulte [Definiciones de tareas de Amazon ECS](task_definitions.md). Para este tutorial, el `taskRoleArn` solo es necesario si va a implementar la tarea en una subred privada y desea probar la implementación. Reemplace el `taskRoleArn` por el rol de tarea de IAM que creó para utilizar ECS Exec, como se menciona en [Requisitos previos](#ECS_AWSCLI_Fargate_prereq).

```
 {
        "family": "sample-fargate",
        "networkMode": "awsvpc",
        "taskRoleArn": "arn:aws:iam::aws_account_id:role/execCommandRole", 
        "containerDefinitions": [
            {
                "name": "fargate-app",
                "image": "public.ecr.aws/docker/library/httpd:latest",
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "essential": true,
                "entryPoint": [
                    "sh",
                    "-c"
                ],
                "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\""
                ]
            }
        ],
        "requiresCompatibilities": [
            "FARGATE"
        ],
        "cpu": "256",
        "memory": "512"
}
```

Guarde el JSON de definición de tarea como un archivo y páselo con la opción `--cli-input-json file://path_to_file.json`. 

Para utilizar un archivo JSON para definiciones de contenedor:

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/fargate-task.json
```

El comando **register-task-definition** devuelve una descripción de la definición de tarea después de realizar su registro.

## Paso 3: Mostrar la lista de definiciones de tareas
<a name="ECS_AWSCLI_Fargate_list_task_definitions"></a>

Puede enumerar las definiciones de tareas para su cuenta en cualquier momento con el comando **list-task-definitions**. La salida de este comando muestra los valores `family` y `revision`, que puede utilizar conjuntamente al llamar a **run-task** o **start-task**.

```
aws ecs list-task-definitions
```

Salida:

```
{
    "taskDefinitionArns": [
        "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1"
    ]
}
```

## Paso 4: Crear un servicio
<a name="ECS_AWSCLI_Fargate_create_service"></a>

Una vez que se haya registrado una tarea para la cuenta, puede crear un servicio para la tarea registradas en su clúster. En este ejemplo, se crea un servicio con una instancia de la definición de tarea `sample-fargate:1` que se ejecuta en el clúster. La tarea requiere una ruta a Internet, por lo que hay dos maneras de lograr esto. Una forma es utilizar una subred privada configurada con una gateway NAT con una dirección IP elástica en una subred pública. Otra forma es utilizar una subred pública y asignar una dirección IP pública a su tarea. A continuación, ofrecemos ambos ejemplos. 

Ejemplo de uso de una subred privada. La opción ` enable-execute-command ` es necesaria para utilizar Amazon ECS Exec.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234]}" --enable-execute-command
```

Ejemplo de uso de una subred pública.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234],assignPublicIp=ENABLED}"
```

El comando **create-service** devuelve una descripción de la definición de tarea después de realizar su registro.

## Paso 5: Mostrar la lista de los servicios
<a name="ECS_AWSCLI_Fargate_list_services"></a>

Enumere los servicios de su clúster. Debe aparecer el servicio que ha creado en la sección anterior. Puede tomar el nombre de servicio o el ARN completo que se devuelve desde este comando y utilizarlo para describir el servicio más adelante.

```
aws ecs list-services --cluster fargate-cluster
```

Salida:

```
{
    "serviceArns": [
        "arn:aws:ecs:region:aws_account_id:service/fargate-cluster/fargate-service"
    ]
}
```

## Paso 6: Describir el servicio en ejecución
<a name="ECS_AWSCLI_Fargate_describe_service"></a>

Describa el servicio utilizado el nombre del servicio recuperado antes para obtener información adicional sobre la tarea.

```
aws ecs describe-services --cluster fargate-cluster --services fargate-service
```

Si tiene éxito, devolverá una descripción de los errores del servicio y los servicios. Por ejemplo, en la sección ` services `, encontrará información sobre implementaciones, como el estado de las tareas en ejecución o pendientes. También puede encontrar información sobre la definición de tarea, la configuración de la red y los eventos con marca temporal. En la sección de errores, encontrará información sobre los errores, si los hay, asociados a la llamada. Para solucionar problemas, consulte [Mensajes de eventos de servicio](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-event-messages.html). Para obtener más información acerca de la descripción del servicio, consulte [Describir servicios](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeServices).

```
{
    "services": [
        {
            "networkConfiguration": {
                "awsvpcConfiguration": {
                    "subnets": [
                        "subnet-abcd1234"
                    ], 
                    "securityGroups": [
                        "sg-abcd1234"
                    ], 
                    "assignPublicIp": "ENABLED"
                }
            }, 
            "launchType": "FARGATE", 
            "enableECSManagedTags": false, 
            "loadBalancers": [], 
            "deploymentController": {
                "type": "ECS"
            }, 
            "desiredCount": 1, 
            "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster", 
            "serviceArn": "arn:aws:ecs:region:aws_account_id:service/fargate-service", 
            "deploymentConfiguration": {
                "maximumPercent": 200, 
                "minimumHealthyPercent": 100
            }, 
            "createdAt": 1692283199.771, 
            "schedulingStrategy": "REPLICA", 
            "placementConstraints": [], 
            "deployments": [
                {
                    "status": "PRIMARY", 
                    "networkConfiguration": {
                        "awsvpcConfiguration": {
                            "subnets": [
                                "subnet-abcd1234"
                            ], 
                            "securityGroups": [
                                "sg-abcd1234"
                            ], 
                            "assignPublicIp": "ENABLED"
                        }
                    }, 
                    "pendingCount": 0, 
                    "launchType": "FARGATE", 
                    "createdAt": 1692283199.771, 
                    "desiredCount": 1, 
                    "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1", 
                    "updatedAt": 1692283199.771, 
                    "platformVersion": "1.4.0", 
                    "id": "ecs-svc/9223370526043414679", 
                    "runningCount": 0
                }
            ], 
            "serviceName": "fargate-service", 
            "events": [
                {
                    "message": "(service fargate-service) has started 2 tasks: (task 53c0de40-ea3b-489f-a352-623bf1235f08) (task d0aec985-901b-488f-9fb4-61b991b332a3).", 
                    "id": "92b8443e-67fb-4886-880c-07e73383ea83", 
                    "createdAt": 1510811841.408
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task b4911bee-7203-4113-99d4-e89ba457c626) (task cc5853e3-6e2d-4678-8312-74f8a7d76474).", 
                    "id": "d85c6ec6-a693-43b3-904a-a997e1fc844d", 
                    "createdAt": 1510811601.938
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task cba86182-52bf-42d7-9df8-b744699e6cfc) (task f4c1ad74-a5c6-4620-90cf-2aff118df5fc).", 
                    "id": "095703e1-0ca3-4379-a7c8-c0f1b8b95ace", 
                    "createdAt": 1510811364.691
                }
            ], 
            "runningCount": 0, 
            "status": "ACTIVE", 
            "serviceRegistries": [], 
            "pendingCount": 0, 
            "createdBy": "arn:aws:iam::aws_account_id:user/user_name", 
            "platformVersion": "LATEST", 
            "placementStrategy": [], 
            "propagateTags": "NONE", 
            "roleArn": "arn:aws:iam::aws_account_id:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS", 
            "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1"
        }
    ], 
    "failures": []
}
```

## Paso 7: Prueba
<a name="ECS_AWSCLI_Fargate_test"></a>

### Prueba de tarea implementada mediante una subred pública
<a name="ECS_AWSCLI_Fargate_test_public"></a>

Describa la tarea del servicio para que pueda obtener la interfaz de red elástica (ENI) para la tarea. 

Primero, obtenga el ARN de la tarea.

```
aws ecs list-tasks --cluster fargate-cluster --service fargate-service
```

El resultado contiene el ARN de la tarea.

```
{
    "taskArns": [
        "arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE
    ]
}
```

Describa la tarea y busque el ID de ENI. Utilice el ARN de tareas para el parámetro `tasks`.

```
aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/service/EXAMPLE
```

La información de datos adjuntos se muestra en la salida. 

```
{
    "tasks": [
        {
            "attachments": [
                {
                    "id": "d9e7735a-16aa-4128-bc7a-b2d5115029e9",
                    "type": "ElasticNetworkInterface",
                    "status": "ATTACHED",
                    "details": [
                        {
                            "name": "subnetId",
                            "value": "subnetabcd1234"
                        },
                        {
                            "name": "networkInterfaceId",
                            "value": "eni-0fa40520aeEXAMPLE"
                        },
                    ]
                }
…
}
```

Describa el ENI para obtener la dirección IP pública.

```
aws ec2 describe-network-interfaces --network-interface-id  eni-0fa40520aeEXAMPLE
```

La dirección IP pública se encuentra en la salida. 

```
{
    "NetworkInterfaces": [
        {
            "Association": {
                "IpOwnerId": "amazon",
                "PublicDnsName": "ec2-34-229-42-222.compute-1.amazonaws.com",
                "PublicIp": "198.51.100.2"
            },
…
}
```

Ingrese dicha dirección IP pública en el navegador web. Debe ver una página web en la que se muestre la aplicación **Amazon ECS **de muestra.

### Prueba de tarea implementada mediante una subred privada
<a name="ECS_AWSCLI_Fargate_test_private.title"></a>

 Describa la tarea y ubique los `managedAgents` para comprobar que el `ExecuteCommandAgent` se está ejecutando. Tenga en cuenta la `privateIPv4Address` para un uso posterior.

```
aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE
```

 La información administrada del agente se enumera en la salida. 

```
{
     "tasks": [
        {
            "attachments": [
                {
                    "id": "d9e7735a-16aa-4128-bc7a-b2d5115029e9",
                    "type": "ElasticNetworkInterface",
                    "status": "ATTACHED",
                    "details": [
                        {
                            "name": "subnetId",
                            "value": "subnetabcd1234"
                        },
                        {
                            "name": "networkInterfaceId",
                            "value": "eni-0fa40520aeEXAMPLE"
                        },
                        {
                            "name": "privateIPv4Address",
                            "value": "10.0.143.156"
                        }
                    ]
                }
            ],
     ...  
     "containers": [
         {
         ...
        "managedAgents": [
                        {
                            "lastStartedAt": "2023-08-01T16:10:13.002000+00:00",
                            "name": "ExecuteCommandAgent",
                            "lastStatus": "RUNNING"
                        } 
                ],
        ...
    }
```

 Después de comprobar que el ` ExecuteCommandAgent` se está ejecutando, puede ejecutar el siguiente comando para ejecutar un intérprete de comandos interactivo en el contenedor de la tarea. 

```
  aws ecs execute-command --cluster fargate-cluster \
      --task  arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE  \
      --container  fargate-app \
      --interactive \
      --command "/bin/sh"
```

 Después de ejecutar el intérprete de comandos interactivo, ejecute los siguientes comandos para instalar la cURL. 

```
apt update 
```

```
apt install curl 
```

 Tras instalar la cURL, ejecute el siguiente comando con la dirección IP privada que obtuvo anteriormente.

```
 curl 10.0.143.156 
```

 Debería ver el equivalente en HTML de la página web de la aplicación de ejemplo de **Amazon ECS**.

```
<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>
```

## Paso 8: eliminación
<a name="ECS_AWSCLI_Fargate_clean_up"></a>

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

Elimine el servicio.

```
aws ecs delete-service --cluster fargate-cluster --service fargate-service --force
```

Elimine el clúster.

```
aws ecs delete-cluster --cluster fargate-cluster
```

# Creación de una tarea de Amazon ECS de Windows para Fargate con AWS CLI
<a name="ECS_AWSCLI_Fargate_windows"></a>

Los siguientes pasos le ayudan a configurar un clúster, registrar una definición de tarea, ejecutar una tarea de Windows y llevar a cabo otras actividades comunes en Amazon ECS con la AWS CLI. Asegúrese de que utiliza la versión más reciente de la AWS CLI. Para obtener más información acerca de cómo actualizar a la versión más reciente, consulte [Instalación o actualización de la versión más reciente de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

**nota**  
Puede utilizar puntos de conexión de servicio de doble pila para interactuar con Amazon ECS desde la AWS CLI, los SDK y la API de Amazon ECS a través de IPv4 e IPv6. Para obtener más información, consulte [Uso de puntos de conexión de doble pila en Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [Requisitos previos](#ECS_AWSCLI_Fargate_windows_prereq)
+ [Paso 1: Crear un clúster](#ECS_AWSCLI_Fargate_windows_create_cluster)
+ [Paso 2: Registrar una definición de tareas de Windows](#ECS_AWSCLI_Fargate_windows_register_task_definition)
+ [Paso 3: Mostrar la lista de definiciones de tareas](#ECS_AWSCLI_Fargate_windows__list_task_definitions)
+ [Paso 4: Crear un servicio](#ECS_AWSCLI_Fargate_windows_create_service)
+ [Paso 5: Mostrar la lista de los servicios](#ECS_AWSCLI_Fargate_windows_list_services)
+ [Paso 6: Describir el servicio en ejecución](#ECS_AWSCLI_Fargate_windows_describe_service)
+ [Paso 7: Eliminación](#ECS_AWSCLI_Fargate_windows_clean_up)

## Requisitos previos
<a name="ECS_AWSCLI_Fargate_windows_prereq"></a>

En este tutorial se supone que los siguientes requisitos previos se han realizado.
+ La última versión de la AWS CLI está instalada y configurada. Para obtener más información acerca de cómo instalar la AWS CLI o actualizarla, consulte [Instalación o actualización de la versión más reciente de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Se han completado los pasos que se indican en [Configuración para utilizar Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Su usuario de IAM dispone de los permisos requeridos que se especifican en la política de IAM [AmazonECS\$1FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) de ejemplo.
+ Tiene una VPC y un grupo de seguridad creados para utilizarlos. En este tutorial se utiliza una imagen de contenedor alojada en Docker Hub por lo que su tarea debe tener acceso a Internet. Para que su tarea tenga una ruta a Internet, utilice una de las siguientes opciones.
  + Utilice una subred privada con una gateway NAT que tenga una dirección IP elástica.
  + Utilice una subred pública y asigne una dirección IP pública a la tarea.

  Para obtener más información, consulte [Creación de una nube virtual privada](get-set-up-for-amazon-ecs.md#create-a-vpc).

  Para obtener información sobre las reglas y los grupos de seguridad, consulte [Default security groups for your VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#DefaultSecurityGroup) (Grupos de seguridad predeterminados para sus VPC) y [Example rules](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#security-group-rule-examples) (Reglas de ejemplo) en la *Guía del usuario de Amazon Virtual Private Cloud*.
+ (Opcional) AWS CloudShell es una herramienta que proporciona a los clientes una línea de comandos sin necesidad de crear su propia instancia de EC2. Para obtener más información, consulte [¿Qué es AWS CloudShell?](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) en la *Guía del usuario de AWS CloudShell*.

## Paso 1: Crear un clúster
<a name="ECS_AWSCLI_Fargate_windows_create_cluster"></a>

De forma predeterminada, la cuenta recibe un clúster `default`.

**nota**  
El beneficio de utilizar el clúster `default` que se le facilita es que no tiene que especificar la opción `--cluster cluster_name` en los comandos siguientes. Si crea su propio clúster no predeterminado, tiene que especificar `--cluster cluster_name` para cada comando que pretenda utilizar con dicho clúster.

Cree su propio clúster con un nombre único con el comando siguiente:

```
aws ecs create-cluster --cluster-name fargate-cluster
```

Salida:

```
{
    "cluster": {
        "status": "ACTIVE", 
        "statistics": [], 
        "clusterName": "fargate-cluster", 
        "registeredContainerInstancesCount": 0, 
        "pendingTasksCount": 0, 
        "runningTasksCount": 0, 
        "activeServicesCount": 0, 
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster"
    }
}
```

## Paso 2: Registrar una definición de tareas de Windows
<a name="ECS_AWSCLI_Fargate_windows_register_task_definition"></a>

Antes de poder ejecutar una tarea de Windows en su clúster de Amazon ECS, debe registrar una definición de tareas. Las definiciones de tareas son listas de contenedores agrupadas. El siguiente ejemplo es una sencilla definición de tarea que crea una aplicación web. Para obtener más información acerca de los parámetros de definición de tareas disponibles, consulte [Definiciones de tareas de Amazon ECS](task_definitions.md).

```
{
    "containerDefinitions": [
        {
            "command": ["New-Item -Path C:\\inetpub\\wwwroot\\index.html -Type file -Value '<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>'; C:\\ServiceMonitor.exe w3svc"],
            "entryPoint": [
                "powershell",
                "-Command"
            ],
            "essential": true,
            "cpu": 2048,
            "memory": 4096,
            "image": "mcr.microsoft.com/windows/servercore/iis:windowsservercore-ltsc2019",
            "name": "sample_windows_app",
            "portMappings": [
                {
                    "hostPort": 80,
                    "containerPort": 80,
                    "protocol": "tcp"
                }
            ]
        }
    ],
    "memory": "4096",
    "cpu": "2048",
    "networkMode": "awsvpc",
    "family": "windows-simple-iis-2019-core",
    "executionRoleArn": "arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
    "runtimePlatform": {"operatingSystemFamily": "WINDOWS_SERVER_2019_CORE"},
    "requiresCompatibilities": ["FARGATE"]
}
```

El ejemplo anterior de JSON se puede transferir a la AWS CLI de dos formas: puede guardar la definición de tareas JSON como un archivo y transferirlo con la opción `--cli-input-json file://path_to_file.json`.

Para utilizar un archivo JSON para definiciones de contenedor:

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/fargate-task.json
```

El comando **register-task-definition** devuelve una descripción de la definición de tarea después de realizar su registro.

## Paso 3: Mostrar la lista de definiciones de tareas
<a name="ECS_AWSCLI_Fargate_windows__list_task_definitions"></a>

Puede enumerar las definiciones de tareas para su cuenta en cualquier momento con el comando **list-task-definitions**. La salida de este comando muestra los valores `family` y `revision`, que puede utilizar conjuntamente al llamar a **run-task** o **start-task**.

```
aws ecs list-task-definitions
```

Salida:

```
{
    "taskDefinitionArns": [
        "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1"
    ]
}
```

## Paso 4: Crear un servicio
<a name="ECS_AWSCLI_Fargate_windows_create_service"></a>

Una vez que se haya registrado una tarea para la cuenta, puede crear un servicio para la tarea registradas en su clúster. En este ejemplo, se crea un servicio con una instancia de la definición de tarea `sample-fargate:1` que se ejecuta en el clúster. La tarea requiere una ruta a Internet, por lo que hay dos maneras de lograr esto. Una forma es utilizar una subred privada configurada con una gateway NAT con una dirección IP elástica en una subred pública. Otra forma es utilizar una subred pública y asignar una dirección IP pública a su tarea. A continuación, ofrecemos ambos ejemplos. 

Ejemplo de uso de una subred privada.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate-windows:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234]}"
```

Ejemplo de uso de una subred pública.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate-windows:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234],assignPublicIp=ENABLED}"
```

El comando **create-service** devuelve una descripción de la definición de tarea después de realizar su registro.

## Paso 5: Mostrar la lista de los servicios
<a name="ECS_AWSCLI_Fargate_windows_list_services"></a>

Enumere los servicios de su clúster. Debe aparecer el servicio que ha creado en la sección anterior. Puede tomar el nombre de servicio o el ARN completo que se devuelve desde este comando y utilizarlo para describir el servicio más adelante.

```
aws ecs list-services --cluster fargate-cluster
```

Salida:

```
{
    "serviceArns": [
        "arn:aws:ecs:region:aws_account_id:service/fargate-service"
    ]
}
```

## Paso 6: Describir el servicio en ejecución
<a name="ECS_AWSCLI_Fargate_windows_describe_service"></a>

Describa el servicio utilizado el nombre del servicio recuperado antes para obtener información adicional sobre la tarea.

```
aws ecs describe-services --cluster fargate-cluster --services fargate-service
```

Si tiene éxito, devolverá una descripción de los errores del servicio y los servicios. Por ejemplo, en la sección de servicios, encontrará información sobre implementaciones, como el estado de las tareas en ejecución o pendientes. También puede encontrar información sobre la definición de tarea, la configuración de la red y los eventos con marca temporal. En la sección de errores, encontrará información sobre los errores, si los hay, asociados a la llamada. Para solucionar problemas, consulte [Mensajes de eventos de servicio](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-event-messages.html). Para obtener más información acerca de la descripción del servicio, consulte [Describir servicios](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeServices). 

```
{
    "services": [
        {
            "status": "ACTIVE", 
            "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1", 
            "pendingCount": 2, 
            "launchType": "FARGATE", 
            "loadBalancers": [], 
            "roleArn": "arn:aws:iam::aws_account_id:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS", 
            "placementConstraints": [], 
            "createdAt": 1510811361.128, 
            "desiredCount": 2, 
            "networkConfiguration": {
                "awsvpcConfiguration": {
                    "subnets": [
                        "subnet-abcd1234"
                    ], 
                    "securityGroups": [
                        "sg-abcd1234"
                    ], 
                    "assignPublicIp": "DISABLED"
                }
            }, 
            "platformVersion": "LATEST", 
            "serviceName": "fargate-service", 
            "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster", 
            "serviceArn": "arn:aws:ecs:region:aws_account_id:service/fargate-service", 
            "deploymentConfiguration": {
                "maximumPercent": 200, 
                "minimumHealthyPercent": 100
            }, 
            "deployments": [
                {
                    "status": "PRIMARY", 
                    "networkConfiguration": {
                        "awsvpcConfiguration": {
                            "subnets": [
                                "subnet-abcd1234"
                            ], 
                            "securityGroups": [
                                "sg-abcd1234"
                            ], 
                            "assignPublicIp": "DISABLED"
                        }
                    }, 
                    "pendingCount": 2, 
                    "launchType": "FARGATE", 
                    "createdAt": 1510811361.128, 
                    "desiredCount": 2, 
                    "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1", 
                    "updatedAt": 1510811361.128, 
                    "platformVersion": "0.0.1", 
                    "id": "ecs-svc/9223370526043414679", 
                    "runningCount": 0
                }
            ], 
            "events": [
                {
                    "message": "(service fargate-service) has started 2 tasks: (task 53c0de40-ea3b-489f-a352-623bf1235f08) (task d0aec985-901b-488f-9fb4-61b991b332a3).", 
                    "id": "92b8443e-67fb-4886-880c-07e73383ea83", 
                    "createdAt": 1510811841.408
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task b4911bee-7203-4113-99d4-e89ba457c626) (task cc5853e3-6e2d-4678-8312-74f8a7d76474).", 
                    "id": "d85c6ec6-a693-43b3-904a-a997e1fc844d", 
                    "createdAt": 1510811601.938
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task cba86182-52bf-42d7-9df8-b744699e6cfc) (task f4c1ad74-a5c6-4620-90cf-2aff118df5fc).", 
                    "id": "095703e1-0ca3-4379-a7c8-c0f1b8b95ace", 
                    "createdAt": 1510811364.691
                }
            ], 
            "runningCount": 0, 
            "placementStrategy": []
        }
    ], 
    "failures": []
}
```

## Paso 7: Eliminación
<a name="ECS_AWSCLI_Fargate_windows_clean_up"></a>

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

Elimine el servicio.

```
aws ecs delete-service --cluster fargate-cluster --service fargate-service --force
```

Elimine el clúster.

```
aws ecs delete-cluster --cluster fargate-cluster
```

# Creación de una tarea de Amazon ECS para EC2 con AWS CLI
<a name="ECS_AWSCLI_EC2"></a>

Los siguientes pasos le ayudan a configurar un clúster, registrar una definición de tarea, ejecutar una tarea y llevar a cabo otros escenarios comunes en Amazon ECS con la AWS CLI. Utilice la versión más reciente de la AWS CLI. Para obtener más información acerca de cómo actualizar a la versión más reciente, consulte [Instalación o actualización de la versión más reciente de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

**nota**  
Puede utilizar puntos de conexión de servicio de doble pila para interactuar con Amazon ECS desde la AWS CLI, los SDK y la API de Amazon ECS a través de IPv4 e IPv6. Para obtener más información, consulte [Uso de puntos de conexión de doble pila en Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [Requisitos previos](#AWSCLI_EC2_prereq)
+ [Creación de un clúster](#AWSCLI_EC2_create_cluster)
+ [Lanzamiento de una instancia de contenedor de AMI para Amazon ECS](#AWSCLI_EC2_launch_container_instance)
+ [Enumeración de instancias de contenedor](#AWSCLI_EC2_list_container_instances)
+ [Descripción de la instancia de contenedor](#AWSCLI_EC2_describe_container_instance)
+ [Registro de una definición de tareas](#AWSCLI_EC2_register_task_definition)
+ [Enumeración de definiciones de tareas](#AWSCLI_EC2_list_task_definitions)
+ [Crear un servicio](#AWSCLI_EC2_run_task)
+ [Enumeración de servicios](#AWSCLI_EC2_list_tasks)
+ [Descripción de los servicios](#AWSCLI_EC2_describe_service)
+ [Descripción de la tarea en ejecución](#AWSCLI_EC2_describe_task)
+ [Prueba del servidor web](#AWSCLI_EC2_test_web_server)
+ [Eliminar recursos](#AWSCLI_EC2_clean_up_resources)

## Requisitos previos
<a name="AWSCLI_EC2_prereq"></a>

En este tutorial se supone que los siguientes requisitos previos se han completado:
+ La última versión de la AWS CLI está instalada y configurada. Para obtener más información acerca de cómo instalar la AWS CLI o actualizarla, consulte [Instalación o actualización de la versión más reciente de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Se han completado los pasos que se indican en [Configuración para utilizar Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Su usuario de IAM dispone de los permisos requeridos que se especifican en la política de IAM [AmazonECS\$1FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) de ejemplo.
+ Se ha creado un rol de IAM de instancia de contenedor para usarlo. Para obtener más información, consulte [Rol de IAM de instancia de contenedor de Amazon ECS](instance_IAM_role.md).
+ Se ha creado una VPC para usarla. Para obtener más información, consulte [Creación de una nube virtual privada](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ (Opcional) AWS CloudShell es una herramienta que proporciona a los clientes una línea de comandos sin necesidad de crear su propia instancia de EC2. Para obtener más información, consulte [¿Qué es AWS CloudShell?](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) en la *Guía del usuario de AWS CloudShell*.

## Creación de un clúster
<a name="AWSCLI_EC2_create_cluster"></a>

De forma predeterminada, su cuenta recibe un clúster `default` donde lanzar su primera instancia de contenedor.

**nota**  
El beneficio de utilizar el clúster `default` que se le facilita es que no tiene que especificar la opción `--cluster cluster_name` en los comandos siguientes. Si crea su propio clúster no predeterminado, tiene que especificar `--cluster cluster_name` para cada comando que pretenda utilizar con dicho clúster.

Cree su propio clúster con un nombre único con el comando siguiente:

```
aws ecs create-cluster --cluster-name MyCluster
```

Salida:

```
{
    "cluster": {
        "clusterName": "MyCluster",
        "status": "ACTIVE",
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/MyCluster"
    }
}
```

## Lanzamiento de una instancia de contenedor de AMI para Amazon ECS
<a name="AWSCLI_EC2_launch_container_instance"></a>

Las instancias de contenedor son instancias de EC2 que ejecutan el agente de contenedor de Amazon ECS y que se han registrado en un clúster. En esta sección, lanzará una instancia EC2 con la AMI optimizada para ECS.

**Lanzamiento de una instancia de contenedor con la AWS CLI**

1. Recupere el último ID de AMI de Amazon Linux 2 optimizado para ECS para su Región de AWS mediante el siguiente comando. Este comando utiliza el almacén de parámetros AWS Systems Manager para obtener el último ID de AMI optimizado para ECS. La AMI incluye el agente de contenedor de Amazon ECS y el tiempo de ejecución de Docker preinstalados.

   ```
   aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/recommended --query 'Parameters[0].Value' --output text | jq -r '.image_id'
   ```

   Salida:

   ```
   ami-abcd1234
   ```

1. Cree un grupo de seguridad que permita el acceso SSH para administrar la instancia de contenedor y el acceso HTTP para el servidor web.

   ```
   aws ec2 create-security-group --group-name ecs-tutorial-sg --description "ECS tutorial security group"
   ```

   Salida:

   ```
   {
       "GroupId": "sg-abcd1234"
   }
   ```

1. Agregue una regla de entrada al grupo de seguridad mediante la ejecución del siguiente comando.

   ```
   aws ec2 authorize-security-group-ingress --group-id sg-abcd1234 --protocol tcp --port 80 --cidr 0.0.0.0/0
   ```

   Salida:

   ```
   {
       "Return": true,
       "SecurityGroupRules": [
           {
               "SecurityGroupRuleId": "sgr-efgh5678",
               "GroupId": "sg-abcd1234",
               "GroupOwnerId": "123456789012",
               "IsEgress": false,
               "IpProtocol": "tcp",
               "FromPort": 80,
               "ToPort": 80,
               "CidrIpv4": "0.0.0.0/0"
           }
       ]
   }
   ```

   El grupo de seguridad ahora permite el acceso SSH desde el rango de IP especificado y el acceso HTTP desde cualquier lugar. En un entorno de producción, debe restringir el acceso SSH a su dirección IP específica y plantearse la limitación del acceso HTTP según sea necesario.

1. Cree un par de claves EC2 para el acceso SSH a su instancia de contenedor.

   ```
   aws ec2 create-key-pair --key-name ecs-tutorial-key --query 'KeyMaterial' --output text > ecs-tutorial-key.pem
   chmod 400 ecs-tutorial-key.pem
   ```

   La clave privada se guarda en la máquina local con los permisos adecuados para el acceso SSH.

1. Lance una instancia EC2 mediante la AMI optimizada para ECS y configúrela para que se una a su clúster.

   ```
   aws ec2 run-instances --image-id ami-abcd1234 --instance-type t3.micro --key-name ecs-tutorial-key --security-group-ids sg-abcd1234 --iam-instance-profile Name=ecsInstanceRole --user-data '#!/bin/bash
   echo ECS_CLUSTER=MyCluster >> /etc/ecs/ecs.config'
   {
       "Instances": [
           {
               "InstanceId": "i-abcd1234",
               "ImageId": "ami-abcd1234",
               "State": {
                   "Code": 0,
                   "Name": "pending"
               },
               "PrivateDnsName": "",
               "PublicDnsName": "",
               "StateReason": {
                   "Code": "pending",
                   "Message": "pending"
               },
               "InstanceType": "t3.micro",
               "KeyName": "ecs-tutorial-key",
               "LaunchTime": "2025-01-13T10:30:00.000Z"
           }
       ]
   }
   ```

   El script de datos de usuario configura el agente de Amazon ECS para que registre la instancia en su `MyCluster`. La instancia usa el rol de IAM `ecsInstanceRole`, que proporciona los permisos necesarios para el agente.

## Enumeración de instancias de contenedor
<a name="AWSCLI_EC2_list_container_instances"></a>

A los pocos minutos de lanzar la instancia de contenedor, el agente de Amazon ECS registra la instancia con su clúster de MyCluster. Puede mostrar la lista de las instancias de contenedor de un clúster ejecutando el comando siguiente:

```
aws ecs list-container-instances --cluster MyCluster
```

Salida:

```
{
    "containerInstanceArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:container-instance/container_instance_ID"
    ]
}
```

## Descripción de la instancia de contenedor
<a name="AWSCLI_EC2_describe_container_instance"></a>

Una vez que tenga el ARN o el ID de una instancia de contenedor, puede utilizar el comando **describe-container-instances** para obtener información valiosa sobre la instancia, como por ejemplo, los recursos registrados y restantes de CPU y de memoria.

```
aws ecs describe-container-instances --cluster MyCluster --container-instances container_instance_ID
```

Salida:

```
{
    "failures": [],
    "containerInstances": [
        {
            "status": "ACTIVE",
            "registeredResources": [
                {
                    "integerValue": 1024,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "CPU",
                    "doubleValue": 0.0
                },
                {
                    "integerValue": 995,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "MEMORY",
                    "doubleValue": 0.0
                },
                {
                    "name": "PORTS",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [
                        "22",
                        "2376",
                        "2375",
                        "51678"
                    ],
                    "type": "STRINGSET",
                    "integerValue": 0
                },
                {
                    "name": "PORTS_UDP",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [],
                    "type": "STRINGSET",
                    "integerValue": 0
                }
            ],
            "ec2InstanceId": "instance_id",
            "agentConnected": true,
            "containerInstanceArn": "arn:aws:ecs:us-west-2:aws_account_id:container-instance/container_instance_ID",
            "pendingTasksCount": 0,
            "remainingResources": [
                {
                    "integerValue": 1024,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "CPU",
                    "doubleValue": 0.0
                },
                {
                    "integerValue": 995,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "MEMORY",
                    "doubleValue": 0.0
                },
                {
                    "name": "PORTS",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [
                        "22",
                        "2376",
                        "2375",
                        "51678"
                    ],
                    "type": "STRINGSET",
                    "integerValue": 0
                },
                {
                    "name": "PORTS_UDP",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [],
                    "type": "STRINGSET",
                    "integerValue": 0
                }
            ],
            "runningTasksCount": 0,
            "attributes": [
                {
                    "name": "com.amazonaws.ecs.capability.privileged-container"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.17"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.18"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.19"
                },
                {
                    "name": "com.amazonaws.ecs.capability.logging-driver.json-file"
                },
                {
                    "name": "com.amazonaws.ecs.capability.logging-driver.syslog"
                }
            ],
            "versionInfo": {
                "agentVersion": "1.5.0",
                "agentHash": "b197edd",
                "dockerVersion": "DockerVersion: 1.7.1"
            }
        }
    ]
}
```

También puede buscar el ID de instancia de Amazon EC2 que puede utilizar para monitorizar la instancia en la consola de Amazon EC2 o con el comando **aws ec2 describe-instances --instance-id *instance\$1id***.

## Registro de una definición de tareas
<a name="AWSCLI_EC2_register_task_definition"></a>

Antes de poder ejecutar una tarea en su clúster de Amazon ECS, debe registrar una definición de tareas. Las definiciones de tareas son listas de contenedores agrupadas. El ejemplo siguiente es una definición de tareas sencilla que utiliza una imagen `nginx`. Para obtener más información acerca de los parámetros de definición de tareas disponibles, consulte [Definiciones de tareas de Amazon ECS](task_definitions.md).

```
{
    "family": "nginx-task",
    "containerDefinitions": [
        {
            "name": "nginx",
            "image": "public.ecr.aws/ecs-sample-image/amazon-ecs-sample:latest",
            "cpu": 256,
            "memory": 512,
            "essential": true,
            "portMappings": [
                {
                    "containerPort": 80,
                    "hostPort": 80,
                    "protocol": "tcp"
                }
            ]
        }
    ],
    "requiresCompatibilities": ["EC2"],
    "networkMode": "bridge"
}
```

El ejemplo anterior de JSON se puede transferir a la AWS CLI de dos formas: puede guardar la definición de tareas JSON como un archivo y transferirlo con la opción `--cli-input-json file://path_to_file.json`. O bien, puede eludir las comillas en JSON y transferir las definiciones de contenedor JSON en la línea de comandos. Si elige transferir las definiciones de contenedor en la línea de comandos, el comando requiere adicionalmente un parámetro `--family` que se utiliza para mantener varias versiones de la definición de tareas asociadas entre sí.

Para utilizar un archivo JSON para definiciones de contenedor:

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/nginx.json
```

**register-task-definition** devuelve una descripción de la definición de tarea después de completar su registro.

```
{
    "taskDefinition": {
        "taskDefinitionArn": "arn:aws:ecs:us-east-1:123456789012:task-definition/nginx-task:1",
        "family": "nginx-task",
        "revision": 1,
        "status": "ACTIVE",
        "containerDefinitions": [
            {
                "name": "nginx",
                "image": "public.ecr.aws/docker/library/nginx:latest",
                "cpu": 256,
                "memory": 512,
                "essential": true,
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "environment": [],
                "mountPoints": [],
                "volumesFrom": []
            }
        ],
        "volumes": [],
        "networkMode": "bridge",
        "compatibilities": [
            "EC2"
        ],
        "requiresCompatibilities": [
            "EC2"
        ]
    }
}
```

## Enumeración de definiciones de tareas
<a name="AWSCLI_EC2_list_task_definitions"></a>

Puede enumerar las definiciones de tareas para su cuenta en cualquier momento con el comando **list-task-definitions**. La salida de este comando muestra los valores `family` y `revision`, que se pueden utilizar conjuntamente al llamar a **create-service**.

```
aws ecs list-task-definitions
```

Salida:

```
{
    "taskDefinitionArns": [
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/sleep360:1",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/sleep360:2",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/nginx-task:1",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:3",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:4",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:5",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:6"
    ]
}
```

## Crear un servicio
<a name="AWSCLI_EC2_run_task"></a>

Después de haber registrado una tarea para la cuenta y haber lanzado una instancia de contenedor que esté registrada en su clúster, puede crear un servicio de Amazon ECS que ejecute y mantenga el número deseado de tareas simultáneamente mediante la definición de tarea que se haya registrado. Para este ejemplo, coloque una instancia única de la definición de tarea `nginx:1` en su clúster de MyCluster.

```
aws ecs create-service --cluster MyCluster --service-name nginx-service --task-definition nginx-task:1 --desired-count 1
```

Salida:

```
{
    "service": {
        "serviceArn": "arn:aws:ecs:us-east-1:aws_account_id:service/MyCluster/nginx-service",
        "serviceName": "nginx-service",
        "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
        "taskDefinition": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
        "desiredCount": 1,
        "runningCount": 0,
        "pendingCount": 0,
        "launchType": "EC2",
        "status": "ACTIVE",
        "createdAt": "2025-01-13T10:45:00.000Z"
    }
}
```

## Enumeración de servicios
<a name="AWSCLI_EC2_list_tasks"></a>

Enumere los servicios de su clúster. Debe aparecer el servicio que ha creado en la sección anterior. Puede tomar nota del ID de servicio o el ARN completo que se devuelve desde este comando y utilizarlo para describir el servicio más adelante.

```
aws ecs list-services --cluster MyCluster
```

Salida:

```
{
    "taskArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:task/task_ID"
    ]
}
```

## Descripción de los servicios
<a name="AWSCLI_EC2_describe_service"></a>

Describa el servicio con el siguiente comando para obtener más información sobre el servicio.

```
aws ecs describe-services --cluster MyCluster --services nginx-service
```

Salida:

```
{
    "services": [
        {
            "serviceArn": "arn:aws:ecs:us-east-1:aws_account_id:service/MyCluster/nginx-service",
            "serviceName": "nginx-service",
            "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
            "taskDefinition": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
            "desiredCount": 1,
            "runningCount": 1,
            "pendingCount": 0,
            "launchType": "EC2",
            "status": "ACTIVE",
            "createdAt": "2025-01-13T10:45:00.000Z",
            "events": [
                {
                    "id": "abcd1234-5678-90ab-cdef-1234567890ab",
                    "createdAt": "2025-01-13T10:45:30.000Z",
                    "message": "(service nginx-service) has started 1 tasks: (task abcd1234-5678-90ab-cdef-1234567890ab)."
                }
            ]
        }
    ]
}
```

## Descripción de la tarea en ejecución
<a name="AWSCLI_EC2_describe_task"></a>

Después de describir el servicio, ejecute el siguiente comando para obtener más información sobre la tarea que se está ejecutando como parte de su servicio.

```
aws ecs list-tasks --cluster MyCluster --service-name nginx-service
```

 Salida: 

```
{
    "tasks": [
        {
            "taskArn": "arn:aws:ecs:us-east-1:aws_account_id:task/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
            "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
            "taskDefinitionArn": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
            "containerInstanceArn": "arn:aws:ecs:us-east-1:aws_account_id:container-instance/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
            "lastStatus": "RUNNING",
            "desiredStatus": "RUNNING",
            "containers": [
                {
                    "containerArn": "arn:aws:ecs:us-east-1:aws_account_id:container/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab/abcd1234-5678-90ab-cdef-1234567890ab",
                    "taskArn": "arn:aws:ecs:us-east-1:aws_account_id:task/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
                    "name": "nginx",
                    "lastStatus": "RUNNING",
                    "networkBindings": [
                        {
                            "bindIP": "0.0.0.0",
                            "containerPort": 80,
                            "hostPort": 80,
                            "protocol": "tcp"
                        }
                    ]
                }
            ],
            "createdAt": "2025-01-13T10:45:00.000Z",
            "startedAt": "2025-01-13T10:45:30.000Z"
        }
    ]
}
```

## Prueba del servidor web
<a name="AWSCLI_EC2_test_web_server"></a>

**Prueba del servidor web**

1. Obtenga la dirección IP pública de su instancia de contenedor con la ejecución del siguiente comando.

   ```
   aws ec2 describe-instances --instance-ids i-abcd1234 --query 'Reservations[0].Instances[0].PublicIpAddress' --output text
   ```

   Salida:

   ```
   203.0.113.25
   ```

1. Después de recuperar la dirección IP, ejecute el siguiente comando `curl` con la dirección IP.

   ```
   curl http://203.0.113.25
   ```

   Salida:

   ```
   <!DOCTYPE html>
   <html>
   <head>
   <title>Welcome to nginx!</title>
   ...
   </head>
   <body>
   <h1>Welcome to nginx!</h1>
   <p>If you can see this page, the nginx web server is successfully installed and working.</p>
   ...
   </body>
   </html>
   ```

   La página de bienvenida de nginx confirma que el servicio se está ejecutando correctamente y que es accesible desde Internet.

## Eliminar recursos
<a name="AWSCLI_EC2_clean_up_resources"></a>

Para dejar de incurrir en cargos, debe limpiar los recursos que se crearon en este tutorial.

**Cómo limpiar los recursos**

1. Actualice el servicio para que no tener tarea deseadas y, a continuación, elimínelo.

   ```
   aws ecs update-service --cluster MyCluster --service nginx-service --desired-count 0
   {
       "service": {
           "serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/nginx-service",
           "serviceName": "nginx-service",
           "desiredCount": 0,
           "runningCount": 1,
           "pendingCount": 0,
           "status": "ACTIVE"
       }
   }
   ```

1. Espere a que se detengan las tareas en ejecución y, a continuación, elimine el servicio.

   ```
   aws ecs delete-service --cluster MyCluster --service nginx-service
   {
       "service": {
           "serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/nginx-service",
           "serviceName": "nginx-service",
           "status": "DRAINING"
       }
   }
   ```

1. Finalice la instancia de contenedor que creó.

   ```
   aws ec2 terminate-instances --instance-ids i-abcd1234
   {
       "TerminatingInstances": [
           {
               "InstanceId": "i-abcd1234",
               "CurrentState": {
                   "Code": 32,
                   "Name": "shutting-down"
               },
               "PreviousState": {
                   "Code": 16,
                   "Name": "running"
               }
           }
       ]
   }
   ```

1. Limpie el grupo de seguridad y el par de claves que creó.

   ```
   aws ec2 delete-security-group --group-id sg-abcd1234
   aws ec2 delete-key-pair --key-name ecs-tutorial-key
   rm ecs-tutorial-key.pem
   ```

1. Elimine el clúster de Amazon ECS.

   ```
   aws ecs delete-cluster --cluster MyCluster
   {
       "cluster": {
           "clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/MyCluster",
           "clusterName": "MyCluster",
           "status": "INACTIVE"
       }
   }
   ```

# Configuración de Amazon ECS para escuchar los eventos de Eventos de CloudWatch
<a name="ecs_cwet"></a>

Obtenga información sobre cómo configurar una función de Lambda simple que escuche eventos de tareas y los escriba en un flujo de registro de Registros de CloudWatch.

## Requisito previo: configurar un clúster de prueba
<a name="cwet_step_1"></a>

Si no dispone de un clúster en ejecución del que capturar eventos, siga los pasos en [Creación de un clúster de Amazon ECS para cargas de trabajo de Fargate](create-cluster-console-v2.md) para crear uno. Al final de este tutorial, se ejecuta una tarea en este clúster para comprobar que la función de Lambda se ha configurado correctamente. 

## Paso 1: Crear la función de Lambda
<a name="cwet_step_2"></a>

En este procedimiento, se crea una función de Lambda sencilla que servirá como destino para los mensajes de la secuencia de eventos de Amazon ECS. 

1. Abra la consola de AWS Lambda en [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Elija **Crear función**. 

1. En la pantalla **Author from scratch**, haga lo siguiente:

   1. Para **Name (Nombre)**, escriba un valor. 

   1. En **Runtime** (Tiempo de ejecución), elija su versión de Python, por ejemplo, **Python 3.9**.

   1. Para **Role (Rol)**, elija **Create a new role with basic Lambda permissions (Crear un nuevo rol con permisos básicos de Lambda)**

1. Seleccione **Crear función**.

1. En la sección **Código de función**, edite el código de muestra de tal modo que coincida con el siguiente ejemplo:

   ```
   import json
   
   def lambda_handler(event, context):
       if event["source"] != "aws.ecs":
          raise ValueError("Function only supports input from events with a source type of: aws.ecs")
          
       print('Here is the event:')
       print(json.dumps(event))
   ```

   Se trata de una función Python 3.9 sencilla que imprime el evento que envía Amazon ECS. Si se configura todo correctamente, al final de este tutorial verá los detalles de los eventos que aparecerán en la secuencia de registros de CloudWatch Logs asociada a esta función de Lambda.

1. Seleccione **Save**.

## Paso 2: Registrar una regla de eventos
<a name="cwet_step_3"></a>

 A continuación, se crea una regla de eventos de CloudWatch Events que captura eventos de tareas procedentes de los clústeres de Amazon ECS. Esta regla captura todos los eventos procedentes de todos los clústeres dentro de la cuenta donde está definido. Los propios mensajes de tareas contienen información acerca del origen de evento, incluido el clúster en el que reside, que puede usar para filtrar y ordenar eventos mediante programación. 

**nota**  
Cuando se utiliza la Consola de administración de AWS para crear una regla de eventos, la consola agrega automáticamente los permisos de IAM necesarios para conceder permiso a CloudWatch Events para ejecutar la función de Lambda. Si crea una regla de eventos utilizando la AWS CLI, tiene que otorgar este permiso explícitamente. Para obtener más información, consulte [Eventos en Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html) y [Patrones de eventos de Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns.html) en la *Guía del usuario de Amazon EventBridge*.

**Para dirigir eventos a la función Lambda**

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

1. En el panel de navegación, elija **Events (Eventos)**, **Rules (Reglas)**, **Create rule (Crear regla)**.

1. En **Event Source**, seleccione **ECS** como el origen de los eventos. De forma predeterminada, la regla se aplica a todos los eventos de Amazon ECS de todos los grupos de Amazon ECS. Como alternativa, puede seleccionar eventos específicos o un grupo de Amazon ECS específico.

1. En **Destinos**, elija **Agregar destino**. En **Tipo de destino**, elija **Función de Lambda** y, a continuación, seleccione la función de Lambda.

1. Seleccione **Configurar los detalles**.

1. Para **Rule definition**, escriba un nombre y la descripción para su regla y seleccione **Create rule**.

## Paso 3: Cree una definición de tarea
<a name="cwet_step_task-def"></a>

Cree una definición de tarea.

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**.

1. Elija **Create new Task Definition** (Crear nueva definición de tarea) y **Create new revision with JSON** (Crear nueva revisión con JSON).

1. Copie y pegue la siguiente definición de tarea de ejemplo en el cuadro y, a continuación, elija **Save (Guardar)**.

   ```
   {
      "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"
               }
            ]
         }
      ],
      "cpu": "256",
      "executionRoleArn": "arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
      "family": "fargate-task-definition",
      "memory": "512",
      "networkMode": "awsvpc",
      "runtimePlatform": {
           "operatingSystemFamily": "LINUX"
       },
      "requiresCompatibilities": [ 
          "FARGATE" 
       ]
   }
   ```

1. Seleccione **Crear**.

## Paso 4: Probar la regla
<a name="cwet_step_4"></a>

 Por último, se crea una regla de eventos de CloudWatch Events que captura los eventos de tareas procedentes de los clústeres de Amazon ECS. Esta regla captura todos los eventos procedentes de todos los clústeres dentro de la cuenta donde está definido. Los propios mensajes de tareas contienen información acerca del origen de evento, incluido el clúster en el que reside, que puede usar para filtrar y ordenar eventos mediante programación. 

**Para probar la regla**

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

1. Elija **Task definitions** (Definiciones de tareas).

1. Elija **console-sample-app-static** y, a continuación, elija **Deploy**(Implementar), **Run new task** (Ejecutar nueva tarea).

1. En **Cluster** (Clúster), elija default (predeterminado) y, a continuación, elija **Deploy** (Implementar).

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

1. En el panel de navegación, elija **Logs** (Registros) y seleccione el grupo de registros para la función de Lambda (por ejemplo, **/aws/lambda/***my-function*).

1. Seleccione una secuencia de registro para ver los datos de los eventos. 

# Envío de alertas de Amazon Simple Notification Service para eventos de tareas detenidas de Amazon ECS
<a name="ecs_cwet2"></a>

Configure una regla de eventos de Amazon EventBridge que solo capture eventos de tareas en los que la tarea dejó de ejecutarse porque uno de sus contenedores esenciales finalizó. El evento solo envía eventos de tareas con una propiedad `stoppedReason` específica al tema de Amazon SNS designado.

## Requisito previo: configurar un clúster de prueba
<a name="cwet2_step_1"></a>

 Si no dispone de un clúster en ejecución de donde capturar eventos, siga los pasos que se describen en [Introducción a la consola mediante contenedores de Linux en AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/getting-started-fargate.html#get-started-fargate-cluster) para crear uno. Al final de este tutorial, ejecutará una tarea en este clúster para comprobar que el tema de Amazon SNS y la regla de EventBridge se han configurado correctamente. 

## Requisito previo: configurar los permisos para Amazon SNS
<a name="cwet2_step_1a"></a>

Para permitir que EventBridge publique en un tema de Amazon SNS, utilice los comandos aws sns get-topic-attributes y aws sns set-topic-attributes. 

Para obtener más información sobre cómo agregar el permiso, consulte [Permisos de Amazon SNS](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html#eb-sns-permissions) en la *Guía para desarrolladores de Amazon Simple Notification Service*.

Agregue los siguientes permisos:

```
{
  "Sid": "PublishEventsToMyTopic",
  "Effect": "Allow",
  "Principal": {
     "Service": "events.amazonaws.com"
  },
  "Action": "sns: Publish",
  "Resource": "arn:aws:sns:region:account-id:TaskStoppedAlert",
}
```

## Paso 1: Crear y suscribirse a un tema de Amazon SNS
<a name="cwet2_step_2"></a>

 Para este tutorial, se configura un tema de Amazon SNS para utilizarse como destino de eventos para la nueva regla de eventos. 

Para obtener información acerca de cómo crear un tema de Amazon SNS y suscribirse a él, consulte [Introducción a Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-getting-started.html#step-create-queue) en la *Guía para desarrolladores de Amazon Simple Notification Service* y utilice la siguiente tabla para determinar qué opciones seleccionar.


| Opción | Valor | 
| --- | --- | 
|  Tipo  | Standard | 
| Nombre |  TaskStoppedAlert  | 
| Protocolo | Correo electrónico | 
| Punto de conexión |  Una dirección de correo electrónico a la que actualmente tiene acceso  | 

## Paso 2: Registrar una regla de eventos
<a name="cwet2_step_3"></a>

 A continuación, registre una regla de eventos que capture solo eventos de tarea parada de tareas con contenedores parados. 

Para obtener información sobre cómo crear y suscribirse a un tema de Amazon SNS, consulte [Create a rule in Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-get-started.html) (Crear una regla en Amazon EventBridge) en la *Guía del usuario de Amazon EventBridge* y utilice la siguiente tabla para determinar qué opciones seleccionar.


| Opción | Valor | 
| --- | --- | 
|  Tipo de regla  |  Regla con un patrón de evento  | 
| Origen del evento | AWSEventos de o eventos de socios de EventBridge | 
| Patrón del evento |  Patrón personalizado (editor JSON)  | 
| Patrón del evento |  <pre>{<br />   "source":[<br />      "aws.ecs"<br />   ],<br />   "detail-type":[<br />      "ECS Task State Change"<br />   ],<br />   "detail":{<br />      "lastStatus":[<br />         "STOPPED"<br />      ],<br />      "stoppedReason":[<br />         "Essential container in task exited"<br />      ]<br />   }<br />}</pre> | 
| Tipo de destino |  Servicio de AWS  | 
| Target | Tema de SNS | 
| Topic |  TaskStopPedAlert (El tema que ha creado en el paso 1)  | 

## Paso 3: Pruebe la regla
<a name="cwet2_step_4"></a>

Compruebe que la regla funciona mediante la ejecución de una tarea que se cierra poco después de iniciarse. Si la regla de eventos está configurada correctamente, recibirá un mensaje de correo electrónico en unos minutos con el texto del evento. Si tiene una definición de tarea existente que puede satisfacer los requisitos de la regla, ejecute una tarea con ella. Si no lo hace, los siguientes pasos le guiarán a través del registro de una definición de tarea de Fargate y su ejecución.

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, edite el archivo JSON y copie lo siguiente en el editor.

   ```
   {
      "containerDefinitions":[
         {
            "command":[
               "sh",
               "-c",
               "sleep 5"
            ],
            "essential":true,
            "image":"public.ecr.aws/amazonlinux/amazonlinux:latest",
            "name":"test-sleep"
         }
      ],
      "cpu":"256",
      "executionRoleArn":"arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
      "family":"fargate-task-definition",
      "memory":"512",
      "networkMode":"awsvpc",
      "requiresCompatibilities":[
         "FARGATE"
      ]
   }
   ```

1. Seleccione **Crear**.

**Para ejecutar una tarea a través de la consola**

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

1. En la página **Clústeres**, seleccione el clúster que creó en los requisitos previos.

1. En la pestaña **Tasks** (Tareas), elija **Run new task** (Ejecutar nueva tarea).

1. En **Application type** (Tipo de aplicación), elija **Task** (Tarea).

1. En **Definición de tareas**, elija **fargate-task-definition**.

1. En **Desired tasks** (Tareas deseadas), ingrese el número de tareas que se lanzarán.

1. Seleccione **Crear**.

# Concatenación de mensajes de registro de Amazon ECS de seguimiento de pila o de varias líneas
<a name="firelens-concatanate-multiline"></a>

Empezando por AWS para Fluent Bit versión 2.22.0, se incluye un filtro multilínea. El filtro multilínea ayuda a concatenar mensajes de registro que originalmente pertenecen a un contexto, pero que se dividieron en varios registros o líneas de registro. Para obtener más información acerca del filtro multilínea, consulte la [documentación de Fluent Bit.](https://docs.fluentbit.io/manual/pipeline/filters/multiline-stacktrace) 

Los siguientes son algunos ejemplos comunes de mensajes de registro divididos:
+ Seguimiento de pila. 
+ Aplicaciones que imprimen registros en varias líneas. 
+ Mensajes de registro que se dividieron porque eran más largos que el tamaño máximo de búfer en tiempo de ejecución especificado. Puede concatenar mensajes de registro divididos por el tiempo de ejecución del contenedor siguiendo el ejemplo de GitHub: [Ejemplo de FireLens: Concatenar registros de contenedores parciales/divididos](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/filter-multiline-partial-message-mode).

## Permisos de IAM necesarios
<a name="iam-permissions"></a>

Dispone de los permisos de IAM necesarios para que el agente de contenedor extraiga las imágenes de contenedor de Amazon ECR y para que el contenedor dirija los registros a Registros de CloudWatch.

Para estos permisos, debe tener los siguientes roles: 
+ Un rol de IAM de tareas. 
+ Un rol de IAM de ejecución de tareas. 

También necesita los siguientes permisos:
+ `logs:CreateLogStream`
+ `logs:CreateLogGroup`
+ `logs:PutLogEvents`

## Determine cuándo utilizar la configuración de registro multilínea
<a name="determine-filter"></a>

En los siguientes ejemplos, se muestran fragmentos de registro de ejemplo que se ven en la consola de Registros de CloudWatch con la configuración de registro predeterminada. Puede fijarse en la línea que empieza por `log` para determinar si necesita el filtro multilínea. Cuando el contexto es el mismo, puede utilizar la configuración de registro de varias líneas. En este ejemplo, el contexto es “com.myproject.model.MyProject”.

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "source=": "stdout", "log": ": "     at com.myproject.modele.(MyProject.badMethod.java:22)",
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log": ": "     at com.myproject.model.MyProject.badMethod(MyProject.java:22)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE",
      "ecs_task_definition": "firelense-example-multiline:3"
     }
```

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "stdout", "log": ": "     at com.myproject.modele.(MyProject.oneMoreMethod.java:18)",
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log": ": "     at com.myproject.model.MyProject.oneMoreMethod(MyProject.java:18)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE,
      "ecs_task_definition": "firelense-example-multiline:3"
     }
```

Después de utilizar la configuración del registro multilínea, la salida tendrá un aspecto similar al del ejemplo siguiente. 

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "stdout",...
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log:    "September 20, 2022 06:41:48 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!\n    
    at com.myproject.module.MyProject.badMethod(MyProject.java:22)\n    at   
    at com.myproject.model.MyProject.oneMoreMethod(MyProject.java:18) com.myproject.module.MyProject.main(MyProject.java:6)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE",
      "ecs_task_definition": "firelense-example-multiline:2"
     }
```

## Opciones de análisis y concatenación
<a name="parse-multiline-log"></a>

Para analizar registros y concatenar líneas que se dividieron debido a las líneas nuevas, puede utilizar cualquiera de estas dos opciones.
+ Utilice su propio archivo analizador que contenga las reglas para analizar y concatenar líneas que pertenecen al mismo mensaje.
+ Utilizar un analizador integrado de Fluent Bit. Para ver una lista de los idiomas admitidos en los analizadores integrados de Fluent Bit, consulte la [documentación de Fluent Bit.](https://docs.fluentbit.io/manual/pipeline/filters/multiline-stacktrace)

El siguiente tutorial lo guiará por los pasos de cada caso de uso. En los pasos, se muestra cómo concatenar varias líneas y enviar los registros a Amazon CloudWatch. Puede especificar otro destino para los registros.

### Ejemplo: utilizar un analizador que cree
<a name="customer-parser"></a>

En este ejemplo, completará los siguientes pasos: 

1. Cree y cargue la imagen en un contenedor de Fluent Bit. 

1. Cree y cargue la imagen de una aplicación multilínea de demostración que se ejecuta, falla y genera un seguimiento de pila multilínea.

1. Cree la definición de tarea y ejecute la tarea. 

1. Consulte los registros para verificar que los mensajes que abarcan varias líneas aparezcan concatenados. 

**Crear y cargar la imagen en un contenedor de Fluent Bit**

En esta imagen, se incluirá el archivo analizador en el que se especifica la expresión regular y un archivo de configuración que hace referencia al archivo analizador. 

1. Cree una carpeta con el nombre `FluentBitDockerImage`. 

1. Dentro de la carpeta, cree un archivo analizador que contenga las reglas para analizar el registro y concatenar líneas que pertenecen al mismo mensaje.

   1. Pegue los siguientes contenidos en el archivo analizador:

      ```
      [MULTILINE_PARSER]
          name          multiline-regex-test
          type          regex
          flush_timeout 1000
          #
          # Regex rules for multiline parsing
          # ---------------------------------
          #
          # configuration hints:
          #
          #  - first state always has the name: start_state
          #  - every field in the rule must be inside double quotes
          #
          # rules |   state name  | regex pattern                  | next state
          # ------|---------------|--------------------------------------------
          rule      "start_state"   "/(Dec \d+ \d+\:\d+\:\d+)(.*)/"  "cont"
          rule      "cont"          "/^\s+at.*/"                     "cont"
      ```

      A medida que personaliza el patrón de expresiones regulares, recomendamos utilizar un editor de expresiones regulares para probar la expresión.

   1. Guarde el archivo como `parsers_multiline.conf`. 

1. En la carpeta `FluentBitDockerImage`, cree un archivo de configuración personalizado que haga referencia al archivo analizador que creó en el paso anterior.

   Para obtener más información sobre el archivo de configuración personalizado, consulte [Especificación de un archivo de configuración personalizado](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-taskdef.html#firelens-taskdef-customconfig) en la *Guía para desarrolladores de Amazon Elastic Container Service* 

   1. Pegue los siguientes contenidos en el archivo:

      ```
      [SERVICE]
          flush                 1
          log_level             info
          parsers_file          /parsers_multiline.conf
          
      [FILTER]
          name                  multiline
          match                 *
          multiline.key_content log
          multiline.parser      multiline-regex-test
      ```
**nota**  
Debe utilizar la ruta absoluta del analizador. 

   1. Guarde el archivo como `extra.conf`. 

1. En la carpeta `FluentBitDockerImage`, cree el archivo de Dockerfile con la imagen de Fluent Bit, el analizador y los archivos de configuración que ha creado.

   1. Pegue los siguientes contenidos en el archivo:

      ```
      FROM public.ecr.aws/aws-observability/aws-for-fluent-bit:latest
      
      ADD parsers_multiline.conf /parsers_multiline.conf
      ADD extra.conf /extra.conf
      ```

   1. Guarde el archivo como `Dockerfile`.

1. Con el archivo de Dockerfile, cree una imagen de Fluent Bit personalizada con el analizador y los archivos de configuración personalizados incluidos.
**nota**  
Puede colocar el archivo analizador y el archivo de configuración en cualquier parte de la imagen de Docker, excepto en `/fluent-bit/etc/fluent-bit.conf`, ya que FireLens utiliza esta ruta de archivo.

   1. Cree la imagen: `docker build -t fluent-bit-multiline-image.`

      Donde: `fluent-bit-multiline-image` es el nombre de la imagen de este ejemplo.

   1. Compruebe que la imagen se haya creado correctamente: `docker images —filter reference=fluent-bit-multiline-image` 

      Si la acción se realiza correctamente, el resultado muestra la imagen y la etiqueta `latest`.

1. Cargue la imagen de Fluent Bit personalizada en Amazon Elastic Container Registry.

   1. Cree un repositorio de Amazon ECR para almacenar la imagen: `aws ecr create-repository --repository-name fluent-bit-multiline-repo --region us-east-1`

      Donde: `fluent-bit-multiline-repo` es el nombre del repositorio y `us-east-1` es la región de este ejemplo. 

      El resultado proporciona los detalles del nuevo repositorio. 

   1. Etiquete la imagen con el valor `repositoryUri` del resultado anterior: `docker tag fluent-bit-multiline-image repositoryUri` 

      Ejemplo:: `docker tag fluent-bit-multiline-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo` 

   1. Ejecute la imagen de Docker para verificar que se haya ejecutado correctamente: `docker images —filter reference=repositoryUri`

      En el resultado, el nombre del repositorio cambia de fluent-bit-multiline-repo a `repositoryUri`.

   1. Autentíquese en Amazon ECR ejecutando el comando `aws ecr get-login-password` y especifique el ID del registro en el que desea efectuar la autenticación: `aws ecr get-login-password | docker login --username AWS --password-stdin registry ID.dkr.ecr.region.amazonaws.com` 

      Ejemplo:: `ecr get-login-password | docker login --username AWS --password-stdin xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com`

      Aparece un mensaje de inicio de sesión correcto.

   1. Envíe la imagen a Amazon ECR: `docker push registry ID.dkr.ecr.region.amazonaws.com/repository name` 

      Ejemplo:: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo`

**Crear y cargar la imagen para una aplicación multilínea de demostración**

En esta imagen, se incluirá un archivo de script de Python que ejecuta la aplicación y un archivo de registro de ejemplo. 

Cuando ejecuta la tarea, la aplicación simula las ejecuciones y, a continuación, falla y crea un seguimiento de pila. 

1. Cree una carpeta denominada `multiline-app`: `mkdir multiline-app` 

1. Cree un archivo de script de Python.

   1. En la carpeta `multiline-app`, cree un archivo y asígnele el nombre `main.py`.

   1. Pegue los siguientes contenidos en el archivo:

      ```
      import os
      import time
      file1 = open('/test.log', 'r')
      Lines = file1.readlines()
       
      count = 0
      
      for i in range(10):
          print("app running normally...")
          time.sleep(1)
      
      # Strips the newline character
      for line in Lines:
          count += 1
          print(line.rstrip())
      print(count)
      print("app terminated.")
      ```

   1. Guarde el archivo `main.py`.

1. Cree un archivo de registro de ejemplo. 

   1. En la carpeta `multiline-app`, cree un archivo y asígnele el nombre `test.log`.

   1. Pegue los siguientes contenidos en el archivo:

      ```
      single line...
      Dec 14 06:41:08 Exception in thread "main" java.lang.RuntimeException: Something has gone wrong, aborting!
          at com.myproject.module.MyProject.badMethod(MyProject.java:22)
          at com.myproject.module.MyProject.oneMoreMethod(MyProject.java:18)
          at com.myproject.module.MyProject.anotherMethod(MyProject.java:14)
          at com.myproject.module.MyProject.someMethod(MyProject.java:10)
          at com.myproject.module.MyProject.main(MyProject.java:6)
      another line...
      ```

   1. Guarde el archivo `test.log`.

1. En la carpeta `multiline-app`, cree el archivo de Dockerfile.

   1. Pegue los siguientes contenidos en el archivo:

      ```
      FROM public.ecr.aws/amazonlinux/amazonlinux:latest
      ADD test.log /test.log
      
      RUN yum upgrade -y && yum install -y python3
      
      WORKDIR /usr/local/bin
      
      COPY main.py .
      
      CMD ["python3", "main.py"]
      ```

   1. Guarde el archivo `Dockerfile`.

1. Con el archivo de Dockerfile, cree una imagen.

   1. Cree la imagen: `docker build -t multiline-app-image `

      Donde: `multiline-app-image` es el nombre de la imagen de este ejemplo.

   1. Compruebe que la imagen se haya creado correctamente: `docker images —filter reference=multiline-app-image` 

      Si la acción se realiza correctamente, el resultado muestra la imagen y la etiqueta `latest`.

1. Cargue la imagen en Amazon Elastic Container Registry.

   1. Cree un repositorio de Amazon ECR para almacenar la imagen: `aws ecr create-repository --repository-name multiline-app-repo --region us-east-1`

      Donde: `multiline-app-repo` es el nombre del repositorio y `us-east-1` es la región de este ejemplo. 

      El resultado proporciona los detalles del nuevo repositorio. Tome nota del valor `repositoryUri`, ya que lo necesitará en los siguientes pasos. 

   1. Etiquete la imagen con el valor `repositoryUri` del resultado anterior: `docker tag multiline-app-image repositoryUri` 

      Ejemplo:: `docker tag multiline-app-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo` 

   1. Ejecute la imagen de Docker para verificar que se haya ejecutado correctamente: `docker images —filter reference=repositoryUri`

      En el resultado, el nombre del repositorio cambia de `multiline-app-repo` al valor `repositoryUri`.

   1. Envíe la imagen a Amazon ECR: `docker push aws_account_id.dkr.ecr.region.amazonaws.com/repository name` 

      Ejemplo:: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo`

**Crear la definición de tarea y ejecutar la tarea**

1. Cree un archivo de definición de tarea con el nombre de archivo `multiline-task-definition.json`. 

1. Pegue los siguientes contenidos en el archivo `multiline-task-definition.json`: 

   ```
   {
       "family": "firelens-example-multiline",
       "taskRoleArn": "task role ARN,
       "executionRoleArn": "execution role ARN",
       "containerDefinitions": [
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-image:latest",
               "name": "log_router",
               "firelensConfiguration": {
                   "type": "fluentbit",
                   "options": {
                       "config-file-type": "file",
                       "config-file-value": "/extra.conf"
                   }
               },
               "memoryReservation": 50
           },
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/multiline-app-image:latest",
               "name": "app",
               "logConfiguration": {
                   "logDriver": "awsfirelens",
                   "options": {
                       "Name": "cloudwatch_logs",
                       "region": "us-east-1",
                       "log_group_name": "multiline-test/application",
                       "auto_create_group": "true",
                       "log_stream_prefix": "multiline-"
                   }
               },
               "memoryReservation": 100
           }
       ],
       "requiresCompatibilities": ["FARGATE"],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512"
   }
   ```

   Sustituya lo siguiente en la definición de tarea `multiline-task-definition.json`:

   1. `task role ARN`

      Para encontrar el ARN del rol de tarea, vaya a la consola de IAM. Elija **Roles** y busque el rol de tarea `ecs-task-role-for-firelens` que ha creado. Elija el rol y copie el **ARN** que aparece en la sección **Summary** (Resumen).

   1. `execution role ARN`

      Para encontrar el ARN del rol de ejecución, vaya a la consola de IAM. Elija **Roles** y busque el rol `ecsTaskExecutionRole`. Elija el rol y copie el **ARN** que aparece en la sección **Summary** (Resumen).

   1. `aws_account_id`

      Para encontrar su `aws_account_id`, inicie sesión en la Consola de administración de AWS. Elija su nombre de usuario en la parte superior derecha y copie su ID de cuenta.

   1. `us-east-1`

      Sustituya la región si es necesario.

1. Registre el archivo de definición de tarea: `aws ecs register-task-definition --cli-input-json file://multiline-task-definition.json --region region` 

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 tarea) y, a continuación, seleccione la familia `firelens-example-multiline` porque hemos registrado la definición de tarea en esta familia en la primera línea de la definición de tarea anterior.

1. Elija la versión más reciente. 

1. Elija **Implementar** y **Ejecutar tarea**. 

1. En la página **Ejecutar tarea**, en **Clúster**, elija el clúster y, a continuación, en **Redes**, para **Subredes**, elija las subredes disponibles para la tarea. 

1. Seleccione **Crear**. 

**Verificar que los mensajes de registro multilínea en Amazon CloudWatch aparezcan concatenados**

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

1. En el panel de navegación, amplíe **Logs** (Registros) y elija **Log groups** (Grupos de registros). 

1. Elija el grupo de registros `multiline-test/applicatio`. 

1. Elija el registro. Vea los mensajes. Las líneas que coinciden con las reglas del archivo analizador se concatenan y aparecen como un solo mensaje. 

   En el siguiente fragmento de registro, se muestran las líneas concatenadas en un único evento de seguimiento de pila Java: 

   ```
   {
       "container_id": "xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "log": "Dec 14 06:41:08 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!\n    at com.myproject.module.MyProject.badMethod(MyProject.java:22)\n    at com.myproject.module.MyProject.oneMoreMethod(MyProject.java:18)\n    at com.myproject.module.MyProject.anotherMethod(MyProject.java:14)\n    at com.myproject.module.MyProject.someMethod(MyProject.java:10)\n    at com.myproject.module.MyProject.main(MyProject.java:6)",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:2"
   }
   ```

   El siguiente fragmento de registro muestra cómo aparece el mismo mensaje con una sola línea si se ejecuta un contenedor de Amazon ECS que no está configurado para concatenar mensajes de registro de varias líneas. 

   ```
   {
       "log": "Dec 14 06:41:08 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:3"
   }
   ```

### Ejemplo: utilizar un analizador integrado de Fluent Bit
<a name="fluent-bit-parser"></a>

En este ejemplo, completará los siguientes pasos: 

1. Cree y cargue la imagen en un contenedor de Fluent Bit. 

1. Cree y cargue la imagen de una aplicación multilínea de demostración que se ejecuta, falla y genera un seguimiento de pila multilínea.

1. Cree la definición de tarea y ejecute la tarea. 

1. Consulte los registros para verificar que los mensajes que abarcan varias líneas aparezcan concatenados. 

**Crear y cargar la imagen en un contenedor de Fluent Bit**

En esta imagen, se incluirá un archivo de configuración que hace referencia al analizador de Fluent Bit. 

1. Cree una carpeta con el nombre `FluentBitDockerImage`. 

1. En la carpeta `FluentBitDockerImage`, cree un archivo de configuración personalizado que haga referencia al archivo analizador integrado de Fluent Bit.

   Para obtener más información sobre el archivo de configuración personalizado, consulte [Especificación de un archivo de configuración personalizado](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-taskdef.html#firelens-taskdef-customconfig) en la *Guía para desarrolladores de Amazon Elastic Container Service* 

   1. Pegue los siguientes contenidos en el archivo:

      ```
      [FILTER]
          name                  multiline
          match                 *
          multiline.key_content log
          multiline.parser      go
      ```

   1. Guarde el archivo como `extra.conf`. 

1. En la carpeta `FluentBitDockerImage`, cree el archivo de Dockerfile con la imagen de Fluent Bit, el analizador y los archivos de configuración que ha creado.

   1. Pegue los siguientes contenidos en el archivo:

      ```
      FROM public.ecr.aws/aws-observability/aws-for-fluent-bit:latest
      ADD extra.conf /extra.conf
      ```

   1. Guarde el archivo como `Dockerfile`.

1. Con el archivo de Dockerfile, cree una imagen de Fluent Bit personalizada con el archivo de configuración personalizado incluido.
**nota**  
Puede colocar el archivo de configuración en cualquier parte de la imagen de Docker, excepto en `/fluent-bit/etc/fluent-bit.conf`, ya que FireLens utiliza esta ruta de archivo.

   1. Cree la imagen: `docker build -t fluent-bit-multiline-image.`

      Donde: `fluent-bit-multiline-image` es el nombre de la imagen de este ejemplo.

   1. Compruebe que la imagen se haya creado correctamente: `docker images —filter reference=fluent-bit-multiline-image` 

      Si la acción se realiza correctamente, el resultado muestra la imagen y la etiqueta `latest`.

1. Cargue la imagen de Fluent Bit personalizada en Amazon Elastic Container Registry.

   1. Cree un repositorio de Amazon ECR para almacenar la imagen: `aws ecr create-repository --repository-name fluent-bit-multiline-repo --region us-east-1`

      Donde: `fluent-bit-multiline-repo` es el nombre del repositorio y `us-east-1` es la región de este ejemplo. 

      El resultado proporciona los detalles del nuevo repositorio. 

   1. Etiquete la imagen con el valor `repositoryUri` del resultado anterior: `docker tag fluent-bit-multiline-image repositoryUri` 

      Ejemplo:: `docker tag fluent-bit-multiline-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo` 

   1. Ejecute la imagen de Docker para verificar que se haya ejecutado correctamente: `docker images —filter reference=repositoryUri`

      En el resultado, el nombre del repositorio cambia de fluent-bit-multiline-repo a `repositoryUri`.

   1. Autentíquese en Amazon ECR ejecutando el comando `aws ecr get-login-password` y especifique el ID del registro en el que desea efectuar la autenticación: `aws ecr get-login-password | docker login --username AWS --password-stdin registry ID.dkr.ecr.region.amazonaws.com` 

      Ejemplo:: `ecr get-login-password | docker login --username AWS --password-stdin xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com`

      Aparece un mensaje de inicio de sesión correcto.

   1. Envíe la imagen a Amazon ECR: `docker push registry ID.dkr.ecr.region.amazonaws.com/repository name` 

      Ejemplo:: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo`

**Crear y cargar la imagen para una aplicación multilínea de demostración**

En esta imagen, se incluirá un archivo de script de Python que ejecuta la aplicación y un archivo de registro de ejemplo. 

1. Cree una carpeta denominada `multiline-app`: `mkdir multiline-app` 

1. Cree un archivo de script de Python.

   1. En la carpeta `multiline-app`, cree un archivo y asígnele el nombre `main.py`.

   1. Pegue los siguientes contenidos en el archivo:

      ```
      import os
      import time
      file1 = open('/test.log', 'r')
      Lines = file1.readlines()
       
      count = 0
      
      for i in range(10):
          print("app running normally...")
          time.sleep(1)
      
      # Strips the newline character
      for line in Lines:
          count += 1
          print(line.rstrip())
      print(count)
      print("app terminated.")
      ```

   1. Guarde el archivo `main.py`.

1. Cree un archivo de registro de ejemplo. 

   1. En la carpeta `multiline-app`, cree un archivo y asígnele el nombre `test.log`.

   1. Pegue los siguientes contenidos en el archivo:

      ```
      panic: my panic
      
      goroutine 4 [running]:
      panic(0x45cb40, 0x47ad70)
        /usr/local/go/src/runtime/panic.go:542 +0x46c fp=0xc42003f7b8 sp=0xc42003f710 pc=0x422f7c
      main.main.func1(0xc420024120)
        foo.go:6 +0x39 fp=0xc42003f7d8 sp=0xc42003f7b8 pc=0x451339
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003f7e0 sp=0xc42003f7d8 pc=0x44b4d1
      created by main.main
        foo.go:5 +0x58
      
      goroutine 1 [chan receive]:
      runtime.gopark(0x4739b8, 0xc420024178, 0x46fcd7, 0xc, 0xc420028e17, 0x3)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc420053e30 sp=0xc420053e00 pc=0x42503c
      runtime.goparkunlock(0xc420024178, 0x46fcd7, 0xc, 0x1000f010040c217, 0x3)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc420053e70 sp=0xc420053e30 pc=0x42512e
      runtime.chanrecv(0xc420024120, 0x0, 0xc420053f01, 0x4512d8)
        /usr/local/go/src/runtime/chan.go:506 +0x304 fp=0xc420053f20 sp=0xc420053e70 pc=0x4046b4
      runtime.chanrecv1(0xc420024120, 0x0)
        /usr/local/go/src/runtime/chan.go:388 +0x2b fp=0xc420053f50 sp=0xc420053f20 pc=0x40439b
      main.main()
        foo.go:9 +0x6f fp=0xc420053f80 sp=0xc420053f50 pc=0x4512ef
      runtime.main()
        /usr/local/go/src/runtime/proc.go:185 +0x20d fp=0xc420053fe0 sp=0xc420053f80 pc=0x424bad
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc420053fe8 sp=0xc420053fe0 pc=0x44b4d1
      
      goroutine 2 [force gc (idle)]:
      runtime.gopark(0x4739b8, 0x4ad720, 0x47001e, 0xf, 0x14, 0x1)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003e768 sp=0xc42003e738 pc=0x42503c
      runtime.goparkunlock(0x4ad720, 0x47001e, 0xf, 0xc420000114, 0x1)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003e7a8 sp=0xc42003e768 pc=0x42512e
      runtime.forcegchelper()
        /usr/local/go/src/runtime/proc.go:238 +0xcc fp=0xc42003e7e0 sp=0xc42003e7a8 pc=0x424e5c
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003e7e8 sp=0xc42003e7e0 pc=0x44b4d1
      created by runtime.init.4
        /usr/local/go/src/runtime/proc.go:227 +0x35
      
      goroutine 3 [GC sweep wait]:
      runtime.gopark(0x4739b8, 0x4ad7e0, 0x46fdd2, 0xd, 0x419914, 0x1)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003ef60 sp=0xc42003ef30 pc=0x42503c
      runtime.goparkunlock(0x4ad7e0, 0x46fdd2, 0xd, 0x14, 0x1)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003efa0 sp=0xc42003ef60 pc=0x42512e
      runtime.bgsweep(0xc42001e150)
        /usr/local/go/src/runtime/mgcsweep.go:52 +0xa3 fp=0xc42003efd8 sp=0xc42003efa0 pc=0x419973
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003efe0 sp=0xc42003efd8 pc=0x44b4d1
      created by runtime.gcenable
        /usr/local/go/src/runtime/mgc.go:216 +0x58
      one more line, no multiline
      ```

   1. Guarde el archivo `test.log`.

1. En la carpeta `multiline-app`, cree el archivo de Dockerfile.

   1. Pegue los siguientes contenidos en el archivo:

      ```
      FROM public.ecr.aws/amazonlinux/amazonlinux:latest
      ADD test.log /test.log
      
      RUN yum upgrade -y && yum install -y python3
      
      WORKDIR /usr/local/bin
      
      COPY main.py .
      
      CMD ["python3", "main.py"]
      ```

   1. Guarde el archivo `Dockerfile`.

1. Con el archivo de Dockerfile, cree una imagen.

   1. Cree la imagen: `docker build -t multiline-app-image `

      Donde: `multiline-app-image` es el nombre de la imagen de este ejemplo.

   1. Compruebe que la imagen se haya creado correctamente: `docker images —filter reference=multiline-app-image` 

      Si la acción se realiza correctamente, el resultado muestra la imagen y la etiqueta `latest`.

1. Cargue la imagen en Amazon Elastic Container Registry.

   1. Cree un repositorio de Amazon ECR para almacenar la imagen: `aws ecr create-repository --repository-name multiline-app-repo --region us-east-1`

      Donde: `multiline-app-repo` es el nombre del repositorio y `us-east-1` es la región de este ejemplo. 

      El resultado proporciona los detalles del nuevo repositorio. Tome nota del valor `repositoryUri`, ya que lo necesitará en los siguientes pasos. 

   1. Etiquete la imagen con el valor `repositoryUri` del resultado anterior: `docker tag multiline-app-image repositoryUri` 

      Ejemplo:: `docker tag multiline-app-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo` 

   1. Ejecute la imagen de Docker para verificar que se haya ejecutado correctamente: `docker images —filter reference=repositoryUri`

      En el resultado, el nombre del repositorio cambia de `multiline-app-repo` al valor `repositoryUri`.

   1. Envíe la imagen a Amazon ECR: `docker push aws_account_id.dkr.ecr.region.amazonaws.com/repository name` 

      Ejemplo:: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo`

**Crear la definición de tarea y ejecutar la tarea**

1. Cree un archivo de definición de tarea con el nombre de archivo `multiline-task-definition.json`. 

1. Pegue los siguientes contenidos en el archivo `multiline-task-definition.json`: 

   ```
   {
       "family": "firelens-example-multiline",
       "taskRoleArn": "task role ARN,
       "executionRoleArn": "execution role ARN",
       "containerDefinitions": [
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-image:latest",
               "name": "log_router",
               "firelensConfiguration": {
                   "type": "fluentbit",
                   "options": {
                       "config-file-type": "file",
                       "config-file-value": "/extra.conf"
                   }
               },
               "memoryReservation": 50
           },
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/multiline-app-image:latest",
               "name": "app",
               "logConfiguration": {
                   "logDriver": "awsfirelens",
                   "options": {
                       "Name": "cloudwatch_logs",
                       "region": "us-east-1",
                       "log_group_name": "multiline-test/application",
                       "auto_create_group": "true",
                       "log_stream_prefix": "multiline-"
                   }
               },
               "memoryReservation": 100
           }
       ],
       "requiresCompatibilities": ["FARGATE"],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512"
   }
   ```

   Sustituya lo siguiente en la definición de tarea `multiline-task-definition.json`:

   1. `task role ARN`

      Para encontrar el ARN del rol de tarea, vaya a la consola de IAM. Elija **Roles** y busque el rol de tarea `ecs-task-role-for-firelens` que ha creado. Elija el rol y copie el **ARN** que aparece en la sección **Summary** (Resumen).

   1. `execution role ARN`

      Para encontrar el ARN del rol de ejecución, vaya a la consola de IAM. Elija **Roles** y busque el rol `ecsTaskExecutionRole`. Elija el rol y copie el **ARN** que aparece en la sección **Summary** (Resumen).

   1. `aws_account_id`

      Para encontrar su `aws_account_id`, inicie sesión en la Consola de administración de AWS. Elija su nombre de usuario en la parte superior derecha y copie su ID de cuenta.

   1. `us-east-1`

      Sustituya la región si es necesario.

1. Registre el archivo de definición de tarea: `aws ecs register-task-definition --cli-input-json file://multiline-task-definition.json --region us-east-1` 

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 tarea) y, a continuación, seleccione la familia `firelens-example-multiline` porque hemos registrado la definición de tarea en esta familia en la primera línea de la definición de tarea anterior.

1. Elija la versión más reciente. 

1. Elija **Implementar** y **Ejecutar tarea**. 

1. En la página **Ejecutar tarea**, en **Clúster**, elija el clúster y, a continuación, en **Redes**, para **Subredes**, elija las subredes disponibles para la tarea. 

1. Seleccione **Crear**. 

**Verificar que los mensajes de registro multilínea en Amazon CloudWatch aparezcan concatenados**

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

1. En el panel de navegación, amplíe **Logs** (Registros) y elija **Log groups** (Grupos de registros). 

1. Elija el grupo de registros `multiline-test/applicatio`. 

1. Elija el registro y vea los mensajes. Las líneas que coinciden con las reglas del archivo analizador se concatenan y aparecen como un solo mensaje. 

   En el siguiente fragmento de registro, se muestra un seguimiento de pila Go que está concatenado en un único evento: 

   ```
   {
       "log": "panic: my panic\n\ngoroutine 4 [running]:\npanic(0x45cb40, 0x47ad70)\n  /usr/local/go/src/runtime/panic.go:542 +0x46c fp=0xc42003f7b8 sp=0xc42003f710 pc=0x422f7c\nmain.main.func1(0xc420024120)\n  foo.go:6 +0x39 fp=0xc42003f7d8 sp=0xc42003f7b8 pc=0x451339\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003f7e0 sp=0xc42003f7d8 pc=0x44b4d1\ncreated by main.main\n  foo.go:5 +0x58\n\ngoroutine 1 [chan receive]:\nruntime.gopark(0x4739b8, 0xc420024178, 0x46fcd7, 0xc, 0xc420028e17, 0x3)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc420053e30 sp=0xc420053e00 pc=0x42503c\nruntime.goparkunlock(0xc420024178, 0x46fcd7, 0xc, 0x1000f010040c217, 0x3)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc420053e70 sp=0xc420053e30 pc=0x42512e\nruntime.chanrecv(0xc420024120, 0x0, 0xc420053f01, 0x4512d8)\n  /usr/local/go/src/runtime/chan.go:506 +0x304 fp=0xc420053f20 sp=0xc420053e70 pc=0x4046b4\nruntime.chanrecv1(0xc420024120, 0x0)\n  /usr/local/go/src/runtime/chan.go:388 +0x2b fp=0xc420053f50 sp=0xc420053f20 pc=0x40439b\nmain.main()\n  foo.go:9 +0x6f fp=0xc420053f80 sp=0xc420053f50 pc=0x4512ef\nruntime.main()\n  /usr/local/go/src/runtime/proc.go:185 +0x20d fp=0xc420053fe0 sp=0xc420053f80 pc=0x424bad\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc420053fe8 sp=0xc420053fe0 pc=0x44b4d1\n\ngoroutine 2 [force gc (idle)]:\nruntime.gopark(0x4739b8, 0x4ad720, 0x47001e, 0xf, 0x14, 0x1)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003e768 sp=0xc42003e738 pc=0x42503c\nruntime.goparkunlock(0x4ad720, 0x47001e, 0xf, 0xc420000114, 0x1)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003e7a8 sp=0xc42003e768 pc=0x42512e\nruntime.forcegchelper()\n  /usr/local/go/src/runtime/proc.go:238 +0xcc fp=0xc42003e7e0 sp=0xc42003e7a8 pc=0x424e5c\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003e7e8 sp=0xc42003e7e0 pc=0x44b4d1\ncreated by runtime.init.4\n  /usr/local/go/src/runtime/proc.go:227 +0x35\n\ngoroutine 3 [GC sweep wait]:\nruntime.gopark(0x4739b8, 0x4ad7e0, 0x46fdd2, 0xd, 0x419914, 0x1)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003ef60 sp=0xc42003ef30 pc=0x42503c\nruntime.goparkunlock(0x4ad7e0, 0x46fdd2, 0xd, 0x14, 0x1)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003efa0 sp=0xc42003ef60 pc=0x42512e\nruntime.bgsweep(0xc42001e150)\n  /usr/local/go/src/runtime/mgcsweep.go:52 +0xa3 fp=0xc42003efd8 sp=0xc42003efa0 pc=0x419973\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003efe0 sp=0xc42003efd8 pc=0x44b4d1\ncreated by runtime.gcenable\n  /usr/local/go/src/runtime/mgc.go:216 +0x58",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:2"
   }
   ```

   En el siguiente fragmento de registro, se muestra cómo aparece el mismo evento si ejecuta un contenedor ECS que no está configurado para concatenar mensajes de registro multilínea. El campo de registro contiene una sola línea.

   ```
   {
       "log": "panic: my panic",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:3"
   ```

**nota**  
Si los registros van a los archivos de registro en lugar de al resultado estándar, recomendamos especificar `multiline.parser` y los parámetros de configuración `multiline.key_content` en el [complemento de entrada de cola](https://docs.fluentbit.io/manual/pipeline/inputs/tail#multiline-support) en lugar del filtro.

# Implementación de Fluent Bit en contenedores de Amazon ECS para Windows
<a name="tutorial-deploy-fluentbit-on-windows"></a>

Fluent Bit es un procesador y enrutador de registros rápido y flexible, que es compatible con varios sistemas operativos. Se puede usar para enrutar registros a varios destinos de AWS, como Registros de Amazon CloudWatch, Firehose Amazon S3 y Amazon OpenSearch Service. Fluent Bit admite soluciones de socios comunes, como [Datadog](https://www.datadoghq.com/), [Splunk](https://www.splunk.com/) y servidores HTTP personalizados. Para obtener más información acerca de Fluent Bit, consulte el sitio web de [https://fluentbit.io/](https://fluentbit.io/).

La imagen de **AWS para Bit Fluent** está disponible en la galería pública y en un repositorio de Amazon ECR en la mayoría de las regiones para lograr alta disponibilidad. Para obtener más información, consulte [https://github.com/aws/aws-for-fluent-bit](https://github.com/aws/aws-for-fluent-bit) en el sitio web de GitHub.

Este tutorial explica cómo implementar contenedores de Fluent Bit en sus instancias de Windows que se ejecutan en Amazon ECS para transmitir los registros generados por las tareas de Windows a Amazon CloudWatch para un registro centralizado. 

Este tutorial utiliza el siguiente enfoque:
+ Fluent Bit funciona como un servicio mediante la estrategia de programación de Daemon. Esta estrategia garantiza que siempre se ejecute una única instancia de Fluent Bit en las instancias de contenedor del clúster.
  + Escucha en el puerto 24224 mediante el complemento de entrada directa.
  + Exponga el puerto 24224 al host para que el tiempo de ejecución de Docker pueda enviar registros a Fluent Bit mediante este puerto expuesto.
  + Tiene una configuración que permite a Fluent Bit enviar los registros a destinos especificados.
+ Inicie todos los demás contenedores de tareas de Amazon ECS con el controlador de registro fluentd. Para obtener más información, consulte [Controlador de registro Fluentd](https://docs.docker.com/engine/logging/drivers/fluentd/) en el sitio web de documentación de Docker.
  + Docker se conecta al socket TCP 24224 en localhost dentro del espacio de nombres del host.
  + El agente de Amazon ECS agrega etiquetas a los contenedores que incluyen el nombre del clúster, el nombre de familia y el número de revisión de la definición de tarea, el ARN de la tarea y el nombre del contenedor. La misma información se agrega al archivo de registro mediante la opción de etiquetas del controlador de registro fluentd de Docker. Para obtener más información, consulte [labels, labels-regex, env y env-regex](https://docs.docker.com/config/containers/logging/fluentd/#labels-labels-regex-env-and-env-regex) en el sitio web de documentación de Docker.
  + Como la opción `async` del controlador de registro fluentd está configurada en `true`, Docker almacena en búfer los registros hasta que se reinicie el contenedor de Fluent Bit. Puede aumentar el límite del búfer si configura la opción fluentd-buffer-limit. Para obtener más información, consulte [fluentd-buffer-limit](https://docs.docker.com/config/containers/logging/fluentd/#fluentd-buffer-limit) en el sitio web de documentación de Docker.

 El flujo de trabajo es el siguiente:
+ El contenedor de Fluent Bit se inicia y escucha en el puerto 24224, el cual está expuesto al host.
+ Fluent Bit usa las credenciales del rol de IAM de la tarea especificadas en la definición de tarea.
+ Otras tareas ejecutadas en la misma instancia utilizan el controlador de registro fluentd de Docker para conectarse al contenedor de Fluent Bit en el puerto 24224. 
+ Cuando los contenedores de la aplicación generan registros, el tiempo de ejecución de Docker los etiqueta, agrega metadatos adicionales especificados en las etiquetas y luego los reenvía al puerto 24224 del espacio de nombres del host. 
+ Fluent Bit recibe el archivo de registro en el puerto 24224 porque está expuesto al espacio de nombres del host.
+ Fluent Bit lleva a cabo su procesamiento interno y enruta los registros según lo especificado.

Este tutorial utiliza la configuración predeterminada de Fluent Bit de CloudWatch, que hace lo siguiente:
+ Crea un nuevo grupo de registro para cada clúster y familia de definiciones de tarea.
+ Crea un nuevo flujo de registro para cada contenedor de tareas del grupo de registro generado anteriormente cada vez que se lanza una nueva tarea. Cada flujo se marcará con el identificador de tarea al que pertenece el contenedor.
+ Agrega metadatos adicionales en cada entrada del registro, como el nombre del clúster, el ARN de la tarea, el nombre del contenedor de la tarea y la familia y el número de revisión de definición de la tarea.

  Por ejemplo, si tiene `task_1` con `container_1` y `container_2`, además de `ask_2` con `container_3`, entonces los siguientes son los flujos de registro de CloudWatch:
  + `/aws/ecs/windows.ecs_task_1`

    `task-out.TASK_ID.container_1`

    `task-out.TASK_ID.container_2`
  + `/aws/ecs/windows.ecs_task_2`

    `task-out.TASK_ID.container_3`

**nota**  
Puede utilizar puntos de conexión de servicio de doble pila para interactuar con Amazon ECS desde la AWS CLI, los SDK y la API de Amazon ECS a través de IPv4 e IPv6. Para obtener más información, consulte [Uso de puntos de conexión de doble pila en Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [Requisitos previos](#tutorial-deploy-fluentbit-on-windows-prereqs)
+ [Paso 1: Crear roles de acceso de IAM](#tutorial-deploy-fluentbit-on-windows-iam-access-role)
+ [Paso 2: Crear una instancia de contenedor de Amazon ECS para Windows](#tutorial-deploy-fluentbit-on-windows-instance)
+ [Paso 3: Configurar Fluent Bit](#tutorial-deploy-fluentbit-on-windows-configure-fluentbit)
+ [Paso 4: Registrar una definición de tarea de Fluent Bit para Windows que dirija los registros a CloudWatch](#tutorial-deploy-fluentbit-on-windows-register-task-definition)
+ [Paso 5: Ejecutar la definición de tarea `ecs-windows-fluent-bit` como un servicio de Amazon ECS mediante la estrategia de programación de daemon](#tutorial-deploy-fluentbit-on-windows-run-task)
+ [Paso 6: Registrar una definición de tarea de Windows que genere los registros](#tutorial-deploy-fluentbit-on-windows-register-task-def-logs)
+ [Paso 7: Ejecutar la definición de tarea `windows-app-task`](#tutorial-deploy-fluentbit-on-windows-run-task-fluentbit)
+ [Paso 8: Verificar los registros en CloudWatch](#tutorial-deploy-fluentbit-on-windows-verify)
+ [Paso 9: limpiar](#tutorial-deploy-fluentbit-on-windows-cleanup)

## Requisitos previos
<a name="tutorial-deploy-fluentbit-on-windows-prereqs"></a>

En este tutorial se supone que los siguientes requisitos previos se han completado:
+ La última versión de la AWS CLI está instalada y configurada. Para obtener más información, consulte [Instalación o actualización de la versión más reciente de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ La imagen del contenedor `aws-for-fluent-bit` está disponible para los siguientes sistemas operativos Windows:
  + Windows Server 2019 Core
  + Windows Server 2019 Full
  + Windows Server 2022 Core
  + Windows Server 2022 Full
+ Se han completado los pasos que se indican en [Configuración para utilizar Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Tiene un clúster. En este tutorial, el nombre del clúster es **FluentBit-cluster**.
+ Tiene una VPC con una subred pública donde se lanzará la instancia de EC2. Puede utilizar la VPC predeterminada. También puede usar una subred privada que permita que los puntos de conexión de Amazon CloudWatch lleguen a la subred. Para obtener más información sobre los puntos de conexión de Amazon CloudWatch, consulte [Cuotas y puntos de conexión de Amazon CloudWatch](https://docs.aws.amazon.com/general/latest/gr/cw_region.html) en la *Referencia general de AWS*. Para obtener información acerca de cómo usar el asistente de Amazon VPC para crear una VPC, consulte [Creación de una nube virtual privada](get-set-up-for-amazon-ecs.md#create-a-vpc).

## Paso 1: Crear roles de acceso de IAM
<a name="tutorial-deploy-fluentbit-on-windows-iam-access-role"></a>

Cree los roles de IAM de Amazon ECS.

1.  Cree el rol de la instancia de contenedor de Amazon ECS denominado “ecsInstanceRole”. Para obtener más información, consulte [Rol de IAM de instancia de contenedor de Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/instance_IAM_role.html).

1. Cree un rol de IAM para la tarea de Fluent Bit denominado `fluentTaskRole`. Para obtener más información, consulte [Rol de IAM de tarea de Amazon ECS](task-iam-roles.md).

    Los contenedores de tareas asumen los permisos de IAM concedidos en este rol de IAM. Para permitir que Fluent Bit envíe registros a CloudWatch, debe adjuntar los siguientes permisos al rol de IAM de la tarea.

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
       {
           "Effect": "Allow",
           "Action": [
               "logs:CreateLogStream",
               "logs:CreateLogGroup",
               "logs:DescribeLogStreams",
               "logs:PutLogEvents"
           ],
           "Resource": "*"
       }
       ]
   }
   ```

------

1. Asocie la política de al rol.

   1. Guarde el contenido anterior en un archivo denominado `fluent-bit-policy.json`.

   1. Ejecute el siguiente comando para asociar la política insertada al rol de IAM `fluentTaskRole`.

      ```
      aws iam put-role-policy --role-name fluentTaskRole --policy-name fluentTaskPolicy --policy-document file://fluent-bit-policy.json
      ```

## Paso 2: Crear una instancia de contenedor de Amazon ECS para Windows
<a name="tutorial-deploy-fluentbit-on-windows-instance"></a>

Cree una instancia de contenedor de Amazon ECS para Windows.

**Para crear una instancia de Amazon ECS**

1. Utilice el comando `aws ssm get-parameters` para recuperar el ID de la AMI de la región que aloja la VPC. Para obtener más información, consulte [Recuperación de los metadatos de la AMI optimizada para Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/retrieve-ecs-optimized_windows_AMI.html).

1. Utilice la consola de Amazon EC2 para lanzar la instancia.

   1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

   1. En la barra de navegación, seleccione la región a utilizar.

   1. En el **panel de EC2**, elija **Launch Instance** (Lanzar instancia).

   1. En **Name (Nombre)**, escriba un nombre único.

   1. En **Application and OS Images (Amazon Machine Image)** (Imágenes de aplicaciones y SO [Amazon Machine Image]), elija la AMI que recuperó en el primer paso.

   1. Para **Tipo de instancia**, elija `t3.xlarge`.

   1. En **Key pair (login)** (Par de claves [inicio de sesión]), elija un par de claves. 

   1. En **Network settings** (Configuración de red), para **Security groups** (Grupo de seguridad), seleccione un grupo de seguridad existente o cree uno nuevo.

   1. En **Network settings** (Configuración de red), para **Auto-assign Public IP** (Asignar automáticamente una IP pública), selecciona **Enable** (Activar). 

   1. En **Advanced details** (Detalles avanzados), en **IAM instance profile** (Perfil de instancia de IAM), elija **ecsInstanceRole**.

   1. Configure su instancia de contenedor de Amazon ECS con los siguientes datos de usuario. En **Advanced details** (Detalles avanzados), pegue el siguiente script en el campo **User data** (Datos de usuario), reemplazando *cluster\$1name* con el nombre de su clúster.

      ```
      <powershell>
      Import-Module ECSTools
      Initialize-ECSAgent -Cluster cluster-name -EnableTaskENI -EnableTaskIAMRole -LoggingDrivers '["awslogs","fluentd"]'
      </powershell>
      ```

   1. Cuando esté listo, seleccione el campo de confirmación y después elija **Launch Instances**. 

   1. Verá una página de confirmación que indicará que la instancia se está lanzando. Elija **View instances** para cerrar la página de confirmación y volver a la consola.

## Paso 3: Configurar Fluent Bit
<a name="tutorial-deploy-fluentbit-on-windows-configure-fluentbit"></a>

Puede utilizar la siguiente configuración predeterminada proporcionada por AWS para empezar rápidamente:
+ [Amazon CloudWatch](https://github.com/aws/aws-for-fluent-bit/blob/mainline/ecs_windows_forward_daemon/cloudwatch.conf), el cual se basa en el complemento Fluent Bit para [Amazon CloudWatch](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch) en el *Fluent Bit Official Manual* (Manual oficial de Fluent Bit).

También puede usar otras configuraciones predeterminadas de AWS. Para obtener más información, consulte [Overriding the entrypoint for the Windows image](https://github.com/aws/aws-for-fluent-bit/tree/mainline/ecs_windows_forward_daemon#overriding-the-entrypoint-for-the-windows-image) (Anulación del punto de entrada de la imagen de Windows) en `aws-for-fluent-bit` en el sitio web de GitHub.

La configuración predeterminada de Fluent Bit de Amazon CloudWatch se muestra a continuación.

Reemplace las siguientes variables:
+ *region* con la región a la que desea enviar los registros de Amazon CloudWatch.

```
[SERVICE]
    Flush               5
    Log_Level           info
    Daemon              off

[INPUT]
    Name                forward
    Listen              0.0.0.0
    Port                24224
    Buffer_Chunk_Size   1M
    Buffer_Max_Size     6M
    Tag_Prefix          ecs.

# Amazon ECS agent adds the following log keys as labels to the docker container.
# We would use fluentd logging driver to add these to log record while sending it to Fluent Bit.
[FILTER]
    Name                modify
    Match               ecs.*
    Rename              com.amazonaws.ecs.cluster ecs_cluster
    Rename              com.amazonaws.ecs.container-name ecs_container_name
    Rename              com.amazonaws.ecs.task-arn ecs_task_arn
    Rename              com.amazonaws.ecs.task-definition-family ecs_task_definition_family
    Rename              com.amazonaws.ecs.task-definition-version ecs_task_definition_version

[FILTER]
    Name                rewrite_tag
    Match               ecs.*
    Rule                $ecs_task_arn ^([a-z-:0-9]+)/([a-zA-Z0-9-_]+)/([a-z0-9]+)$  out.$3.$ecs_container_name false
    Emitter_Name        re_emitted

[OUTPUT]
    Name                cloudwatch_logs
    Match               out.*
    region              region
    log_group_name      fallback-group
    log_group_template  /aws/ecs/$ecs_cluster.$ecs_task_definition_family
    log_stream_prefix   task-
    auto_create_group   On
```

Cada registro que entra en Fluent Bit tiene una etiqueta que usted especifica o se genera automáticamente cuando no proporcione una. Las etiquetas se pueden usar para enrutar distintos registros a diferentes destinos. Para obtener información adicional, consulte [Tag](https://docs.fluentbit.io/manual/concepts/key-concepts#tag) (Etiqueta) en el *Fluent Bit Official Manual* (Manual oficial de Fluent Bit). 

La configuración de Fluent Bit descrita anteriormente tiene las siguientes propiedades:
+ El complemento de entrada directa escucha el tráfico entrante en el puerto TCP 24224. 
+ Cada entrada de registro recibida en ese puerto tiene una etiqueta que el complemento de entrada directa modifica para poner un prefijo de cadena `ecs.` al registro. 
+ La canalización interna de Fluent Bit enruta la entrada de registro para modificar el filtro mediante la expresión regular Match. Este filtro reemplaza las claves del archivo de registro JSON por el formato que Fluent Bit puede utilizar. 
+ A continuación, el filtro rewrite\$1tag utiliza la entrada de registro modificada. Este filtro cambia la etiqueta del archivo de registro al formato out.*TASK\$1ID*.*CONTAINER\$1NAME*. 
+ La nueva etiqueta se enrutará al complemento de salida cloudwatch\$1logs, el cual crea los grupos de registro y las transmisiones tal como se describió anteriormente mediante las opciones `log_group_template` y `log_stream_prefix` del complemento de salida de CloudWatch. Para obtener información adicional, consulte [Configuration parameters](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch#configuration-parameters) (Parámetros de configuración) en el *Fluent Bit Official Manual* (Manual oficial de Fluent Bit). 

## Paso 4: Registrar una definición de tarea de Fluent Bit para Windows que dirija los registros a CloudWatch
<a name="tutorial-deploy-fluentbit-on-windows-register-task-definition"></a>

Registre una definición de tarea de Fluent Bit para Windows que dirija los registros a CloudWatch.

**nota**  
Esta definición de tarea expone el puerto de contenedor de Fluent Bit 24224 al puerto de host 24224. Compruebe que este puerto no esté abierto en el grupo de seguridad de la instancia de EC2 para impedir el acceso desde el exterior.

**Para registrar una definición de tareas**

1. Cree un archivo denominado `fluent-bit.json` con el siguiente contenido.

   Reemplace las siguientes variables:
   + *task-iam-role* con el nombre de recurso de Amazon (ARN) del rol de IAM de su tarea
   + *region* con la región en la que se ejecuta la tarea

   ```
   {
     "family": "ecs-windows-fluent-bit",
     "taskRoleArn": "task-iam-role",
     "containerDefinitions": [
       {
         "name": "fluent-bit",
         "image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:windowsservercore-latest",
         "cpu": 512,
         "portMappings": [
           {
             "hostPort": 24224,
             "containerPort": 24224,
             "protocol": "tcp"
           }
         ],
         "entryPoint": [
           "Powershell",
           "-Command"
         ],
         "command": [
           "C:\\entrypoint.ps1 -ConfigFile C:\\ecs_windows_forward_daemon\\cloudwatch.conf"
         ],
         "environment": [
           {
             "name": "AWS_REGION",
             "value": "region"
           }
         ],
         "memory": 512,
         "essential": true,
         "logConfiguration": {
           "logDriver": "awslogs",
           "options": {
             "awslogs-group": "/ecs/fluent-bit-logs",
             "awslogs-region": "region",
             "awslogs-stream-prefix": "flb",
             "awslogs-create-group": "true"
           }
         }
       }
     ],
     "memory": "512",
     "cpu": "512"
   }
   ```

1. Ejecute el siguiente comando para registrar la definición de tarea.

   ```
   aws ecs register-task-definition --cli-input-json file://fluent-bit.json --region region
   ```

   Puede enumerar las definiciones de tarea para su cuenta con el comando `list-task-definitions`. El resultado muestra los valores de familia y revisión que puede usar junto con `run-task` o `start-task`.

## Paso 5: Ejecutar la definición de tarea `ecs-windows-fluent-bit` como un servicio de Amazon ECS mediante la estrategia de programación de daemon
<a name="tutorial-deploy-fluentbit-on-windows-run-task"></a>

Después de registrar una definición de tarea para su cuenta, puede ejecutar una tarea en el clúster. En este tutorial, se ejecuta una instancia de la definición de tarea `ecs-windows-fluent-bit:1` en el clúster `FluentBit-cluster`. Ejecute la tarea en un servicio que utilice la estrategia de programación de daemon, lo que garantizará que siempre se ejecute una sola instancia de Fluent Bit en cada una de las instancias de contenedor.

**Para ejecutar una tarea**

1. Ejecute el siguiente comando para iniciar la definición de tarea `ecs-windows-fluent-bit:1` (registrada en el paso anterior) como servicio.
**nota**  
Esta definición de tareas utiliza el controlador de registro `awslogs`; la instancia de contenedor debe tener los permisos necesarios.

   Reemplace las siguientes variables:
   + *region* con la región en la que se ejecuta el servicio

   ```
   aws ecs create-service \
       --cluster FluentBit-cluster \
       --service-name FluentBitForwardDaemonService \
       --task-definition ecs-windows-fluent-bit:1 \
       --launch-type EC2 \
       --scheduling-strategy DAEMON \
       --region region
   ```

1. Ejecute el siguiente comando para enumerar las tareas.

   Reemplace las siguientes variables:
   + *region* con la región en la que se ejecutan las tareas de servicio

   ```
   aws ecs list-tasks --cluster FluentBit-cluster --region region
   ```

## Paso 6: Registrar una definición de tarea de Windows que genere los registros
<a name="tutorial-deploy-fluentbit-on-windows-register-task-def-logs"></a>

Registre una definición de tarea que genere los registros. Esta definición de tarea implementa una imagen de contenedor de Windows que escribirá un número incremental por segundo en `stdout`.

La definición de tarea utiliza el controlador de registro fluentd que se conecta al puerto 24224, el cual escucha el complemento de Fluent Bit. El agente de Amazon ECS etiqueta a cada contenedor de Amazon ECS con etiquetas que incluyen el nombre del clúster, el ARN de la tarea, el nombre de la familia y el número de revisión de la definición de tarea y el nombre del contenedor de la tarea. Estas etiquetas de clave-valor se pasan a Fluent Bit.

**nota**  
Esta tarea utiliza el modo de red `default`. Sin embargo, también puede usar el modo de red `awsvpc` con la tarea.

**Para registrar una definición de tareas**

1. Cree un archivo denominado `windows-app-task.json` con el siguiente contenido.

   ```
   {
     "family": "windows-app-task",
     "containerDefinitions": [
       {
         "name": "sample-container",
         "image": "mcr.microsoft.com/windows/servercore:ltsc2019",
         "cpu": 512,
         "memory": 512,
         "essential": true,
         "entryPoint": [
           "Powershell",
           "-Command"
         ],
         "command": [
           "$count=1;while(1) { Write-Host $count; sleep 1; $count=$count+1;}"
         ],
         "logConfiguration": {
           "logDriver": "fluentd",
           "options": {
             "fluentd-address": "localhost:24224",
             "tag": "{{ index .ContainerLabels \"com.amazonaws.ecs.task-definition-family\" }}",
             "fluentd-async": "true",
             "labels": "com.amazonaws.ecs.cluster,com.amazonaws.ecs.container-name,com.amazonaws.ecs.task-arn,com.amazonaws.ecs.task-definition-family,com.amazonaws.ecs.task-definition-version"
           }
         }
       }
     ],
     "memory": "512",
     "cpu": "512"
   }
   ```

1. Ejecute el siguiente comando para registrar la definición de tarea.

   Reemplace las siguientes variables:
   + *region* con la región en la que se ejecuta la tarea

   ```
   aws ecs register-task-definition --cli-input-json file://windows-app-task.json --region region
   ```

   Puede enumerar las definiciones de tarea para su cuenta con el comando `list-task-definitions`. El resultado muestra los valores de familia y revisión que puede usar junto con `run-task` o `start-task`.

## Paso 7: Ejecutar la definición de tarea `windows-app-task`
<a name="tutorial-deploy-fluentbit-on-windows-run-task-fluentbit"></a>

Después de registrar la definición de tarea `windows-app-task`, ejecútela en el clúster `FluentBit-cluster`.

**Para ejecutar una tarea**

1. Ejecute la definición de tarea `windows-app-task:1` registrada en el paso anterior.

   Reemplace las siguientes variables:
   + *region* con la región en la que se ejecuta la tarea

   ```
   aws ecs run-task --cluster FluentBit-cluster --task-definition windows-app-task:1 --count 2 --region region
   ```

1. Ejecute el siguiente comando para enumerar las tareas.

   ```
   aws ecs list-tasks --cluster FluentBit-cluster
   ```

## Paso 8: Verificar los registros en CloudWatch
<a name="tutorial-deploy-fluentbit-on-windows-verify"></a>

Para verificar la configuración de Fluent Bit, compruebe los siguientes grupos de registro en la consola de CloudWatch:
+ `/ecs/fluent-bit-logs`: este es el grupo de registro que corresponde al contenedor de daemon de Fluent Bit que se ejecuta en la instancia de contenedor.
+ `/aws/ecs/FluentBit-cluster.windows-app-task`: este es el grupo de registro que corresponde a todas las tareas lanzadas para la familia de definición de tarea `windows-app-task` dentro del clúster `FluentBit-cluster`.

   `task-out.FIRST_TASK_ID.sample-container`: este flujo de registro contiene todos los registros generados por la primera instancia de la tarea en el contenedor de tareas del contenedor de muestras. 

  `task-out.SECOND_TASK_ID.sample-container`: este flujo de registro contiene todos los registros generados por la segunda instancia de la tarea en el contenedor de tareas del contenedor de muestras. 

 El flujo de registro `task-out.TASK_ID.sample-container` tiene campos similares a los siguientes:

```
{
    "source": "stdout",
    "ecs_task_arn": "arn:aws:ecs:region:0123456789012:task/FluentBit-cluster/13EXAMPLE",
    "container_name": "/ecs-windows-app-task-1-sample-container-cEXAMPLE",
    "ecs_cluster": "FluentBit-cluster",
    "ecs_container_name": "sample-container",
    "ecs_task_definition_version": "1",
    "container_id": "61f5e6EXAMPLE",
    "log": "10",
    "ecs_task_definition_family": "windows-app-task"
}
```

**Para verificar la configuración de Fluent Bit**

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

1. En el panel de navegación, seleccione **Grupos de registro**. Asegúrese de que está en la región donde ha implementado Fluent Bit en los contenedores.

   En la lista de grupos de registro de la Región de AWS, debería ver lo siguiente:
   + `/ecs/fluent-bit-logs`
   + `/aws/ecs/FluentBit-cluster.windows-app-task`

   Si ve estos grupos de registro, la configuración de Fluent Bit es correcta.

## Paso 9: limpiar
<a name="tutorial-deploy-fluentbit-on-windows-cleanup"></a>

Cuando termine este tutorial, debe limpiar los recursos asociados para evitar incurrir en cargos por recursos que no está utilizando. 

**Para borrar los recursos del tutorial, realice el siguiente procedimiento:**

1. Detenga la tarea `windows-simple-task` y la tarea `ecs-fluent-bit`. Para obtener más información, consulte [Detención de una tarea de Amazon ECS](standalone-task-stop.md).

1. Ejecute el siguiente comando para eliminar el grupo de registro `/ecs/fluent-bit-logs`. Para obtener más información sobre la eliminación de grupos de registro, consulte [delete-log-group](https://docs.aws.amazon.com/cli/latest/reference/logs/delete-log-group.html) en la *Referencia de la AWS Command Line Interface*.

   ```
   aws logs delete-log-group --log-group-name /ecs/fluent-bit-logs
   aws logs delete-log-group --log-group-name /aws/ecs/FluentBit-cluster.windows-app-task
   ```

1. Ejecute el siguiente comando para finalizar la instancia.

   ```
   aws ec2 terminate-instances --instance-ids instance-id
   ```

1. Ejecute los siguientes comandos para eliminar los roles de IAM. 

   ```
   aws iam delete-role --role-name ecsInstanceRole
   aws iam delete-role --role-name fluentTaskRole
   ```

1. Ejecute el siguiente comando para eliminar el clúster de Amazon ECS.

   ```
   aws ecs delete-cluster --cluster FluentBit-cluster
   ```

# Uso de gMSA para contenedores de EC2 Linux en Amazon ECS
<a name="linux-gmsa"></a>

Amazon ECS admite la autenticación de Active Directory para contenedores de Linux en EC2 con un tipo especial de cuenta de servicio denominada *cuenta de servicio administrada de grupo* (gMSA).

Las aplicaciones de red basadas en Linux, como las aplicaciones .NET Core, pueden utilizar Active Directory para facilitar la administración de autorizaciones y autenticación entre usuarios y servicios. Puede utilizar esta característica diseñando aplicaciones que se integren con Active Directory y se ejecuten en servidores unidos a un dominio. Sin embargo, dado que los contenedores de Linux no se pueden unir a un dominio, debe configurar un contenedor de Linux para que se ejecute con gMSA.

Un contenedor de Linux que se ejecuta con gMSA depende del daemon `credentials-fetcher` que se ejecuta en la instancia de Amazon EC2 del host del contenedor. Es decir, el daemon recupera las credenciales de la gMSA del controlador de dominio de Active Directory y, a continuación, las transfiere a la instancia de contenedor. Para obtener más información sobre las cuentas de servicio, consulte [Crear gMSAs para contenedores de Windows](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts) en el sitio web de Microsoft Learn.

## Consideraciones
<a name="linux-gmsa-considerations"></a>

Tenga en cuenta lo siguiente antes de usar una gMSA para contenedores de Linux:
+ Si sus contenedores se ejecutan en EC2, puede utilizar gMSA para contenedores de Windows y de Linux. Para obtener información sobre cómo utilizar el contenedor gMSA de Linux en Fargate, consulte [Uso de gMSA para contenedores de Linux en Fargate](fargate-linux-gmsa.md).
+ Puede que necesite una computadora con Windows unida al dominio para cumplir los requisitos previos. Por ejemplo, puede que necesite una computadora con Windows que esté unida al dominio para crear la gMSA en Active Directory con PowerShell. Las herramientas de PowerShell en Active Directory RSAT solo están disponibles para Windows. Para obtener más información, consulte [Instalar las herramientas de administración de Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_install_ad_tools.html).
+ Puede elegir entre **gMSA sin dominio** o **unir cada instancia a un único dominio**. Al usar una gMSA sin dominio, la instancia de contenedor no se une al dominio, las demás aplicaciones de la instancia no pueden utilizar las credenciales para acceder al dominio y las tareas que unen diferentes dominios se pueden ejecutar en la misma instancia.

  A continuación, seleccione el almacenamiento de datos para las CredSpec y, de forma opcional, para las credenciales de usuario de Active Directory para gMSA sin dominio.

  Amazon ECS utiliza un archivo de especificaciones de credenciales de Active Directory (CredSpec). Este archivo contiene los metadatos de gMSA utilizados para propagar el contexto de la cuenta de gMSA al contenedor. Genera el archivo de CredSpec y, a continuación, lo almacena en una de las opciones de almacenamiento de CredSpec de la siguiente tabla, específica del sistema operativo de las instancias de contenedor. Para usar el método sin dominio, en una sección opcional del archivo de CredSpec se pueden especificar las credenciales de una de las opciones de almacenamiento *domainless user credentials* de la siguiente tabla, específicas del sistema operativo de las instancias de contenedor.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonECS/latest/developerguide/linux-gmsa.html)

## Requisitos previos
<a name="linux-gmsa-prerequisites"></a>

Antes de utilizar la característica de gMSA para contenedores de Linux con Amazon ECS, asegúrese de completar lo siguiente:
+ Configure un dominio de Active Directory con los recursos a los que desea que accedan sus contenedores. Amazon ECS admite las siguientes configuraciones:
  + Un Directory Service Active Directory. Directory Service es un Active Directory administrado por AWS y alojado en Amazon EC2. Para obtener más información, consulte [Introducción a Microsoft AD administrado por AWS](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) en la *Guía de administración de AWS Directory Service*.
  + Un Active Directory en las instalaciones. Debe asegurarse de que la instancia de contenedor de Linux de Amazon ECS pueda unirse al dominio. Para obtener más información, consulte [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect.html).
+ Tiene una cuenta de gMSA existente en Active Directory. Para obtener más información, consulte [Uso de gMSA para contenedores de EC2 Linux en Amazon ECS](#linux-gmsa).
+ Instaló y está ejecutando el `credentials-fetcher` daemon en una instancia de contenedor Linux de Amazon ECS. También agregó un conjunto inicial de credenciales al `credentials-fetcher` daemon para autenticarse en Active Directory.
**nota**  
El `credentials-fetcher` daemon solo está disponible para Amazon Linux 2023 y Fedora 37 y versiones posteriores. El daemon no está disponible para Amazon Linux 2. Para obtener más información, consulte [aws/credentials-fetcher](https://github.com/aws/credentials-fetcher) en GitHub.
+ Configuró las credenciales para que el `credentials-fetcher` daemon se autentique en Active Directory. Las credenciales deben ser miembros del grupo de seguridad de Active Directory que tenga acceso a la cuenta de gMSA. Hay varias opciones en [Decida si quiere unir las instancias al dominio o usar gMSA sin dominio.](#linux-gmsa-initial-creds).
+ Agregó los permisos necesarios de IAM. Los permisos necesarios dependen de los métodos que elija para las credenciales iniciales y para almacenar la especificación de las credenciales:
  + Si utiliza las credenciales iniciales *sin dominio de gMSA*, se requieren permisos de IAM para AWS Secrets Manager en el rol de ejecución de tareas.
  + Si almacena la especificación de credenciales en SSM Parameter Store, se requieren permisos de IAM para Parameter Store de Amazon EC2 Systems Manager en el rol de ejecución de la tarea.
  + Si almacena la especificación de credenciales en Amazon S3, se requieren permisos de IAM para Amazon Simple Storage Service en el rol de ejecución de tareas.

## Configuración de contenedores de Linux compatibles con gMSA en Amazon ECS
<a name="linux-gmsa-setup"></a>
<a name="linux-gmsa-setup-infra"></a>
**Preparar la infraestructura**  
Los siguientes pasos son consideraciones y la configuración que se realizan una vez. Después de completar estos pasos, puede automatizar la creación de instancias de contenedores para reutilizar esta configuración.

Decida cómo se proporcionan las credenciales iniciales y configure los datos de usuario de EC2 en una plantilla de lanzamiento de EC2 reutilizable para instalar el `credentials-fetcher` daemon.

1. <a name="linux-gmsa-initial-creds"></a>

**Decida si quiere unir las instancias al dominio o usar gMSA sin dominio.**
   + <a name="linux-gmsa-initial-join"></a>

**Unir instancias de EC2 al dominio de Active Directory**

     
     + <a name="linux-gmsa-initial-join-userdata"></a>

**Una las instancias por datos de usuario.**

       Agregue los pasos para unir el dominio de Active Directory a sus datos de usuario de EC2 en una plantilla de lanzamiento de EC2. Varios grupos de Amazon EC2 Auto Scaling pueden utilizar la misma plantilla de lanzamiento.

       Puede seguir estos pasos [Unirse a un dominio FreeIPA o a Active Directory](https://docs.fedoraproject.org/en-US/quick-docs/join-active-directory-freeipa/) en los documentos de Fedora.
   + <a name="linux-gmsa-initial-domainless"></a>

**Hacer que un usuario de Active Directory sea una gMSA sin dominio**

     El `credentials-fetcher` daemon tiene una característica que se denomina *gMSA sin dominio*. Esta característica requiere un dominio, pero no es necesario unir la instancia EC2 al dominio. Al usar una gMSA sin dominio, la instancia de contenedor no se une al dominio, las demás aplicaciones de la instancia no pueden utilizar las credenciales para acceder al dominio y las tareas que unen diferentes dominios se pueden ejecutar en la misma instancia. En su lugar, debe proporcionar el nombre de un secreto en AWS Secrets Manager en el archivo de CredSpec. El secreto debe contener un nombre de usuario, una contraseña y el dominio para iniciar sesión.

     Esta característica es compatible y se puede utilizar con contenedores de Linux y Windows.

     Esta característica es similar a la característica *gMSA support for non-domain-joined container hosts*. Para obtener más información sobre la característica de Windows, consulte [Arquitectura y mejoras de gMSA](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#gmsa-architecture-and-improvements) en el sitio web de Microsoft Learn.

     1. Cree un usuario en el dominio de Active Directory. El usuario de Active Directory debe tener permiso para acceder a las cuentas de servicio de gMSA que utilice en las tareas.

     1. Cree un secreto en AWS Secrets Manager después de crear el usuario en Active Directory. 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).

     1. Introduzca el nombre de usuario, la contraseña y el dominio en pares clave-valor de JSON denominados `username`, `password` y `domainName`, respectivamente.

        ```
        {"username":"username","password":"passw0rd", "domainName":"example.com"}
        ```

     1. Agregue la configuración al archivo de CredSpec de la cuenta de servicio. La `HostAccountConfig` adicional contiene el nombre de recurso de Amazon (ARN) del secreto de Secrets Manager.

        En Windows, el `PluginGUID` debe coincidir con el GUID del siguiente fragmento de ejemplo. En Linux, se omite el `PluginGUID`. Reemplace `MySecret` con un ejemplo del nombre de recurso de Amazon (ARN) de su secreto.

        ```
            "ActiveDirectoryConfig": {
                "HostAccountConfig": {
                    "PortableCcgVersion": "1",
                    "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
                    "PluginInput": {
                        "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
                    }
                }
        ```

     1. La característica de *gMSA sin dominio* necesita permisos adicionales en el rol de ejecución de tareas. Siga el paso [(Opcional) secreto de gMSA sin dominio](#linux-gmsa-domainless-secret).

1. <a name="linux-gmsa-install"></a>

**Configurar las instancias e instalar el `credentials-fetcher` daemon**

   Puede instalar el `credentials-fetcher` daemon con un script de datos de usuario en su plantilla de lanzamiento de EC2. Los siguientes ejemplos muestran dos tipos de datos de usuario, `cloud-config` YAML o script de bash. Estos ejemplos son para Amazon Linux 2023 (AL2023). Reemplace `MyCluster` por el nombre del clúster de Amazon ECS al que desea que se unan estas instancias.
   + <a name="linux-gmsa-install-yaml"></a>

**`cloud-config` YAML**

     ```
     Content-Type: text/cloud-config
     package_reboot_if_required: true
     packages:
       # prerequisites
       - dotnet
       - realmd
       - oddjob
       - oddjob-mkhomedir
       - sssd
       - adcli
       - krb5-workstation
       - samba-common-tools
       # https://github.com/aws/credentials-fetcher gMSA credentials management for containers
       - credentials-fetcher
     write_files:
     # configure the ECS Agent to join your cluster.
     # replace MyCluster with the name of your cluster.
     - path: /etc/ecs/ecs.config
       owner: root:root
       permissions: '0644'
       content: |
         ECS_CLUSTER=MyCluster
         ECS_GMSA_SUPPORTED=true
     runcmd:
     # start the credentials-fetcher daemon and if it succeeded, make it start after every reboot
     - "systemctl start credentials-fetcher"
     - "systemctl is-active credentials-fetcher && systemctl enable credentials-fetcher"
     ```
   + <a name="linux-gmsa-install-userdata"></a>

**bash script**

     Si se siente más cómodo con scripts de bash y tiene distintas variables en las que escribir `/etc/ecs/ecs.config`, utilice el siguiente formato de `heredoc`. Este formato escribe todo entre las líneas que comienzan por **cat** y `EOF` en el archivo de configuración.

     ```
     #!/usr/bin/env bash
     set -euxo pipefail
     
     # prerequisites
     timeout 30 dnf install -y dotnet realmd oddjob oddjob-mkhomedir sssd adcli krb5-workstation samba-common-tools
     # install https://github.com/aws/credentials-fetcher gMSA credentials management for containers
     timeout 30 dnf install -y credentials-fetcher
     
     # start credentials-fetcher
     systemctl start credentials-fetcher
     systemctl is-active credentials-fetcher && systemctl enable credentials-fetcher
     
     cat <<'EOF' >> /etc/ecs/ecs.config
     ECS_CLUSTER=MyCluster
     ECS_GMSA_SUPPORTED=true
     EOF
     ```

   Hay variables de configuración opcionales para el `credentials-fetcher` daemon que puede configurar en `/etc/ecs/ecs.config`. Se recomienda configurar las variables de los datos de usuario en el bloque YAML o en `heredoc`, de forma similar a los ejemplos anteriores. De este modo, se evitan los problemas de configuración parcial que pueden producirse al editar un archivo varias veces. Para obtener más información sobre la configuración del agente de ECS, consulte [Agente de contenedor de Amazon ECS](https://github.com/aws/amazon-ecs-agent/blob/master/README.md#environment-variables) en GitHub.
   + De forma opcional, puede usar la variable `CREDENTIALS_FETCHER_HOST` si cambia la configuración del `credentials-fetcher` daemon para mover el socket a otra ubicación.

**Configuración de permisos y secretos**  
Realice los siguientes pasos una vez para cada aplicación y cada definición de tarea. Recomendamos utilizar la práctica recomendada de concesión de privilegios mínimos y reducir los permisos que se utilizan en la política. De esta forma, cada tarea solo puede leer los secretos que necesita.

1. <a name="linux-gmsa-domainless-secret"></a>

**(Opcional) secreto de gMSA sin dominio**

   Si utiliza el método sin dominio en el que la instancia no está unida al dominio, siga este paso.

   También debe agregar los siguientes permisos como una política en línea al rol de IAM de ejecución de tareas. De ese modo, el `credentials-fetcher` daemon tendrá acceso al secreto de Secrets Manager. Reemplace el ejemplo de `MySecret` con el nombre de recurso de Amazon (ARN) de su secreto en la lista de `Resource`.

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:my-secret-AbCdEf"
           }
       ]
   }
   ```

------
**nota**  
Si utiliza su propia clave de KMS para cifrar el secreto, debe agregar los permisos necesarios a este rol y agregar este rol a la política de claves de AWS KMS.

1. 

**Decidir si utilizar SSM Parameter Store o S3 para almacenar el CredSpec**

   Amazon ECS admite las siguientes formas de hacer referencia a la ruta de archivo en el campo `credentialSpecs` de una definición de tarea.

   Si une las instancias a un solo dominio, utilice el prefijo `credentialspec:` al principio del ARN de la cadena. Si utiliza la gMSA sin dominio, utilice `credentialspecdomainless:`.

   Para obtener más información sobre CredSpec, consulte [Archivo de especificaciones de credenciales](#linux-gmsa-credentialspec).
   + <a name="linux-gmsa-credspec-s3"></a>

**Bucket de Amazon S3**

     Agregue la especificación de credenciales a un bucket de Amazon S3. A continuación, haga referencia al nombre de recurso de Amazon (ARN) del bucket de Amazon S3 en el campo `credentialSpecs` de la definición de tareas.

     ```
     {
         "family": "",
         "executionRoleArn": "",
         "containerDefinitions": [
             {
                 "name": "",
                 ...
                 "credentialSpecs": [
                     "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
                 ],
                 ...
             }
         ],
         ...
     }
     ```

     Para que las tareas tengan acceso al bucket de S3, agregue los siguientes permisos como una política en línea al rol de IAM de ejecución de tareas de Amazon ECS.

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

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
         "Statement": [
             {
                 "Sid": "VisualEditor",
                 "Effect": "Allow",
                 "Action": [
                     "s3:Get*",
                     "s3:List*"
                 ],
                 "Resource": [
                     "arn:aws:s3:::amzn-s3-demo-bucket",
                     "arn:aws:s3:::amzn-s3-demo-bucket/{object}"
                 ]
             }
         ]
     }
     ```

------
   + <a name="linux-gmsa-credspec-ssm"></a>

**Parámetro de Parameter Store de SSM**

     Agregue la especificación de credenciales a un parámetro de SSM Parameter Store. A continuación, haga referencia al nombre de recurso de Amazon (ARN) del parámetro de SSM Parameter Store en el campo `credentialSpecs` de la definición de tareas.

     ```
     {
         "family": "",
         "executionRoleArn": "",
         "containerDefinitions": [
             {
                 "name": "",
                 ...
                 "credentialSpecs": [
                     "credentialspecdomainless:arn:aws:ssm:aws-region:111122223333:parameter/parameter_name"
                 ],
                 ...
             }
         ],
         ...
     }
     ```

     Para que las tareas tengan acceso al parámetro de SSM Parameter Store, agregue los siguientes permisos como una política en línea al rol de IAM de ejecución de tareas de Amazon ECS.

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

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
         "Statement": [
             {
                 "Effect": "Allow",
                 "Action": [
                     "ssm:GetParameters"
                 ],
                 "Resource": "arn:aws:ssm:us-east-1:123456789012:parameter/my-parameter"
             }
         ]
     }
     ```

------

## Archivo de especificaciones de credenciales
<a name="linux-gmsa-credentialspec"></a>

Amazon ECS utiliza un archivo de especificaciones de credenciales de Active Directory (*CredSpec*). Este archivo contiene los metadatos de gMSA utilizados para propagar el contexto de la cuenta de gMSA al contenedor de Linux. Genere las CredSpec y haga referencia a ellas en el campo `credentialSpecs` de la definición de tareas. El archivo de CredSpec no contiene ningún secreto.

A continuación se muestra un ejemplo de un archivo CredSpec.

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "example.com",
        "DnsName": "example.com",
        "NetBiosName": "example"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "example.com"
            }
        ],
        "HostAccountConfig": {
            "PortableCcgVersion": "1",
            "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
            "PluginInput": {
                "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
            }
        }
    }
}
```
<a name="linux-gmsa-credentialspec-create"></a>
**Creación de un CredSpec**  
Cree unas CredSpec utilizando el módulo PowerShell de CredSpec en una computadora con Windows que esté unida al dominio. Siga los pasos que se indican en [Crear una especificación de credenciales](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#create-a-credential-spec) en el sitio web de Microsoft Learn.

# Uso de gMSA para contenedores de Linux en Fargate
<a name="fargate-linux-gmsa"></a>

Amazon ECS admite la autenticación de Active Directory para contenedores de Linux en Fargate con un tipo especial de cuenta de servicio denominada *cuenta de servicio administrada de grupo* (gMSA).

Las aplicaciones de red basadas en Linux, como las aplicaciones .NET Core, pueden utilizar Active Directory para facilitar la administración de autorizaciones y autenticación entre usuarios y servicios. Puede utilizar esta característica diseñando aplicaciones que se integren con Active Directory y se ejecuten en servidores unidos a un dominio. Sin embargo, dado que los contenedores de Linux no se pueden unir a un dominio, debe configurar un contenedor de Linux para que se ejecute con gMSA.

## Consideraciones
<a name="fargate-linux-gmsa-considerations"></a>

Tenga en cuenta lo siguiente antes de usar gMSA para contenedores de Linux en Fargate:
+ Debe ejecutar la versión 1.4 de la plataforma o una posterior.
+ Puede que necesite una computadora con Windows unida al dominio para cumplir los requisitos previos. Por ejemplo, puede que necesite una computadora con Windows que esté unida al dominio para crear la gMSA en Active Directory con PowerShell. Las herramientas de PowerShell en Active Directory RSAT solo están disponibles para Windows. Para obtener más información, consulte [Instalar las herramientas de administración de Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_install_ad_tools.html).
+ Debe usar **gMSA sin dominio**. 

  Amazon ECS utiliza un archivo de especificaciones de credenciales de Active Directory (CredSpec). Este archivo contiene los metadatos de gMSA utilizados para propagar el contexto de la cuenta de gMSA al contenedor. Debe generar el archivo CredSpec y, a continuación, almacenarlo en un bucket de Amazon S3.
+ Una tarea solo puede admitir un Active Directory.

## Requisitos previos
<a name="fargate-linux-gmsa-prerequisites"></a>

Antes de utilizar la característica de gMSA para contenedores de Linux con Amazon ECS, asegúrese de completar lo siguiente:
+ Configure un dominio de Active Directory con los recursos a los que desea que accedan sus contenedores. Amazon ECS admite las siguientes configuraciones:
  + Un Directory Service Active Directory. Directory Service es un Active Directory administrado por AWS y alojado en Amazon EC2. Para obtener más información, consulte [Introducción a Microsoft AD administrado por AWS](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) en la *Guía de administración de AWS Directory Service*.
  + Un Active Directory en las instalaciones. Debe asegurarse de que la instancia de contenedor de Linux de Amazon ECS pueda unirse al dominio. Para obtener más información, consulte [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Debe tener una cuenta de gMSA existente en Active Directory y un usuario que tenga permiso para acceder a la cuenta de servicio gMSA. Para obtener más información, consulte [Hacer que un usuario de Active Directory sea una gMSA sin dominio](#fargate-linux-gmsa-initial-domainless).
+ Tiene un bucket de Amazon S3. Para obtener más información, consulte [Crear un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) en la *Guía del usuario de Amazon S3*.

## Configuración de contenedores de Linux compatibles con gMSA en Amazon ECS
<a name="fargate-linux-gmsa-setup"></a>
<a name="linux-gmsa-setup-infra"></a>
**Preparar la infraestructura**  
Los siguientes pasos son consideraciones y la configuración que se realizan una vez. 
+ <a name="fargate-linux-gmsa-initial-domainless"></a>

**Hacer que un usuario de Active Directory sea una gMSA sin dominio**

  Cuando se utiliza gMSA sin dominio, el contenedor no está unido al dominio. Otras aplicaciones que se ejecutan en el contenedor no pueden utilizar las credenciales para acceder al dominio. Las tareas que utilizan un dominio diferente se pueden ejecutar en el mismo contenedor. Usted proporciona el nombre de un secreto en AWS Secrets Manager en el archivo CredSpec. El secreto debe contener un nombre de usuario, una contraseña y el dominio para iniciar sesión.

  Esta característica es similar a la característica *gMSA support for non-domain-joined container hosts*. Para obtener más información sobre la característica de Windows, consulte [Arquitectura y mejoras de gMSA](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#gmsa-architecture-and-improvements) en el sitio web de Microsoft Learn.

  1. Configure un usuario en el dominio de Active Directory. El usuario de Active Directory debe tener permiso para acceder a la cuenta de servicio de gMSA que utilice en las tareas.

  1. Tiene una VPC y subredes que pueden resolver el nombre de dominio de Active Directory. Configure las opciones de VPC con DHCP con el nombre de dominio que apunta al nombre del servicio de Active Directory. Para obtener más información sobre cómo configurar opciones de DHCP para una VPC, consulte [Trabajar con los conjuntos de opciones de DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/DHCPOptionSet.html) en la *Guía del usuario de Amazon Virtual Private Cloud*.

  1. Cree un secreto en AWS Secrets Manager. 

  1. Cree el archivo de especificación de credenciales.

**Configuración de permisos y secretos**  
Siga los siguientes pasos una vez por cada aplicación y definición de tarea. Recomendamos utilizar la práctica recomendada de concesión de privilegios mínimos y reducir los permisos que se utilizan en la política. De esta forma, cada tarea solo puede leer los secretos que necesita.

1. Cree un usuario en el dominio de Active Directory. El usuario de Active Directory debe tener permiso para acceder a las cuentas de servicio de gMSA que utilice en las tareas.

1. Cree un secreto en AWS Secrets Manager después de crear el usuario en Active Directory. 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).

1. Introduzca el nombre de usuario, la contraseña y el dominio en pares clave-valor de JSON denominados `username`, `password` y `domainName`, respectivamente.

   ```
   {"username":"username","password":"passw0rd", "domainName":"example.com"}
   ```

1. <a name="fargate-linux-gmsa-domainless-secret"></a>También debe agregar los siguientes permisos como una política en línea al rol de IAM de ejecución de tareas. De ese modo, el `credentials-fetcher` daemon tendrá acceso al secreto de Secrets Manager. Reemplace el ejemplo de `MySecret` con el nombre de recurso de Amazon (ARN) de su secreto en la lista de `Resource`.

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": [
               "arn:aws:secretsmanager:us-east-1:111122223333:secret:MySecret"
               ]
           }
       ]
   }
   ```

------
**nota**  
Si utiliza su propia clave de KMS para cifrar el secreto, debe agregar los permisos necesarios a este rol y agregar este rol a la política de claves de AWS KMS.

1. <a name="linux-gmsa-credspec-ssm"></a>Agregue la especificación de credenciales a un bucket de Amazon S3. A continuación, haga referencia al nombre de recurso de Amazon (ARN) del bucket de Amazon S3 en el campo `credentialSpecs` de la definición de tareas.

   ```
   {
       "family": "",
       "executionRoleArn": "",
       "containerDefinitions": [
           {
               "name": "",
               ...
               "credentialSpecs": [
                   "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
               ],
               ...
           }
       ],
       ...
   }
   ```

   Para que las tareas tengan acceso al bucket de S3, agregue los siguientes permisos como una política en línea al rol de IAM de ejecución de tareas de Amazon ECS.

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "VisualEditor",
               "Effect": "Allow",
               "Action": [
               "s3:GetObjectVersion",
               "s3:ListBucket"
               ],
               "Resource": [
                   "arn:aws:s3:::{bucket_name}",
                   "arn:aws:s3:::{bucket_name}/{object}"
               ]
           }
       ]
   }
   ```

------

## Archivo de especificaciones de credenciales
<a name="fargate-linux-gmsa-credentialspec"></a>

Amazon ECS utiliza un archivo de especificaciones de credenciales de Active Directory (*CredSpec*). Este archivo contiene los metadatos de gMSA utilizados para propagar el contexto de la cuenta de gMSA al contenedor de Linux. Genere las CredSpec y haga referencia a ellas en el campo `credentialSpecs` de la definición de tareas. El archivo de CredSpec no contiene ningún secreto.

A continuación se muestra un ejemplo de un archivo CredSpec.

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "example.com",
        "DnsName": "example.com",
        "NetBiosName": "example"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "example.com"
            }
        ],
        "HostAccountConfig": {
            "PortableCcgVersion": "1",
            "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
            "PluginInput": {
                "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
            }
        }
    }
}
```
<a name="fargate-linux-gmsa-credentialspec-create"></a>
**Creación de CredSpec y cómo cargarlo en Amazon S3**  
Cree unas CredSpec utilizando el módulo PowerShell de CredSpec en una computadora con Windows que esté unida al dominio. Siga los pasos que se indican en [Crear una especificación de credenciales](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#create-a-credential-spec) en el sitio web de Microsoft Learn.

Tras crear el archivo de especificación de credenciales, cárguelo a un bucket de Amazon S3. Copie el archivo CredSpec en la computadora o el entorno en el que esté ejecutando los comandos de la AWS CLI.

Ejecute el siguiente comando de la AWS CLI para cargar el CredSpec a Amazon S3. Reemplace `amzn-s3-demo-bucket` con el nombre de su bucket de Amazon S3. Puede almacenar el archivo como un objeto en cualquier bucket y ubicación, pero debe permitir el acceso a ese bucket y ubicación en la política que asocie al rol de ejecución de la tarea.

Para PowerShell, use el comando siguiente:

```
$ Write-S3Object -BucketName "amzn-s3-demo-bucket" -Key "ecs-domainless-gmsa-credspec" -File "gmsa-cred-spec.json"
```

El siguiente comando de la AWS CLI utiliza caracteres de continuación con barra invertida que utilizan los intérpretes de comandos compatibles y `sh`. 

```
$ aws s3 cp gmsa-cred-spec.json \
s3://amzn-s3-demo-bucket/ecs-domainless-gmsa-credspec
```

# Uso de contenedores de Amazon ECS para Windows con gMSA sin dominio mediante la AWS CLI
<a name="tutorial-gmsa-windows"></a>

En el siguiente tutorial, se muestra cómo crear una tarea de Amazon ECS que ejecute un contenedor de Windows que tenga credenciales para acceder a Active Directory con la AWS CLI. Al usar una gMSA sin dominio, la instancia de contenedor no se une al dominio, las demás aplicaciones de la instancia no pueden utilizar las credenciales para acceder al dominio y las tareas que unen diferentes dominios se pueden ejecutar en la misma instancia.

**Topics**
+ [Requisitos previos](#tutorial-gmsa-windows-prerequisites)
+ [Paso 1: Crear y configurar la cuenta de gMSA en los servicios de dominio de Active Directory (AD DS)](#tutorial-gmsa-windows-step1)
+ [Paso 2: Cargar credenciales a Secrets Manager](#tutorial-gmsa-windows-step2)
+ [Paso 3: Modifique el JSON CredSpec para incluir información de gMSA sin dominio](#tutorial-gmsa-windows-step3)
+ [Paso 4: Cargar CredSpec a Amazon S3](#tutorial-gmsa-windows-step4)
+ [Paso 5: (Opcional) crear un clúster de Amazon ECS](#tutorial-gmsa-windows-step5)
+ [Paso 6: crear un rol de IAM para instancias de contenedor](#tutorial-gmsa-windows-step6)
+ [Paso 7: Crear un rol de ejecución de tarea personalizado](#tutorial-gmsa-windows-step7)
+ [Paso 8: crear un rol de tarea para Amazon ECS Exec](#tutorial-gmsa-windows-step8)
+ [Paso 9: Registrar una definición de tarea que utilice gMSA sin dominio](#tutorial-gmsa-windows-step9)
+ [Paso 10: Registrar una instancia de contenedor de Windows en el clúster](#tutorial-gmsa-windows-step10)
+ [Paso 11: Verificar la instancia de contenedor](#tutorial-gmsa-windows-step11)
+ [Paso 12: Ejecutar una tarea de Windows](#tutorial-gmsa-windows-step12)
+ [Paso 13: Comprobar que el contenedor tenga credenciales de gMSA](#tutorial-gmsa-windows-step13)
+ [Paso 14: Limpiar](#tutorial-gmsa-windows-step14)
+ [Depuración de gMSA sin dominio de Amazon ECS para contenedores de Windows](#tutorial-gmsa-windows-debugging)

## Requisitos previos
<a name="tutorial-gmsa-windows-prerequisites"></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).
+ Su usuario de IAM dispone de los permisos requeridos que se especifican en la política de IAM [AmazonECS\$1FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) de ejemplo.
+  La última versión de la AWS CLI está instalada y configurada. Para obtener más información acerca de cómo instalar o actualizar la AWS CLI, consulte [Instalación de la AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**nota**  
Puede utilizar puntos de conexión de servicio de doble pila para interactuar con Amazon ECS desde la AWS CLI, los SDK y la API de Amazon ECS a través de IPv4 e IPv6. Para obtener más información, consulte [Uso de puntos de conexión de doble pila en Amazon ECS](dual-stack-endpoint.md).
+ Configure un dominio de Active Directory con los recursos a los que desea que accedan sus contenedores. Amazon ECS admite las siguientes configuraciones:
  + Un Directory Service Active Directory. Directory Service es un Active Directory administrado por AWS y alojado en Amazon EC2. Para obtener más información, consulte [Introducción a Microsoft AD administrado por AWS](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) en la *Guía de administración de AWS Directory Service*.
  + Un Active Directory en las instalaciones. Debe asegurarse de que la instancia de contenedor de Linux de Amazon ECS pueda unirse al dominio. Para obtener más información, consulte [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Tiene una VPC y subredes que pueden resolver el nombre de dominio de Active Directory.
+ Puede elegir entre **gMSA sin dominio** o **unir cada instancia a un único dominio**. Al usar una gMSA sin dominio, la instancia de contenedor no se une al dominio, las demás aplicaciones de la instancia no pueden utilizar las credenciales para acceder al dominio y las tareas que unen diferentes dominios se pueden ejecutar en la misma instancia.

  A continuación, seleccione el almacenamiento de datos para las CredSpec y, de forma opcional, para las credenciales de usuario de Active Directory para gMSA sin dominio.

  Amazon ECS utiliza un archivo de especificaciones de credenciales de Active Directory (CredSpec). Este archivo contiene los metadatos de gMSA utilizados para propagar el contexto de la cuenta de gMSA al contenedor. Genera el archivo de CredSpec y, a continuación, lo almacena en una de las opciones de almacenamiento de CredSpec de la siguiente tabla, específica del sistema operativo de las instancias de contenedor. Para usar el método sin dominio, en una sección opcional del archivo de CredSpec se pueden especificar las credenciales de una de las opciones de almacenamiento *domainless user credentials* de la siguiente tabla, específicas del sistema operativo de las instancias de contenedor.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonECS/latest/developerguide/tutorial-gmsa-windows.html)
+ (Opcional) AWS CloudShell es una herramienta que proporciona a los clientes una línea de comandos sin necesidad de crear su propia instancia de EC2. Para obtener más información, consulte [¿Qué es AWS CloudShell?](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) en la *Guía del usuario de AWS CloudShell*.

## Paso 1: Crear y configurar la cuenta de gMSA en los servicios de dominio de Active Directory (AD DS)
<a name="tutorial-gmsa-windows-step1"></a>

Cree y configure una cuenta de gMSA en el dominio de Active Directory.

**nota**  
Este paso crea dos cuentas independientes: una cuenta de servicio administrada de grupo (gMSA) que proporciona la identidad para los contenedores y una cuenta de usuario normal que se utiliza para la autenticación de dominio. Estas cuentas tienen propósitos distintos y deben tener nombres distintos.

1. 

**Generar una clave raíz del servicio de distribución de claves**
**nota**  
Si utiliza Directory Service, puede omitir este paso.

   La clave raíz de KDS y los permisos de gMSA se configuran con su Microsoft AD administrado por AWS.

   Si aún no ha creado una cuenta de servicio de gMSA en su dominio, primero tendrá que generar una clave raíz del Servicio de distribución de claves (KDS). El KDS es responsable de crear, rotar y divulgar la contraseña de gMSA a los hosts autorizados. Cuando `ccg.exe` necesita recuperar las credenciales de gMSA, se pone en contacto con KDS para recuperar la contraseña actual.

   Para comprobar si la clave raíz de KDS ya se ha creado, ejecute el siguiente cmdlet de PowerShell con privilegios de administrador de dominio en un controlador de dominio mediante el módulo PowerShell de `ActiveDirectory`. Para obtener más información sobre el módulo, consulte el [Módulo de ActiveDirectory](https://learn.microsoft.com/en-us/powershell/module/activedirectory/?view=windowsserver2022-ps) en el sitio web de Microsoft Learn.

   ```
   PS C:\> Get-KdsRootKey
   ```

   Si el comando devuelve un ID de clave, puede omitir el resto de este paso. De lo contrario, cree la clave raíz de KDS mediante el siguiente comando:

   ```
   PS C:\> Add-KdsRootKey -EffectiveImmediately
   ```

   Aunque el argumento `EffectiveImmediately` al comando implica que la clave entra en vigor inmediatamente, debe esperar 10 horas antes de que la clave raíz de KDS se replique y esté disponible para su uso en todos los controladores de dominio.

1. 

**Crear la cuenta de gMSA**

   Para crear la cuenta de gMSA y permitir que `ccg.exe` recupere la contraseña de gMSA, ejecute los siguientes comandos de PowerShell desde un servidor o cliente de Windows con acceso al dominio. Sustituya `ExampleAccount` por el nombre que desee para la cuenta gMSA y sustituya `example-domain` por el nombre de su dominio de Active Directory (por ejemplo, si su dominio es `contoso.com`, utilice `contoso`).

   1. 

      ```
      PS C:\> Install-WindowsFeature RSAT-AD-PowerShell
      ```

   1. 

      ```
      PS C:\> New-ADGroup -Name "ExampleAccount Authorized Hosts" -SamAccountName "ExampleAccountHosts" -GroupScope DomainLocal
      ```

   1. 

      ```
      PS C:\> New-ADServiceAccount -Name "ExampleAccount" -DnsHostName "example-domain" -ServicePrincipalNames "host/ExampleAccount", "host/example-domain" -PrincipalsAllowedToRetrieveManagedPassword "ExampleAccountHosts"
      ```

   1. Cree un usuario con una contraseña permanente que no caduque. Estas credenciales se almacenan en AWS Secrets Manager y utilizan en cada tarea para unirse al dominio. Se trata de una cuenta de usuario independiente de la cuenta gMSA creada anteriormente. Sustituya `ExampleServiceUser` por el nombre que desee para esta cuenta de usuario de servicio.

      ```
      PS C:\> New-ADUser -Name "ExampleServiceUser" -AccountPassword (ConvertTo-SecureString -AsPlainText "Test123" -Force) -Enabled 1 -PasswordNeverExpires 1
      ```

   1. 

      ```
      PS C:\> Add-ADGroupMember -Identity "ExampleAccountHosts" -Members "ExampleServiceUser"
      ```

   1. Instale el módulo de PowerShell para crear objetos de CredSpec en Active Directory y generar el JSON CredSpec.

      ```
      PS C:\> Install-PackageProvider -Name NuGet -Force
      ```

      ```
      PS C:\> Install-Module CredentialSpec
      ```

   1. 

      ```
      PS C:\> New-CredentialSpec -AccountName ExampleAccount
      ```

1. Copie la salida JSON del comando anterior en un archivo llamado `gmsa-cred-spec.json`. Este es el archivo CredSpec. Se usa en el paso 3, [Paso 3: Modifique el JSON CredSpec para incluir información de gMSA sin dominio](#tutorial-gmsa-windows-step3).

## Paso 2: Cargar credenciales a Secrets Manager
<a name="tutorial-gmsa-windows-step2"></a>

Copie las credenciales de Active Directory en un sistema de almacenamiento de credenciales seguro para que cada tarea las recupere. Este es el método de gMSA sin dominio. Al usar una gMSA sin dominio, la instancia de contenedor no se une al dominio, las demás aplicaciones de la instancia no pueden utilizar las credenciales para acceder al dominio y las tareas que unen diferentes dominios se pueden ejecutar en la misma instancia.

En este paso se utiliza la AWS CLI. Puede ejecutar estos comandos en AWS CloudShell en el intérprete de comandos predeterminado, que es `bash`.
+ Ejecute el siguiente comando de AWS CLI y sustituya el nombre de usuario, la contraseña y el nombre de dominio por los correspondientes a su entorno. Utilice el nombre de la cuenta de usuario de servicio (no el nombre de la cuenta gMSA) como nombre de usuario. Guardar el ARN del secreto para usarlo en el siguiente paso, [Paso 3: Modifique el JSON CredSpec para incluir información de gMSA sin dominio](#tutorial-gmsa-windows-step3)

  El siguiente comando utiliza caracteres de continuación con barra invertida que utilizan los intérpretes de comandos compatibles y `sh`. No se admite este comando con PowerShell. Debe modificar el comando para usarlo con PowerShell.

  ```
  $ aws secretsmanager create-secret \
  --name gmsa-plugin-input \
  --description "Amazon ECS - gMSA Portable Identity." \
  --secret-string "{\"username\":\"ExampleServiceUser\",\"password\":\"Test123\",\"domainName\":\"contoso.com\"}"
  ```

## Paso 3: Modifique el JSON CredSpec para incluir información de gMSA sin dominio
<a name="tutorial-gmsa-windows-step3"></a>

Antes de subir las CredSpec a una de las opciones de almacenamiento, agregue información a las CredSpec con el ARN del secreto en Secrets Manager del paso anterior. Para obtener más información, consulte [Configuración de especificaciones de credenciales adicionales para el caso de uso de hosts de contenedores no unidos a un dominio](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#additional-credential-spec-configuration-for-non-domain-joined-container-host-use-case) en el sitio web de Microsoft Learn.

1. Agregue la siguiente información al archivo de CredSpec que se encuentra dentro del `ActiveDirectoryConfig`. Reemplace el ARN con el secreto de Secrets Manager del paso anterior.

   Tenga en cuenta que el valor de `PluginGUID` debe coincidir con el GUID del siguiente fragmento de ejemplo y es obligatorio.

   ```
   "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
   ```

   También puede utilizar un secreto en SSM Parameter Store mediante el ARN en este formato: `\"arn:aws:ssm:aws-region:111122223333:parameter/gmsa-plugin-input\"`.

1. Tras modificar el archivo de CredSpec, tendrá un aspecto semejante al de este ejemplo:

   ```
   {
     "CmsPlugins": [
       "ActiveDirectory"
     ],
     "DomainJoinConfig": {
       "Sid": "S-1-5-21-4066351383-705263209-1606769140",
       "MachineAccountName": "ExampleAccount",
       "Guid": "ac822f13-583e-49f7-aa7b-284f9a8c97b6",
       "DnsTreeName": "example-domain",
       "DnsName": "example-domain",
       "NetBiosName": "example-domain"
     },
     "ActiveDirectoryConfig": {
       "GroupManagedServiceAccounts": [
         {
           "Name": "ExampleAccount",
           "Scope": "example-domain"
         },
         {
           "Name": "ExampleAccount",
           "Scope": "example-domain"
         }
       ],
       "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
     }
   }
   ```

## Paso 4: Cargar CredSpec a Amazon S3
<a name="tutorial-gmsa-windows-step4"></a>



En este paso se utiliza la AWS CLI. Puede ejecutar estos comandos en AWS CloudShell en el intérprete de comandos predeterminado, que es `bash`.

1. Copie el archivo CredSpec en la computadora o el entorno en el que esté ejecutando los comandos de la AWS CLI.

1. Ejecute el siguiente comando de la AWS CLI para cargar el CredSpec a Amazon S3. Reemplace `MyBucket` con el nombre de su bucket de Amazon S3. Puede almacenar el archivo como un objeto en cualquier bucket y ubicación, pero debe permitir el acceso a ese bucket y ubicación en la política que asocie al rol de ejecución de la tarea.

   El siguiente comando utiliza caracteres de continuación con barra invertida que utilizan los intérpretes de comandos compatibles y `sh`. No se admite este comando con PowerShell. Debe modificar el comando para usarlo con PowerShell.

   ```
   $ aws s3 cp gmsa-cred-spec.json \
   s3://MyBucket/ecs-domainless-gmsa-credspec
   ```

## Paso 5: (Opcional) crear un clúster de Amazon ECS
<a name="tutorial-gmsa-windows-step5"></a>

De forma predeterminada, su cuenta tiene un clúster de Amazon ECS denominado `default`. Este clúster se utiliza de forma predeterminada en AWS CLI, los SDK y CloudFormation. Puede utilizar clústeres adicionales para agrupar y organizar las tareas y la infraestructura, y asignar valores predeterminados para algunas configuraciones.

Puede crear un clúster con la Consola de administración de AWS, la AWS CLI, los SDK o CloudFormation. Los ajustes y la configuración del clúster no afectan gMSA.

En este paso se utiliza la AWS CLI. Puede ejecutar estos comandos en AWS CloudShell en el intérprete de comandos predeterminado, que es `bash`.

```
$ aws ecs create-cluster --cluster-name windows-domainless-gmsa-cluster
```

**importante**  
Si decide crear su propio clúster, debe especificar `--cluster clusterName` para cada comando que pretenda utilizar con dicho clúster.

## Paso 6: crear un rol de IAM para instancias de contenedor
<a name="tutorial-gmsa-windows-step6"></a>

Una *instancia de contenedor* es una computadora host para ejecutar contenedores en tareas de ECS, por ejemplo, instancias de Amazon EC2. Cada instancia de contenedor se registra en un clúster de Amazon ECS. Antes de lanzar instancias de Amazon EC2 y registrarlas en un clúster, debe crear un rol de IAM para que lo utilicen las instancias de contenedor.

Para crear el rol de instancia de contenedor, consulte [Rol de IAM de instancia de contenedor de Amazon ECS](instance_IAM_role.md). La opción predeterminada `ecsInstanceRole` tiene permisos suficientes para completar este tutorial.

## Paso 7: Crear un rol de ejecución de tarea personalizado
<a name="tutorial-gmsa-windows-step7"></a>

Amazon ECS puede usar un rol de IAM diferente para los permisos necesarios para iniciar cada tarea, en lugar del rol de instancia de contenedor. Este rol se denomina *rol de ejecución de tareas*. Recomendamos crear un rol de ejecución de tareas con solo los permisos necesarios para que ECS ejecute la tarea, también conocidos como *permisos con privilegios mínimos*. Para obtener más información sobre el principio de privilegios mínimos, consulte [SEC03-BP02 Conceder acceso con privilegios mínimos](https://docs.aws.amazon.com/wellarchitected/latest/framework/sec_permissions_least_privileges.html) en el *AWS Well-Architected Framework*.

1. Para crear un rol de ejecución de tareas, consulte [Creación del rol de de ejecución de tareas](task_execution_IAM_role.md#create-task-execution-role). Los permisos predeterminados permiten a la instancia de contenedor extraer imágenes de contenedores de Amazon Elastic Container Registry y `stdout` y `stderr` de sus aplicaciones para registrarlas en registros de Amazon CloudWatch.

   Como el rol necesita permisos personalizados para este tutorial, puede asignarle un nombre diferente al de `ecsTaskExecutionRole`. Este tutorial utiliza `ecsTaskExecutionRole` en otros pasos.

1. Agregue los siguientes permisos creando una política personalizada, ya sea una política en línea que solo exista para este rol o una política que pueda reutilizar. Sustituya el ARN con el `Resource` en la primera declaración con el bucket y la ubicación de Amazon S3, y el segundo `Resource` con el ARN del secreto de Secrets Manager.

   Si cifra el secreto en Secrets Manager con una clave personalizada, también debe permitir `kms:Decrypt` para la clave.

   Si utiliza SSM Parameter Store en lugar de Secrets Manager, debe permitir `ssm:GetParameter` para el parámetro, en lugar de `secretsmanager:GetSecretValue`.

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject"
               ],
               "Resource": "arn:aws:s3:::MyBucket/ecs-domainless-gmsa-credspec/gmsa-cred-spec.json"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:gmsa-plugin-AbCdEf"
           }
       ]
   }
   ```

------

## Paso 8: crear un rol de tarea para Amazon ECS Exec
<a name="tutorial-gmsa-windows-step8"></a>

En este tutorial, se utiliza Amazon ECS Exec para verificar la funcionalidad mediante la ejecución de un comando dentro de una tarea en ejecución. Para usar ECS Exec, el servicio o la tarea debe activar ECS Exec y el rol de la tarea (pero no el rol de ejecución de la tarea) debe tener permisos de `ssmmessages`. Para obtener información sobre la política de IAM necesaria, consulte [Permisos de ECS Exec](task-iam-roles.md#ecs-exec-required-iam-permissions).

En este paso se utiliza la AWS CLI. Puede ejecutar estos comandos en AWS CloudShell en el intérprete de comandos predeterminado, que es `bash`.

Para crear un rol de tarea mediante la AWS CLI, siga estos pasos.

1. Cree un archivo denominado `ecs-tasks-trust-policy.json` con el siguiente contenido:

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Service": "ecs-tasks.amazonaws.com"
               },
               "Action": "sts:AssumeRole"
           }
       ]
   }
   ```

------

1. Crear un rol de IAM. Puede reemplazar el nombre `ecs-exec-demo-task-role`, pero consérvelo para los siguientes pasos.

   El siguiente comando utiliza caracteres de continuación con barra invertida que utilizan los intérpretes de comandos compatibles y `sh`. No se admite este comando con PowerShell. Debe modificar el comando para usarlo con PowerShell.

   ```
   $ aws iam create-role --role-name ecs-exec-demo-task-role \
   --assume-role-policy-document file://ecs-tasks-trust-policy.json
   ```

   Puede eliminar el archivo `ecs-tasks-trust-policy.json`.

1. Cree un archivo denominado `ecs-exec-demo-task-role-policy.json` con el siguiente contenido:

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "ssmmessages:CreateControlChannel",
                   "ssmmessages:CreateDataChannel",
                   "ssmmessages:OpenControlChannel",
                   "ssmmessages:OpenDataChannel"
               ],
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Cree una política de IAM y asóciela al rol del paso anterior.

   El siguiente comando utiliza caracteres de continuación con barra invertida que utilizan los intérpretes de comandos compatibles y `sh`. No se admite este comando con PowerShell. Debe modificar el comando para usarlo con PowerShell.

   ```
   $ aws iam put-role-policy \
       --role-name ecs-exec-demo-task-role \
       --policy-name ecs-exec-demo-task-role-policy \
       --policy-document file://ecs-exec-demo-task-role-policy.json
   ```

   Puede eliminar el archivo `ecs-exec-demo-task-role-policy.json`.

## Paso 9: Registrar una definición de tarea que utilice gMSA sin dominio
<a name="tutorial-gmsa-windows-step9"></a>



En este paso se utiliza la AWS CLI. Puede ejecutar estos comandos en AWS CloudShell en el intérprete de comandos predeterminado, que es `bash`.

1. Cree un archivo denominado `windows-gmsa-domainless-task-def.json` con el siguiente contenido:

   ```
   {
     "family": "windows-gmsa-domainless-task",
     "containerDefinitions": [
       {
         "name": "windows_sample_app",
         "image": "mcr.microsoft.com/windows/servercore/iis",
         "cpu": 1024,
         "memory": 1024,
         "essential": true,
         "credentialSpecs": [
                   "credentialspecdomainless:arn:aws:s3:::ecs-domainless-gmsa-credspec/gmsa-cred-spec.json"
         ],
         "entryPoint": [
           "powershell",
           "-Command"
         ],
         "command": [
           "New-Item -Path C:\\inetpub\\wwwroot\\index.html -ItemType file -Value '<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>' -Force ; C:\\ServiceMonitor.exe w3svc"
         ],
         "portMappings": [
           {
             "protocol": "tcp",
             "containerPort": 80,
             "hostPort": 8080
           }
         ]
       }
     ],
     "taskRoleArn": "arn:aws:iam::111122223333:role/ecs-exec-demo-task-role",
     "executionRoleArn": "arn:aws:iam::111122223333:role/ecsTaskExecutionRole"
   }
   ```

1. Registre la definición de tarea ejecutando el siguiente comando:

   El siguiente comando utiliza caracteres de continuación con barra invertida que utilizan los intérpretes de comandos compatibles y `sh`. No se admite este comando con PowerShell. Debe modificar el comando para usarlo con PowerShell.

   ```
   $ aws ecs register-task-definition \
   --cli-input-json file://windows-gmsa-domainless-task-def.json
   ```

## Paso 10: Registrar una instancia de contenedor de Windows en el clúster
<a name="tutorial-gmsa-windows-step10"></a>

Lance una instancia de Amazon EC2 para Windows y ejecute el agente de contenedor de ECS para registrarla como instancia de contenedor en el clúster. ECS ejecuta las tareas en las instancias de contenedor que están registradas en el clúster en el que se inician las tareas.

1. Para lanzar una instancia de Amazon EC2 para Windows que esté configurada para Amazon ECS en la Consola de administración de AWS, consulte [Lanzamiento de una instancia de contenedor de Windows de Amazon ECS](launch_window-container_instance.md). Deténgase en el paso correspondiente a los *datos de usuario*.

1. Para gMSA, los datos del usuario deben configurar la variable de entorno `ECS_GMSA_SUPPORTED` antes de iniciar el agente de contenedor de ECS.

   En el caso de ECS Exec, el agente debe empezar con el argumento `-EnableTaskIAMRole`.

   Para proteger el rol de IAM de la instancia impidiendo que las tareas lleguen al servicio web IMDS de EC2 para recuperar las credenciales del rol, agregue el argumento `-AwsvpcBlockIMDS`. Esto solo se aplica a las tareas que utilizan el modo de red de `awsvpc`.

   ```
   <powershell>
   [Environment]::SetEnvironmentVariable("ECS_GMSA_SUPPORTED", $TRUE, "Machine")
   Import-Module ECSTools
   Initialize-ECSAgent -Cluster windows-domainless-gmsa-cluster -EnableTaskIAMRole -AwsvpcBlockIMDS
   </powershell>
   ```

1. Revise un resumen de la configuración de su instancia en el panel **Summary** (Resumen); cuando haya terminado, elija **Launch instance**.

## Paso 11: Verificar la instancia de contenedor
<a name="tutorial-gmsa-windows-step11"></a>

Puede comprobar que hay una instancia de contenedor en el clúster mediante la Consola de administración de AWS. Sin embargo, gMSA necesita otras características que se indican como *atributos*. Estos atributos no están visibles en la Consola de administración de AWS, por lo que en este tutorial se utiliza la AWS CLI.

En este paso se utiliza la AWS CLI. Puede ejecutar estos comandos en AWS CloudShell en el intérprete de comandos predeterminado, que es `bash`.

1. Haga una lista de las instancias de contenedor del clúster. Las instancias de contenedor tienen un ID diferente del ID de la instancia de EC2.

   ```
   $ aws ecs list-container-instances
   ```

   Salida:

   ```
   {
       "containerInstanceArns": [
           "arn:aws:ecs:aws-region:111122223333:container-instance/default/MyContainerInstanceID"
       ]
   }
   ```

   Por ejemplo, `526bd5d0ced448a788768334e79010fd` es un ID de instancia de contenedor válido.

1. Utilice el ID de instancia de contenedor del paso anterior para obtener los detalles de la instancia de contenedor. Reemplace `MyContainerInstanceID` por el ID.

   El siguiente comando utiliza caracteres de continuación con barra invertida que utilizan los intérpretes de comandos compatibles y `sh`. No se admite este comando con PowerShell. Debe modificar el comando para usarlo con PowerShell.

   ```
   $ aws ecs describe-container-instances \
        ----container-instances MyContainerInstanceID
   ```

   Tenga en cuenta que el resultado es muy largo.

1. Compruebe que la lista de `attributes` tenga un objeto con la clave llamado `name` y un valor `ecs.capability.gmsa-domainless`. A continuación, se muestra un ejemplo del objeto.

   Salida:

   ```
   {
       "name": "ecs.capability.gmsa-domainless"
   }
   ```

## Paso 12: Ejecutar una tarea de Windows
<a name="tutorial-gmsa-windows-step12"></a>

Ejecute una tarea de Amazon ECS. Si solo hay una instancia de contenedor en el clúster, puede usar `run-task`. Si hay muchas instancias de contenedor diferentes, puede ser más fácil utilizar `start-task` y especificar el ID de la instancia de contenedor en la que ejecutará la tarea, antes que agregar restricciones de ubicación a la definición de la tarea para controlar en qué tipo de instancia de contenedor se va a ejecutar la tarea.

En este paso se utiliza la AWS CLI. Puede ejecutar estos comandos en AWS CloudShell en el intérprete de comandos predeterminado, que es `bash`.

1. 

   El siguiente comando utiliza caracteres de continuación con barra invertida que utilizan los intérpretes de comandos compatibles y `sh`. No se admite este comando con PowerShell. Debe modificar el comando para usarlo con PowerShell.

   ```
   aws ecs run-task --task-definition windows-gmsa-domainless-task \
       --enable-execute-command --cluster windows-domainless-gmsa-cluster
   ```

   Tenga en cuenta el ID de la tarea que devuelve el comando.

1. Ejecute el siguiente comando para comprobar que la tarea ha comenzado. Este comando espera y no devuelve el indicador del intérprete de comandos hasta que se inicie la tarea. Sustituya `MyTaskID` por el ID de la tarea del paso anterior.

   ```
   $ aws ecs wait tasks-running --task MyTaskID
   ```

## Paso 13: Comprobar que el contenedor tenga credenciales de gMSA
<a name="tutorial-gmsa-windows-step13"></a>

Compruebe que el contenedor de la tarea tenga un token Kerberos. gMSA 

En este paso se utiliza la AWS CLI. Puede ejecutar estos comandos en AWS CloudShell en el intérprete de comandos predeterminado, que es `bash`.

1. 

   El siguiente comando utiliza caracteres de continuación con barra invertida que utilizan los intérpretes de comandos compatibles y `sh`. No se admite este comando con PowerShell. Debe modificar el comando para usarlo con PowerShell.

   ```
   $ aws ecs execute-command \
   --task MyTaskID \
   --container windows_sample_app \
   --interactive \
   --command powershell.exe
   ```

   El resultado será un indicador de PowerShell.

1. Ejecute el siguiente comando en la terminal de PowerShell dentro del contenedor.

   ```
   PS C:\> klist get ExampleAccount$
   ```

   En la salida, tenga en cuenta que `Principal` es la que creó anteriormente.

## Paso 14: Limpiar
<a name="tutorial-gmsa-windows-step14"></a>

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

En este paso se utiliza la AWS CLI. Puede ejecutar estos comandos en AWS CloudShell en el intérprete de comandos predeterminado, que es `bash`.

1. Detenga la tarea. Sustituya `MyTaskID` por el ID de la tarea del paso 12, [Paso 12: Ejecutar una tarea de Windows](#tutorial-gmsa-windows-step12).

   ```
   $ aws ecs stop-task --task MyTaskID
   ```

1. Termine la instancia de Amazon EC2. Después, la instancia de contenedor del clúster se eliminará automáticamente al cabo de una hora.

   Puede buscar y terminar la instancia con la consola de Amazon EC2. O bien, puede ejecutar el siguiente comando. Para ejecutar el comando, busque el ID de instancia de EC2 en el resultado del comando `aws ecs describe-container-instances` del paso 1, [Paso 11: Verificar la instancia de contenedor](#tutorial-gmsa-windows-step11). El ID i-10a64379 es un ejemplo de un ID de instancia de EC2.

   ```
   $ aws ec2 terminate-instances --instance-ids MyInstanceID
   ```

1. Elimine el archivo CredSpec en Amazon S3. Reemplace `MyBucket` con el nombre de su bucket de Amazon S3.

   ```
   $ aws s3api delete-object --bucket MyBucket --key ecs-domainless-gmsa-credspec/gmsa-cred-spec.json
   ```

1. Elimine el secreto de Secrets Manager. Si utilizó SSM Parameter Store en su lugar, elimine el parámetro.

   El siguiente comando utiliza caracteres de continuación con barra invertida que utilizan los intérpretes de comandos compatibles y `sh`. No se admite este comando con PowerShell. Debe modificar el comando para usarlo con PowerShell.

   ```
   $ aws secretsmanager delete-secret --secret-id gmsa-plugin-input \
        --force-delete-without-recovery
   ```

1. Anule el registro y elimine la definición de tarea. Al anular el registro de la definición de tarea, se marca como inactiva para que no se pueda utilizar para iniciar nuevas tareas. A continuación, puede eliminar la definición de tarea.

   1. Anule el registro de la definición de la tarea especificando la versión. ECS crea automáticamente versiones de las definiciones de tareas, numeradas a partir del 1. Se hace referencia a las versiones en el mismo formato que las etiquetas de las imágenes de los contenedores, por ejemplo `:1`.

      ```
      $ aws ecs deregister-task-definition --task-definition windows-gmsa-domainless-task:1
      ```

   1. Elimine la definición de tareas.

      ```
      $ aws ecs delete-task-definitions --task-definition windows-gmsa-domainless-task:1
      ```

1. (Opcional) Elimine el clúster de ECS si creó un clúster.

   ```
   $ aws ecs delete-cluster --cluster windows-domainless-gmsa-cluster
   ```

## Depuración de gMSA sin dominio de Amazon ECS para contenedores de Windows
<a name="tutorial-gmsa-windows-debugging"></a>



Estado de tarea de Amazon ECS  
ECS intenta iniciar una tarea exactamente una vez. Cualquier tarea que tenga un problema se detiene y se establece en el estado `STOPPED`. Hay dos tipos comunes de problemas con las tareas. En primer lugar, las tareas que no se pudieron iniciar. En segundo lugar, las tareas en las que la aplicación se ha detenido dentro de uno de los contenedores. En la Consola de administración de AWS, observe el campo **Motivo de la detención** de la tarea y busque el motivo por el que se detuvo la tarea. En la AWS CLI, describa la tarea y observe el `stoppedReason`. Para ver los pasos a seguir en laConsola de administración de AWS y AWS CLI, consulte [Visualización de los errores de las tareas detenidas de Amazon ECS](stopped-task-errors.md).

Eventos de Windows  
Los eventos de Windows para gMSA que se encuentran en contenedores se registran en el archivo de registro de `Microsoft-Windows-Containers-CCG` y se encuentran en el Visor de eventos, en la sección Aplicaciones y servicios de `Logs\Microsoft\Windows\Containers-CCG\Admin`. Para obtener más consejos de depuración, consulte [Solución de problemas de gMSA para contenedores de Windows](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/gmsa-troubleshooting#non-domain-joined-container-hosts-use-event-logs-to-identify-configuration-issues) en el sitio web de Microsoft Learn.

Complemento de gMSA para agente de ECS  
El registro del complemento de gMSA para el agente de ECS en la instancia de contenedor de Windows se encuentra en el siguiente directorio, `C:/ProgramData/Amazon/gmsa-plugin/`. Consulte este registro para comprobar si las credenciales de usuario sin dominio se descargaron de la ubicación de almacenamiento, como Secrets Manager, y si el formato de la credencial se leyó correctamente.

# Obtenga información sobre cómo utilizar gMSA para contenedores de EC2 para Windows en Amazon ECS.
<a name="windows-gmsa"></a>

Amazon ECS admite la autenticación de Active Directory para contenedores de Windows a través de un tipo especial de cuenta de servicio denominada *cuenta de servicio administrada de grupo* (gMSA).

Las aplicaciones de red basadas en Windows, como las aplicaciones .NET, suelen utilizar Active Directory para facilitar la gestión de autorizaciones y la autenticación entre usuarios y servicios. Normalmente, los desarrolladores diseñan sus aplicaciones para que se integren con Active Directory y se ejecuten en servidores unidos a dominios para este propósito. Dado que los contenedores de Windows no se pueden unir a un dominio, debe configurar un contenedor de Windows para que se ejecute con gMSA.

Un contenedor de Windows que se ejecuta con gMSA depende de su instancia de Amazon EC2 host para recuperar las credenciales de gMSA del controlador de dominio de Active Directory y proporcionárselas a la instancia de contenedor. Para obtener más información, consulte [Crear GMSA para contenedores de Windows](https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts).

**nota**  
Esta característica no es compatible con los contenedores de Windows de Fargate.

**Topics**
+ [Consideraciones](#windows-gmsa-considerations)
+ [Requisitos previos](#windows-gmsa-prerequisites)
+ [Configuración de gMSA para contenedores de Windows en Amazon ECS](#windows-gmsa-setup)

## Consideraciones
<a name="windows-gmsa-considerations"></a>

Cuando se utilizan gMSA para contenedores de Windows, se debe tener en cuenta lo siguiente:
+ Al utilizar la AMI de Windows Server 2016 Full optimizada para Amazon ECS para las instancias de contenedor, el nombre de host del contenedor debe ser el mismo que el nombre de cuenta de gMSA definido en el archivo de especificación de credenciales. Para especificar un nombre de host para un contenedor, utilice el parámetro `hostname` de definición de contenedor. Para obtener más información, consulte [Configuración de red](task_definition_parameters.md#container_definition_network).
+ Puede elegir entre **gMSA sin dominio** o **unir cada instancia a un único dominio**. Al usar una gMSA sin dominio, la instancia de contenedor no se une al dominio, las demás aplicaciones de la instancia no pueden utilizar las credenciales para acceder al dominio y las tareas que unen diferentes dominios se pueden ejecutar en la misma instancia.

  A continuación, seleccione el almacenamiento de datos para las CredSpec y, de forma opcional, para las credenciales de usuario de Active Directory para gMSA sin dominio.

  Amazon ECS utiliza un archivo de especificaciones de credenciales de Active Directory (CredSpec). Este archivo contiene los metadatos de gMSA utilizados para propagar el contexto de la cuenta de gMSA al contenedor. Genera el archivo de CredSpec y, a continuación, lo almacena en una de las opciones de almacenamiento de CredSpec de la siguiente tabla, específica del sistema operativo de las instancias de contenedor. Para usar el método sin dominio, en una sección opcional del archivo de CredSpec se pueden especificar las credenciales de una de las opciones de almacenamiento *domainless user credentials* de la siguiente tabla, específicas del sistema operativo de las instancias de contenedor.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonECS/latest/developerguide/windows-gmsa.html)

## Requisitos previos
<a name="windows-gmsa-prerequisites"></a>

Antes de utilizar la característica de gMSA para contenedores de Windows con Amazon ECS, asegúrese de completar lo siguiente:
+ Configure un dominio de Active Directory con los recursos a los que desea que accedan sus contenedores. Amazon ECS admite las siguientes configuraciones:
  + Un Directory Service Active Directory. Directory Service es un Active Directory administrado por AWS y alojado en Amazon EC2. Para obtener más información, consulte [Introducción a Microsoft AD administrado por AWS](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) en la *Guía de administración de AWS Directory Service*.
  + Un Active Directory en las instalaciones. Debe asegurarse de que la instancia de contenedor de Linux de Amazon ECS pueda unirse al dominio. Para obtener más información, consulte [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Tiene una cuenta de gMSA existente en Active Directory. Para obtener más información, consulte [Crear GMSA para contenedores de Windows](https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts).
+ **Eligió utilizar *gMSA sin dominio* o la instancia de contenedor de Windows de Amazon ECS en la que se aloja la tarea de Amazon ECS que debe ser un *dominio unido* a Active Directory y ser miembro del grupo de seguridad de Active Directory que tenga acceso a la cuenta de gMSA.**

  Al usar una gMSA sin dominio, la instancia de contenedor no se une al dominio, las demás aplicaciones de la instancia no pueden utilizar las credenciales para acceder al dominio y las tareas que unen diferentes dominios se pueden ejecutar en la misma instancia.
+ Agregó los permisos necesarios de IAM. Los permisos necesarios dependen de los métodos que elija para las credenciales iniciales y para almacenar la especificación de las credenciales:
  + Si utiliza las *gMSA sin dominio* para credenciales iniciales, se requieren permisos de IAM para AWS Secrets Manager en el rol de instancias de Amazon EC2.
  + Si almacena la especificación de credenciales en SSM Parameter Store, se requieren permisos de IAM para Parameter Store de Amazon EC2 Systems Manager en el rol de ejecución de la tarea.
  + Si almacena la especificación de credenciales en Amazon S3, se requieren permisos de IAM para Amazon Simple Storage Service en el rol de ejecución de tareas.

## Configuración de gMSA para contenedores de Windows en Amazon ECS
<a name="windows-gmsa-setup"></a>

Para configurar gMSA para contenedores de Windows en Amazon ECS, puede seguir el tutorial completo que incluye la configuración de los requisitos previos [Uso de contenedores de Amazon ECS para Windows con gMSA sin dominio mediante la AWS CLI](tutorial-gmsa-windows.md).

En las siguientes secciones, se describe la configuración de CredSpec en detalle.

**Topics**
+ [Ejemplo CredSpec](#windows-gmsa-example)
+ [Configuración de gMSA sin dominio](#windows-gmsa-domainless)
+ [Cómo hacer referencia a un archivo de especificación de credenciales en una definición de tareas](#windows-gmsa-credentialspec)

### Ejemplo CredSpec
<a name="windows-gmsa-example"></a>

Amazon ECS utiliza un archivo de especificación de credenciales que contiene los metadatos de gMSA utilizados para propagar el contexto de la cuenta de gMSA al contenedor de Windows. Puede generar el archivo de especificación de credenciales y hacer referencia a él en el campo `credentialSpec` de la definición de tareas. El archivo de especificación de credenciales no contiene ningún secreto.

A continuación se muestra un ejemplo de archivo de especificación de credenciales:

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "contoso.com",
        "DnsName": "contoso.com",
        "NetBiosName": "contoso"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "contoso.com"
            }
        ]
    }
}
```

### Configuración de gMSA sin dominio
<a name="windows-gmsa-domainless"></a>

Recomendamos gMSA sin dominio en lugar de unir las instancias de contenedor a un solo dominio. Al usar una gMSA sin dominio, la instancia de contenedor no se une al dominio, las demás aplicaciones de la instancia no pueden utilizar las credenciales para acceder al dominio y las tareas que unen diferentes dominios se pueden ejecutar en la misma instancia.

1. Antes de subir las CredSpec a una de las opciones de almacenamiento, agregue información a las CredSpec con el ARN del secreto en Secrets Manager o en SSM Parameter Store. Para obtener más información, consulte [Configuración de especificaciones de credenciales adicionales para el caso de uso de hosts de contenedores no unidos a un dominio](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#additional-credential-spec-configuration-for-non-domain-joined-container-host-use-case) en el sitio web de Microsoft Learn.

**Formato de credenciales de gMSA sin dominio**  
El siguiente es el formato JSON para las credenciales de gMSA sin dominio de Active Directory. Almacene las credenciales en Secrets Manager o SSM Parameter Store.

   ```
   {
       "username":"WebApp01",
       "password":"Test123!",
       "domainName":"contoso.com"
   }
   ```

1. Agregue la siguiente información al archivo de CredSpec que se encuentra dentro del `ActiveDirectoryConfig`. Sustituya el ARN por el secreto en Secrets Manager o SSM Parameter Store.

   Tenga en cuenta que el valor de `PluginGUID` debe coincidir con el GUID del siguiente fragmento de ejemplo y es obligatorio.

   ```
       "HostAccountConfig": {
           "PortableCcgVersion": "1",
           "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
           "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
   ```

   También puede utilizar un secreto en SSM Parameter Store mediante el ARN en este formato: `\"arn:aws:ssm:aws-region:111122223333:parameter/gmsa-plugin-input\"`.

1. Tras modificar el archivo de CredSpec, tendrá un aspecto semejante al de este ejemplo:

   ```
   {
     "CmsPlugins": [
       "ActiveDirectory"
     ],
     "DomainJoinConfig": {
       "Sid": "S-1-5-21-4066351383-705263209-1606769140",
       "MachineAccountName": "WebApp01",
       "Guid": "ac822f13-583e-49f7-aa7b-284f9a8c97b6",
       "DnsTreeName": "contoso",
       "DnsName": "contoso",
       "NetBiosName": "contoso"
     },
     "ActiveDirectoryConfig": {
       "GroupManagedServiceAccounts": [
         {
           "Name": "WebApp01",
           "Scope": "contoso"
         },
         {
           "Name": "WebApp01",
           "Scope": "contoso"
         }
       ],
       "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
     }
   }
   ```

### Cómo hacer referencia a un archivo de especificación de credenciales en una definición de tareas
<a name="windows-gmsa-credentialspec"></a>

Amazon ECS admite las siguientes formas de hacer referencia a la ruta de archivo en el campo `credentialSpecs` de una definición de tarea. Para cada una de estas opciones, puede proporcionar `credentialspec:` o `domainlesscredentialspec:`, en función de si va a unir las instancias de contenedor a un único dominio o si va a utilizar gMSA sin dominio, respectivamente.

#### Bucket de Amazon S3
<a name="gmsa-credspec-s3"></a>

Agregue la especificación de credenciales a un bucket de Amazon S3 y, a continuación, haga referencia al nombre de recurso de Amazon (ARN) del bucket de Amazon S3 en el campo `credentialSpecs` de la definición de tareas.

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
            ],
            ...
        }
    ],
    ...
}
```

También debe agregar los siguientes permisos como una política en línea al rol de IAM de ejecución de tareas de Amazon ECS, de modo que las tareas puedan obtener acceso al bucket de Amazon S3.

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "VisualEditor",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::{bucket_name}",
                "arn:aws:s3:::{bucket_name}/{object}"
            ]
        }
    ]
}
```

------

#### Parámetro de Parameter Store de SSM
<a name="gmsa-credspec-ssm"></a>

Agregue la especificación de credenciales a un parámetro de Parameter Store de SSM. A continuación, haga referencia al nombre de recurso de Amazon (ARN) del parámetro de Parameter Store de SSM en el campo `credentialSpecs` de la definición de tareas.

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspecdomainless:arn:aws:ssm:region:111122223333:parameter/parameter_name"
            ],
            ...
        }
    ],
    ...
}
```

También debe agregar los siguientes permisos como una política en línea al rol de IAM de ejecución de tareas de Amazon ECS, para que las tareas puedan obtener acceso al parámetro de Parameter Store de SSM.

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ssm:GetParameters"
            ],
            "Resource": "arn:aws:ssm:*:111122223333:parameter/example*"
        }
    ]
}
```

------

#### Archivo local
<a name="gmsa-credspec-file"></a>

Con los detalles de especificación de credenciales en un archivo local, haga referencia a la ruta del archivo en el campo `credentialSpecs` de la definición de tareas. La ruta del archivo al que se hace referencia debe ser relativa al directorio `C:\ProgramData\Docker\CredentialSpecs` y usar la barra invertida (“\$1”) como separador de la ruta del archivo.

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspec:file://CredentialSpecDir\CredentialSpecFile.json"
            ],
            ...
        }
    ],
    ...
}
```

# Uso del Generador de imágenes de EC2 para crear AMI personalizadas optimizadas para Amazon ECS
<a name="image-builder-tutorial"></a>

AWS recomienda utilizar las AMI optimizadas para Amazon ECS, ya que están preconfiguradas con estos requisitos y recomendaciones para ejecutar sus cargas de trabajo de contenedor. Es posible que en ocasiones necesite personalizar la AMI para agregar software adicional. Puede utilizar el Generador de imágenes de EC2 para la creación, administración e implementación de sus imágenes de servidor. Retiene la propiedad de las imágenes personalizadas creadas en su cuenta. Puede utilizar las canalizaciones del Generador de imágenes de EC2 para automatizar las actualizaciones y los parches del sistema para sus imágenes o puede utilizar un comando independiente para crear una imagen con los recursos de configuración definidos.

Usted crea una receta para su imagen. La receta incluye una imagen principal y cualquier componente adicional. También crea una canalización que distribuye su AMI personalizada.

Usted crea una receta para su imagen. Una receta de imagen de Generador de Imágenes es un documento que define la imagen base y los componentes que se aplicarán a la imagen base para producir la configuración deseada de la imagen AMI de salida. También crea una canalización que distribuye su AMI personalizada. Para obtener más información, consulte [How EC2 Image Builder works](https://docs.aws.amazon.com/imagebuilder/latest/userguide/how-image-builder-works.html) en la *Guía del usuario del Generador de imágenes de EC2*.

Se recomienda que utilice una de las siguientes AMI optimizadas para Amazon ECS como “imagen principal” en el Generador de imágenes de EC2:
+ Linux
  + AL2023 x86 optimizada para Amazon ECS
  + AMI de Amazon Linux 2023 (arm64) optimizada para Amazon ECS
  + AMI de Amazon Linux 2 con kernel 5 optimizada para Amazon ECS
  + AMI de Amazon Linux 2 x86 optimizada para Amazon ECS
+ Windows
  + AMI de Windows 2022 Full x86 optimizada para Amazon ECS
  + AMI de Windows 2022 Core x86 optimizada para Amazon ECS
  + AMI de Windows 2019 Full x86 optimizada para Amazon ECS
  + AMI de Windows 2019 Core x86 optimizada para Amazon ECS
  + AMI de Windows 2016 Full x86 optimizada para Amazon ECS

Se recomienda que seleccione la opción “Usar la versión más reciente disponible del SO”. La canalización utilizará el control de versiones semántico para la imagen principal, lo que ayuda a detectar las actualizaciones de dependencias en los trabajos programados automáticamente. Para más información, consulte [Semantic versioning](https://docs.aws.amazon.com/imagebuilder/latest/userguide/ibhow-semantic-versioning.html) en la *Guía de usuario del Generador de imágenes de EC2*.

AWS actualiza periódicamente las imágenes de AMI optimizadas para Amazon ECS con parches de seguridad y la nueva versión del agente de contenedores. Cuando utiliza un ID de AMI como imagen principal en la receta de la imagen, debe comprobar periódicamente si hay actualizaciones en la imagen principal. Si las hay, debe crear una nueva versión de su receta con la AMI actualizada. Esto garantiza que las imágenes personalizadas incorporen la última versión de la imagen principal. Para obtener información sobre cómo crear un flujo de trabajo para actualizar automáticamente las instancias de EC2 de su clúster de Amazon ECS con las AMI recién creadas, consulte [How to create an AMI hardening pipeline and automate updates to your ECS instance fleet](https://aws.amazon.com/blogs/security/how-to-create-an-ami-hardening-pipeline-and-automate-updates-to-your-ecs-instance-fleet/).

También puede especificar el nombre de recurso de Amazon (ARN) de una imagen principal que se publique mediante una canalización administrada del Generador de imágenes de EC2. Amazon publica de forma habitual imágenes AMI optimizadas para Amazon ECS a través de canalizaciones administradas. Estas imágenes son de acceso público. Debe tener los permisos correctos para acceder a la imagen. Cuando utiliza un ARN de imagen en lugar de una AMI en su receta del Generador de imágenes, su canalización utiliza automáticamente la versión más reciente de la imagen principal cada vez que se ejecuta. Este enfoque elimina la necesidad de crear manualmente nuevas versiones de recetas para cada actualización. 

## Limpieza de la AMI optimizada para Amazon ECS
<a name="cleanup-ecs-optimized-ami"></a>

Si utiliza una AMI optimizada para Amazon ECS como imagen principal, debe limpiar la imagen para evitar problemas transitorios. La AMI optimizada para Amazon ECS está preconfigurada para que el agente de Amazon ECS se inicie automáticamente y se registre como instancia de contenedor en Amazon ECS. Si se utiliza como imagen base sin una limpieza adecuada, se pueden producir problemas en la AMI personalizada.

Para limpiar la imagen para utilizarla en el futuro, cree un componente que ponga en marcha los comandos siguientes para detener el paquete ecs-init y los procesos de Docker:

```
sudo systemctl stop ecs
sudo systemctl stop docker
```

Elimine todos los archivos de registro de la instancia actual para evitar que se conserven al guardar la imagen. Utilice el script de ejemplo de [Security best practices for EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/security-best-practices.html) para limpiar los distintos archivos de la instancia.

Para limpiar los datos específicos de Amazon ECS, ponga en marcha los comandos siguientes:

```
sudo rm -rf /var/log/ecs/*
sudo rm /var/lib/ecs/data/agent.db
```

Para obtener más información acerca de la creación de AMI personalizadas optimizadas para Amazon ECS, consulte [How do I create a custom AMI from an Amazon ECS-optimized AMI?](https://forums.aws.amazon.com/knowledge-center/ecs-create-custom-amis/) en Centro de conocimientos de AWS.

## Uso del ARN de imagen con la infraestructura como código (IaC)
<a name="infrastructure-as-code-arn"></a>

Puede configurar la receta mediante la consola del Generador de imágenes de EC2 o infraestructura como código (por ejemplo, CloudFormation) o el AWS SDK. Al especificar una imagen principal en la receta, puede especificar un ID de AMI de EC2, un ARN de imagen del Generador de imágenes, un ID de producto de AWS Marketplace o una imagen de contenedor. AWS publica los ID de AMI y los ARN de imagen del Generador de imágenes de las AMI optimizadas para Amazon ECS públicamente. El siguiente es el formato del ARN para la imagen:

```
arn:${Partition}:imagebuilder:${Region}:${Account}:image/${ImageName}/${ImageVersion}
```

La `ImageVersion` tiene el siguiente formato. Sustituya los valores *principal*, *secundario* y *parche* por los valores más recientes.

```
<major>.<minor>.<patch>
```

Puede reemplazar los valores `major`, `minor` y `patch` con valores específicos o puede utilizar el ARN sin versión de una imagen para que su canalización permanezca actualizada con la última versión de la imagen principal. Un ARN sin versiones utiliza el formato comodín “x.x.x” para representar la versión de la imagen. Este enfoque permite que el servicio del Generador de imágenes se resuelva automáticamente en la versión más reciente de la imagen. El uso de un ARN sin versiones garantiza que su referencia siempre apunte a la imagen más reciente disponible, lo que agiliza el proceso de mantener las imágenes actualizadas en su implementación. Al crear una receta con la consola, el Generador de imágenes de EC2 identifica automáticamente el ARN de la imagen principal. Cuando utilice IaC para crear la receta, debe identificar el ARN y seleccionar la versión de imagen deseada o utilizar el ARN sin versión para indicar la última imagen disponible. Se recomienda que cree un script automático para filtrar y mostrar solo las imágenes que se ajusten a sus criterios. El siguiente script de Python muestra cómo se puede recuperar una lista de AMI optimizadas para Amazon ECS. 

El script acepta dos argumentos opcionales: `owner` y `platform`, con los valores predeterminados de “Amazon” y “Windows”, respectivamente. Los valores válidos para el argumento propietario son: `Self`, `Shared`, `Amazon` y `ThirdParty`. Los valores válidos para el argumento plataforma son `Windows` y `Linux`. Por ejemplo, si ejecuta el script con el argumento `owner` establecido en `Amazon` y `platform` establecido en `Linux`, el script genera una lista de imágenes publicadas por Amazon, que incluye las imágenes optimizadas para Amazon ECS.

```
import boto3
import argparse

def list_images(owner, platform):
    # Create a Boto3 session
    session = boto3.Session()
    
    # Create an EC2 Image Builder client
    client = session.client('imagebuilder')

    # Define the initial request parameters
    request_params = {
        'owner': owner,
        'filters': [
            {
                'name': 'platform',
                'values': [platform]
            }
        ]
    }

    # Initialize the results list
    all_images = []

    # Get the initial response with the first page of results
    response = client.list_images(**request_params)

    # Extract images from the response
    all_images.extend(response['imageVersionList'])

    # While 'nextToken' is present, continue paginating
    while 'nextToken' in response and response['nextToken']:
        # Update the token for the next request
        request_params['nextToken'] = response['nextToken']

        # Get the next page of results
        response = client.list_images(**request_params)

        # Extract images from the response
        all_images.extend(response['imageVersionList'])

    return all_images

def main():
    # Initialize the parser
    parser = argparse.ArgumentParser(description="List AWS images based on owner and platform")
    
    # Add the parameters/arguments
    parser.add_argument("--owner", default="Amazon", help="The owner of the images. Default is 'Amazon'.")
    parser.add_argument("--platform", default="Windows", help="The platform type of the images. Default is 'Windows'.")

    # Parse the arguments
    args = parser.parse_args()

    # Retrieve all images based on the provided owner and platform
    images = list_images(args.owner, args.platform)

    # Print the details of the images
    for image in images:
        print(f"Name: {image['name']}, Version: {image['version']}, ARN: {image['arn']}")

if __name__ == "__main__":
    main()
```

## Uso del ARN de la imagen con CloudFormation
<a name="arn-with-cloudformation"></a>

Una receta de imagen del Generador de imágenes es un esquema que especifica la imagen principal y los componentes necesarios para lograr la configuración deseada de la imagen de salida. Usted utiliza el recurso `AWS::ImageBuilder::ImageRecipe`. Establezca el valor `ParentImage` en el ARN de la imagen. Utilice el ARN sin versiones de la imagen que desee para asegurarse de que su canalización utilice siempre la versión más reciente de la imagen. Por ejemplo, `arn:aws:imagebuilder:us-east-1:aws:image/amazon-linux-2023-ecs-optimized-x86/x.x.x`. La siguiente definición de recurso `AWS::ImageBuilder::ImageRecipe` utiliza un ARN de imagen administrada por Amazon:

```
ECSRecipe:
    Type: AWS::ImageBuilder::ImageRecipe
    Properties:
      Name: MyRecipe
      Version: '1.0.0'
      Components:
        - ComponentArn: [<The component arns of the image recipe>]
      ParentImage: "arn:aws:imagebuilder:us-east-1:aws:image/amazon-linux-2023-ecs-optimized-x86/x.x.x"
```

Para más información sobre el recurso [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagerecipe.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagerecipe.html), consulte la *Guía del usuario de AWS CloudFormation*.

Puede automatizar la creación de nuevas imágenes en su canalización configurando la propiedad `Schedule` del recurso `AWS::ImageBuilder::ImagePipeline`. La programación incluye una condición de inicio y una expresión cron. Para obtener más información, consulte [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagepipeline.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagepipeline.html) en la *Guía del usuario de AWS CloudFormation*.

 En el siguiente ejemplo de `AWS::ImageBuilder::ImagePipeline`, la canalización ejecuta una compilación todos los días a las 10:00 h, Hora Universal Coordinada (UTC). Defina los siguientes valores de `Schedule`:
+ Establece `PipelineExecutionStartCondition` en `EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE`. La compilación se inicia solo si se actualizan los recursos dependientes, como la imagen principal o los componentes, que utilizan el comodín “x” en sus versiones semánticas. Esto garantiza que la compilación incorpore las actualizaciones más recientes de esos recursos.
+ Establezca ScheduleExpression en la expresión cron `(0 10 * * ? *)`.

```
ECSPipeline:
    Type: AWS::ImageBuilder::ImagePipeline
    Properties:
      Name: my-pipeline
      ImageRecipeArn: <arn of the recipe you created in previous step>
      InfrastructureConfigurationArn: <ARN of the infrastructure configuration associated with this image pipeline>
      Schedule:
        PipelineExecutionStartCondition: EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE
        ScheduleExpression: 'cron(0 10 * * ? *)'
```

## Uso del ARN de la imagen con Terraform
<a name="arn-with-terraform"></a>

El enfoque para especificar la imagen principal y la programación de su canalización en Terraform se alinea con las de AWS CloudFormation. Usted utiliza el recurso `aws_imagebuilder_image_recipe`. Establezca el valor `parent_image` en el ARN de la imagen. Utilice el ARN sin versiones de la imagen que desee para asegurarse de que su canalización utilice siempre la versión más reciente de la imagen. Para más información, consulte [https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_recipe#argument-reference](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_recipe#argument-reference) en la documentación de Terraform. 

En el bloque de configuración de programación de la `aws_imagebuilder_image_pipeline resource`, establezca el valor del argumento `schedule_expression` en una expresión cron de su elección para especificar la frecuencia con la que se ejecuta la canalización y establezca `pipeline_execution_start_condition` en `EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE`. Para más información, consulte [https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_pipeline#argument-reference](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_pipeline#argument-reference) en la documentación de Terraform. 

# Uso de contenedores de aprendizaje profundo de AWS en Amazon ECS
<a name="deep-learning-containers"></a>

AWS Deep Learning Containers proporciona un conjunto de imágenes de Docker para formar y trabajar con modelos en TensorFlow y en Apache MXNet (incubación) en Amazon ECS. Deep Learning Containers proporciona entornos optimizados con bibliotecas de TensorFlow, CUDA de NVIDIA (para instancias de GPU) y MKL de Intel (para instancias de CPU). Las imágenes de contenedor de Deep Learning Containers están disponibles en Amazon ECR para referenciarlas en las definiciones de tareas de Amazon ECS. Puede utilizar Deep Learning Containers junto con Amazon Elastic Inference para reducir los costes de inferencia.

Para empezar a utilizar contenedores de aprendizaje profundo sin Elastic Inference en Amazon ECS, consulte [Configuración de Amazon ECS](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/deep-learning-containers-ecs-setup.html) en la *Guía para desarrolladores de AWS Deep Learning AMIs*.

# Tutorial: Creación de un servicio mediante una implementación blue/green
<a name="create-blue-green"></a>

Amazon ECS ha integrado las implementaciones “blue/green” en el asistente de creación de servicios de la consola de Amazon ECS. Para obtener más información, consulte [Creación de una implementación de actualización continua de Amazon ECS](create-service-console-v2.md).

En el siguiente tutorial, se muestra cómo crear un servicio de Amazon ECS que contenga una tarea de Fargate que utilice el tipo de implementación “blue/green” con la desde la AWS CLI.

**nota**  
Se ha añadido soporte para realizar una implementación green/blue en CloudFormation. Para obtener más información, consulte [Realización de implementaciones “blue/green” (azul/verde) de Amazon ECS a través de CodeDeploy mediante CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html) en la *Guía del usuario de AWS CloudFormation*.

## Requisitos previos
<a name="create-blue-green-prereqs"></a>

En este tutorial se supone que se han completado los siguientes requisitos previos:
+ La última versión de la AWS CLI está instalada y configurada. Para obtener más información sobre cómo instalar o actualizar la AWS CLI, consulte [Instalación de la AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html).
+ Se han completado los pasos que se indican en [Configuración para utilizar Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Su usuario de IAM dispone de los permisos requeridos que se especifican en la política de IAM [AmazonECS\$1FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) de ejemplo.
+ Tiene una VPC y un grupo de seguridad creados para utilizarlos. Para obtener más información, consulte [Creación de una nube virtual privada](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Se crea el rol de IAM de CodeDeploy de Amazon ECS. Para obtener más información, consulte [Rol de IAM de CodeDeploy de Amazon ECS](codedeploy_IAM_role.md).

## Paso 1: Crear un Application Load Balancer
<a name="create-blue-green-loadbalancer"></a>

Los servicios Amazon ECS que utilizan el tipo de implementación “blue/green” requieren la utilización de un Application Load Balancer o un Network Load Balancer. En este tutorial, se utiliza un Application Load Balancer.

**Para crear un Application Load Balancer de**

1. Utilice el comando [create-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-load-balancer.html) para crear un Application Load Balancer. Especifique dos subredes que no formen parte de la misma zona de disponibilidad, así como un grupo de seguridad.

   ```
   aws elbv2 create-load-balancer \
        --name bluegreen-alb \
        --subnets subnet-abcd1234 subnet-abcd5678 \
        --security-groups sg-abcd1234 \
        --region us-east-1
   ```

   El resultado contiene el nombre de recurso de Amazon (ARN) del equilibrador de carga con el siguiente formato:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642
   ```

1. Utilice el comando [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html) para crear un grupo de destino. Este grupo de destino dirigirá el tráfico a las tareas originales definidas en su servicio.

   ```
   aws elbv2 create-target-group \
        --name bluegreentarget1 \
        --protocol HTTP \
        --port 80 \
        --target-type ip \
        --vpc-id vpc-abcd1234 \
        --region us-east-1
   ```

   El resultado contiene el ARN del grupo de destino con el siguiente formato:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4
   ```

1. Utilice el comando [create-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html) para crear un agente de escucha del balanceador de carga con una regla predeterminada que reenvíe las solicitudes al grupo de destino.

   ```
   aws elbv2 create-listener \
        --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
        --protocol HTTP \
        --port 80 \
        --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
        --region us-east-1
   ```

   El resultado incluye el ARN del agente de escucha con el siguiente formato:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4
   ```

## Paso 2: Crear un clúster de Amazon ECS
<a name="create-blue-green-cluster"></a>

Utilice el comando [create-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-cluster.html) para crear un clúster denominado `tutorial-bluegreen-cluster`.

```
aws ecs create-cluster \
     --cluster-name tutorial-bluegreen-cluster \
     --region us-east-1
```

El resultado incluye el ARN del clúster con el siguiente formato:

```
arn:aws:ecs:region:aws_account_id:cluster/tutorial-bluegreen-cluster
```

## Paso 3: Registrar una definición de tareas
<a name="create-blue-green-taskdef"></a>

Utilice el comando [register-task-definition](https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html) para registrar una definición de tareas compatible con Fargate. Se necesita utilizar el modo de red `awsvpc`. A continuación, se muestra el ejemplo de definición de tareas utilizado en este tutorial.

En primer lugar, cree un archivo denominado `fargate-task.json` con el siguiente contenido. Asegúrese de que utiliza el ARN del rol de ejecución de la tarea. Para obtener más información, consulte [Rol de IAM de ejecución de tareas de Amazon ECS](task_execution_IAM_role.md).

```
{
    "family": "sample-fargate", 
    "networkMode": "awsvpc", 
    "containerDefinitions": [
        {
            "name": "sample-app", 
            "image": "public.ecr.aws/docker/library/httpd:latest", 
            "portMappings": [
                {
                    "containerPort": 80, 
                    "hostPort": 80, 
                    "protocol": "tcp"
                }
            ], 
            "essential": true, 
            "entryPoint": [
                "sh",
		"-c"
            ], 
            "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\""
            ]
        }
    ], 
    "requiresCompatibilities": [
        "FARGATE"
    ], 
    "cpu": "256", 
    "memory": "512"
}
```

A continuación, registre la definición de tarea mediante el archivo `fargate-task.json` que ha creado.

```
aws ecs register-task-definition \
     --cli-input-json file://fargate-task.json \
     --region us-east-1
```

## Paso 4: Crear un servicio de Amazon ECS
<a name="create-blue-green-service"></a>

Ejecute el comando [create-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-service.html) para crear un servicio. 

En primer lugar, cree un archivo denominado `service-bluegreen.json` con el siguiente contenido.

```
{
    "cluster": "tutorial-bluegreen-cluster",
    "serviceName": "service-bluegreen",
    "taskDefinition": "tutorial-task-def",
    "loadBalancers": [
        {
            "targetGroupArn": "arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4",
            "containerName": "sample-app",
            "containerPort": 80
        }
    ],
    "launchType": "FARGATE",
    "schedulingStrategy": "REPLICA",
    "deploymentController": {
        "type": "CODE_DEPLOY"
    },
    "platformVersion": "LATEST",
    "networkConfiguration": {
       "awsvpcConfiguration": {
          "assignPublicIp": "ENABLED",
          "securityGroups": [ "sg-abcd1234" ],
          "subnets": [ "subnet-abcd1234", "subnet-abcd5678" ]
       }
    },
    "desiredCount": 1
}
```

A continuación, cree el servicio mediante el archivo `service-bluegreen.json` que ha creado.

```
aws ecs create-service \
     --cli-input-json file://service-bluegreen.json \
     --region us-east-1
```

El resultado incluye el ARN del servicio con el siguiente formato:

```
arn:aws:ecs:region:aws_account_id:service/service-bluegreen
```

## Paso 5: Crear los recursos de AWS CodeDeploy
<a name="create-blue-green-codedeploy"></a>

Siga los pasos que se describen a continuación para crear la aplicación CodeDeploy, el grupo de destino del Application Load Balancer para el grupo de implementaciones de CodeDeploy y el grupo de implementaciones de CodeDeploy.

**Para crear recursos de CodeDeploy**

1. Utilice el comando [create-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-application.html) para crear una aplicación de CodeDeploy. Especifique la plataforma informática de `ECS`.

   ```
   aws deploy create-application \
        --application-name tutorial-bluegreen-app \
        --compute-platform ECS \
        --region us-east-1
   ```

   El resultado incluye el ID de aplicación con el siguiente formato:

   ```
   {
       "applicationId": "b8e9c1ef-3048-424e-9174-885d7dc9dc11"
   }
   ```

1. Utilice el comando [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html) para crear un segundo grupo de destino para el Application Load Balancer, que se utilizará al crear el grupo de implementación de CodeDeploy.

   ```
   aws elbv2 create-target-group \
        --name bluegreentarget2 \
        --protocol HTTP \
        --port 80 \
        --target-type ip \
        --vpc-id "vpc-0b6dd82c67d8012a1" \
        --region us-east-1
   ```

   El resultado contiene el ARN del grupo de destino con el siguiente formato:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc
   ```

1. Ejecute el comando [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html) para crear un grupo de implementación de CodeDeploy.

   En primer lugar, cree un archivo denominado `tutorial-deployment-group.json` con el siguiente contenido. En el ejemplo se utiliza el recurso que ha creado. En `serviceRoleArn`, especifique el ARN del rol de IAM de CodeDeploy de Amazon ECS. Para obtener más información, consulte [Rol de IAM de CodeDeploy de Amazon ECS](codedeploy_IAM_role.md).

   ```
   {
      "applicationName": "tutorial-bluegreen-app",
      "autoRollbackConfiguration": {
         "enabled": true,
         "events": [ "DEPLOYMENT_FAILURE" ]
      },
      "blueGreenDeploymentConfiguration": {
         "deploymentReadyOption": {
            "actionOnTimeout": "CONTINUE_DEPLOYMENT",
            "waitTimeInMinutes": 0
         },
         "terminateBlueInstancesOnDeploymentSuccess": {
            "action": "TERMINATE",
            "terminationWaitTimeInMinutes": 5
         }
      },
      "deploymentGroupName": "tutorial-bluegreen-dg",
      "deploymentStyle": {
         "deploymentOption": "WITH_TRAFFIC_CONTROL",
         "deploymentType": "BLUE_GREEN"
      },
      "loadBalancerInfo": {
         "targetGroupPairInfoList": [
           {
             "targetGroups": [
                {
                    "name": "bluegreentarget1"
                },
                {
                    "name": "bluegreentarget2"
                }
             ],
             "prodTrafficRoute": {
                 "listenerArns": [
                     "arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4"
                 ]
             }
           }
         ]
      },
      "serviceRoleArn": "arn:aws:iam::aws_account_id:role/ecsCodeDeployRole",
      "ecsServices": [
          {
              "serviceName": "service-bluegreen",
              "clusterName": "tutorial-bluegreen-cluster"
          }
      ]
   }
   ```

   A continuación, cree el grupo de implementación de CodeDeploy.

   ```
   aws deploy create-deployment-group \
        --cli-input-json file://tutorial-deployment-group.json \
        --region us-east-1
   ```

   El resultado incluye el ID del grupo de implementación con el siguiente formato:

   ```
   {
       "deploymentGroupId": "6fd9bdc6-dc51-4af5-ba5a-0a4a72431c88"
   }
   ```

## Paso 6: Crear y monitorear una implementación de CodeDeploy
<a name="create-blue-green-verify"></a>

Siga estos pasos para crear y cargar un archivo de especificación de la aplicación (archivo AppSpec) y una implementación de CodeDeploy.

**Para crear y monitorear una implementación de CodeDeploy**

1. Cree y cargue un archivo AppSpec con los pasos que se describen a continuación.

   1. Cree un archivo con el nombre `appspec.yaml` que incluya el contenido del grupo de implementación de CodeDeploy. En este ejemplo se utilizan los recursos que creó previamente en el tutorial.

      ```
      version: 0.0
      Resources:
        - TargetService:
            Type: AWS::ECS::Service
            Properties:
              TaskDefinition: "arn:aws:ecs:region:aws_account_id:task-definition/first-run-task-definition:7"
              LoadBalancerInfo:
                ContainerName: "sample-app"
                ContainerPort: 80
              PlatformVersion: "LATEST"
      ```

   1. Utilice el comando [s3 mb](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html) para crear un bucket de Amazon S3 para el archivo AppSpec.

      ```
      aws s3 mb s3://tutorial-bluegreen-bucket
      ```

   1. Utilice el comando [s3 cp](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html) para cargar el archivo AppSpec en el bucket de Amazon S3.

      ```
      aws s3 cp ./appspec.yaml s3://tutorial-bluegreen-bucket/appspec.yaml
      ```

1. Siga estos pasos para crear la implementación de CodeDeploy.

   1. Cree un archivo con el nombre `create-deployment.json` que incluya el contenido de la implementación de CodeDeploy. En este ejemplo se utilizan los recursos que creó previamente en el tutorial.

      ```
      {
          "applicationName": "tutorial-bluegreen-app",
          "deploymentGroupName": "tutorial-bluegreen-dg",
          "revision": {
              "revisionType": "S3",
              "s3Location": {
                  "bucket": "tutorial-bluegreen-bucket",
                  "key": "appspec.yaml",
                  "bundleType": "YAML"
              }
          }
      }
      ```

   1. Utilice el comando [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html) para crear la implementación.

      ```
      aws deploy create-deployment \
           --cli-input-json file://create-deployment.json \
           --region us-east-1
      ```

      El resultado incluye el ID de la implementación con el siguiente formato:

      ```
      {
          "deploymentId": "d-RPCR1U3TW"
      }
      ```

   1. Utilice el comando [get-deployment-target](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-target.html) para obtener los detalles de la implementación, especificando el `deploymentId` del resultado anterior.

      ```
      aws deploy get-deployment-target \
           --deployment-id "d-IMJU3A8TW" \
           --target-id tutorial-bluegreen-cluster:service-bluegreen \
           --region us-east-1
      ```

      Continue recuperando los detalles de la implementación hasta que el estado sea `Succeeded`, tal y como se muestra en el siguiente resultado.

      ```
      {
          "deploymentTarget": {
              "deploymentTargetType": "ECSTarget",
              "ecsTarget": {
                  "deploymentId": "d-RPCR1U3TW",
                  "targetId": "tutorial-bluegreen-cluster:service-bluegreen",
                  "targetArn": "arn:aws:ecs:region:aws_account_id:service/service-bluegreen",
                  "lastUpdatedAt": 1543431490.226,
                  "lifecycleEvents": [
                      {
                          "lifecycleEventName": "BeforeInstall",
                          "startTime": 1543431361.022,
                          "endTime": 1543431361.433,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "Install",
                          "startTime": 1543431361.678,
                          "endTime": 1543431485.275,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterInstall",
                          "startTime": 1543431485.52,
                          "endTime": 1543431486.033,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "BeforeAllowTraffic",
                          "startTime": 1543431486.838,
                          "endTime": 1543431487.483,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AllowTraffic",
                          "startTime": 1543431487.748,
                          "endTime": 1543431488.488,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterAllowTraffic",
                          "startTime": 1543431489.152,
                          "endTime": 1543431489.885,
                          "status": "Succeeded"
                      }
                  ],
                  "status": "Succeeded",
                  "taskSetsInfo": [
                      {
                          "identifer": "ecs-svc/9223370493425779968",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "ACTIVE",
                          "trafficWeight": 0.0,
                          "targetGroup": {
                              "name": "bluegreentarget1"
                          }
                      },
                      {
                          "identifer": "ecs-svc/9223370493423413672",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "PRIMARY",
                          "trafficWeight": 100.0,
                          "targetGroup": {
                              "name": "bluegreentarget2"
                          }
                      }
                  ]
              }
          }
      }
      ```

## Paso 7: Eliminación
<a name="create-blue-green-cleanup"></a>

Cuando termine este tutorial, debe limpiar los recursos asociados para evitar incurrir en cargos por recursos que no está utilizando.

**Limpieza de los recursos del tutorial**

1. Utilice el comando [delete-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html) para eliminar el grupo de implementación de CodeDeploy.

   ```
   aws deploy delete-deployment-group \
        --application-name tutorial-bluegreen-app \
        --deployment-group-name tutorial-bluegreen-dg \
        --region us-east-1
   ```

1. Utilice el comando [delete-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) para eliminar la aplicación de CodeDeploy.

   ```
   aws deploy delete-application \
        --application-name tutorial-bluegreen-app \
        --region us-east-1
   ```

1. Utilice el comando [delete-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-service.html) para eliminar el servicio de Amazon ECS. El uso de la marca `--force` le permite eliminar un servicio aunque no se haya escalado a cero tareas.

   ```
   aws ecs delete-service \
        --service arn:aws:ecs:region:aws_account_id:service/service-bluegreen \
        --force \
        --region us-east-1
   ```

1. Utilice el comando [delete-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-cluster.html) para eliminar el clúster de Amazon ECS.

   ```
   aws ecs delete-cluster \
        --cluster tutorial-bluegreen-cluster \
        --region us-east-1
   ```

1. Utilice el comando [s3 rm](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html) para eliminar el archivo AppSpec del bucket de Amazon S3.

   ```
   aws s3 rm s3://tutorial-bluegreen-bucket/appspec.yaml
   ```

1. Utilice el comando [s3 rb](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html) para eliminar el bucket de Amazon S3.

   ```
   aws s3 rb s3://tutorial-bluegreen-bucket
   ```

1. Utilice el comando [delete-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-load-balancer.html) para eliminar el Application Load Balancer.

   ```
   aws elbv2 delete-load-balancer \
        --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
        --region us-east-1
   ```

1. Utilice el comando [delete-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-target-group.html) para eliminar los dos grupos de destino del Application Load Balancer.

   ```
   aws elbv2 delete-target-group \
        --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
        --region us-east-1
   ```

   ```
   aws elbv2 delete-target-group \
        --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc \
        --region us-east-1
   ```