# Implementación de Fluent Bit en contenedores de Amazon ECS para Windows
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
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
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
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\_name}} con el nombre de su clúster.
```
Import-Module ECSTools
Initialize-ECSAgent -Cluster {{cluster-name}} -EnableTaskENI -EnableTaskIAMRole -LoggingDrivers '["awslogs","fluentd"]'
```
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
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\_tag utiliza la entrada de registro modificada. Este filtro cambia la etiqueta del archivo de registro al formato out.{{TASK\_ID}}.{{CONTAINER\_NAME}}.
+ La nueva etiqueta se enrutará al complemento de salida cloudwatch\_logs, 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
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
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
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`
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
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
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}}
```