# Envío de registros de Amazon ECS a un servicio de AWS o AWS Partner
Puede utilizar FireLens para Amazon ECS para utilizar parámetros de definición de tareas para dirigir registros a un servicio de AWS o a un destino de AWS Partner Network (APN) para el almacenamiento y el análisis de registros. La AWS Partner Network es una comunidad global de socios que aprovecha los programas, el conocimiento técnico y los recursos para crear, comercializar y vender ofertas para los clientes. Para obtener más información, consulte [AWS Partner](https://aws.amazon.com/partners/work-with-partners/). FireLens trabaja con [Fluentd](https://www.fluentd.org/) y [Fluent Bit](https://fluentbit.io/). Proporcionamos AWS para la imagen de Fluent Bit o puede utilizar su propia imagen de Fluentd o Fluent Bit.
De forma predeterminada, Amazon ECS configura la dependencia del contenedor para que el contenedor Firelens se inicie antes que cualquier contenedor que lo utilice. El contenedor Firelens también se detiene después de que se detengan todos los contenedores que lo utilizan.
Para utilizar esta característica, debe crear un rol de IAM para las tareas, que proporcione los permisos necesarios para utilizar los servicios de AWS que las tareas requieran. Por ejemplo, si un contenedor dirige los registros a Firehose, la tarea necesita permiso para llamar a la API `firehose:PutRecordBatch`. Para obtener más información, consulte [Adición y eliminación de permisos de identidad de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) en la *Guía del usuario de IAM*.
Es posible que la tarea también requiera el rol de ejecución de tareas de Amazon ECS en las condiciones que se describen a continuación. Para obtener más información, consulte [Rol de IAM de ejecución de tareas de Amazon ECS](task_execution_IAM_role.md).
+ Si la tarea está alojada en Fargate y se están extrayendo imágenes de contenedor de Amazon ECR o haciendo referencia a información confidencial de AWS Secrets Manager en la configuración de registro, debe incluir el rol de IAM de ejecución de tareas.
+ Si utiliza un archivo de configuración personalizado alojado en Amazon S3, el rol de IAM de ejecución de tareas debe incluir el permiso `s3:GetObject`.
Al utilizar FireLens para Amazon ECS, tenga en cuenta lo siguiente:
+ Se recomienda agregar `my_service_` al nombre del contenedor de registros para poder distinguir fácilmente los nombres de los contenedores en la consola.
+ Amazon ECS agrega una dependencia de orden de contenedores inicial entre los contenedores de la aplicación y el contenedor de FireLens de manera predeterminada. Al especificar un orden de contenedores entre los contenedores de la aplicación y el contenedor de FireLens, se anula el orden de contenedores inicial predeterminado.
+ FireLens para Amazon ECS es compatible con tareas que están alojadas en AWS Fargate en Linux y Amazon EC2 en Linux. Los contenedores de Windows no son compatibles con FireLens.
Para obtener información sobre cómo configurar el registro centralizado para contenedores de Windows, consulte [Centralized logging for Windows containers on Amazon ECS using Fluent Bit](https://aws.amazon.com/blogs/containers/centralized-logging-for-windows-containers-on-amazon-ecs-using-fluent-bit/) (Registro centralizado para contenedores de Windows en Amazon ECS con Fluent Bit).
+ Puede utilizar plantillas de CloudFormation para configurar FireLens para Amazon ECS. Para obtener más información, consulte [FirelensConfiguration de ::ECS::TaskDefinition](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-firelensconfiguration.html) en la *Guía del usuario de AWS CloudFormation*.
+ FireLens escucha en el puerto `24224`, para asegurarse de que el direccionador de registros FireLens no sea accesible fuera de la tarea, no debe permitir la entrada de tráfico en el puerto `24224` en el grupo de seguridad que utiliza la tarea. Para tareas que utilizan el modo de red `awsvpc`, es el grupo de seguridad asociado a la tarea. Para tareas que utilizan el modo de red `host`, es el grupo de seguridad asociado a la instancia de Amazon EC2 que aloja la tarea. Para tareas que utilizan el modo de red `bridge`, no cree asignaciones de puertos que utilicen el puerto `24224`.
+ Para las tareas que utilizan el modo de red `bridge`, el contenedor con la configuración de FireLens debe iniciarse antes de que se inicie cualquier contenedor de aplicación que se base en él. Para controlar el orden de inicio de los contenedores, utilice las condiciones de dependencia en la definición de la tarea. Para obtener más información, consulte [Dependencia de contenedor](task_definition_parameters.md#container_definition_dependson).
**nota**
Si utiliza parámetros de condición de dependencia en definiciones de contenedor con una configuración de FireLens, asegúrese de que cada contenedor tenga un requisito de condición `START` o `HEALTHY`.
+ Por defecto, FireLens agrega el nombre de definición de clúster y tarea y el nombre de recurso de Amazon (ARN) del clúster como claves de metadatos a los registros de contenedor de stdout/stderr. A continuación se muestra un ejemplo del formato de los metadatos.
```
"ecs_cluster": "cluster-name",
"ecs_task_arn": "arn:aws:ecs:region:111122223333:task/cluster-name/f2ad7dba413f45ddb4EXAMPLE",
"ecs_task_definition": "task-def-name:revision",
```
Si no quiere que los metadatos estén en los registros, establezca `enable-ecs-log-metadata` en `false` en la `firelensConfiguration` de la definición de tareas.
```
"firelensConfiguration":{
"type":"fluentbit",
"options":{
"enable-ecs-log-metadata":"false",
"config-file-type":"file",
"config-file-value":"/extra.conf"
}
```
Puede configurar el contenedor FireLens para que se ponga en marcha como usuario no raíz. Considere lo siguiente:
+ Para configurar el contenedor FireLens para que se ponga en marcha como un usuario no raíz, debe especificar el usuario en uno de los formatos siguientes:
+ `uid`
+ `uid:gid`
+ `uid:group`
Para obtener más información acerca de la especificación de un usuario en una definición de contenedor, consulte [ContainerDefinition](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html) en la *Referencia de la API de Amazon Elastic Container Service*.
El contenedor FireLens recibe los registros de la aplicación a través de un socket UNIX. El agente de Amazon ECS utiliza el parámetro `uid` para asignar la responsabilidad del directorio de sockets al contenedor FireLens.
+ La configuración del contenedor FireLens para que se ponga en marcha como un usuario no raíz se admite en la versión `1.96.0` del agente de Amazon ECS y posteriores, y en la versión `v20250716` de AMI optimizada para Amazon ECS y posteriores.
+ Al especificar un usuario para el contenedor FireLens, el parámetro `uid` debe ser único y no se debe utilizar para otros procesos que pertenezcan a otros contenedores de la tarea o de la instancia de contenedor.
Para obtener información sobre cómo usar varios archivos de configuración con Amazon ECS, incluidos los archivos que usted aloja o los archivos en Amazon S3, consulte [Init process for Fluent Bit on ECS, multi-config support](https://github.com/aws/aws-for-fluent-bit/tree/mainline/use_cases/init-process-for-fluent-bit).
Para obtener información acerca de las configuraciones de ejemplo, consulte [Definición de tareas de Amazon ECS de ejemplo: enrutar registros a FireLens](firelens-taskdef.md).
Para obtener más información acerca de la configuración de registros de rendimiento alto, consulte [Configuración de los registros de Amazon ECS para conseguir un alto rendimiento](firelens-docker-buffer-limit.md).
# Configuración de los registros de Amazon ECS para conseguir un alto rendimiento
Para escenarios de alto rendimiento de registros, recomendamos utilizar el controlador de registro `awsfirelens` con Firelens y Fluent Bit. Fluent Bit es un procesador de registro ligero que es eficiente con los recursos y puede gestionar millones de registros. Sin embargo, para lograr un rendimiento óptimo a escala es necesario ajustar su configuración.
En esta sección se describen las técnicas de optimización de Fluent Bit avanzadas para gestionar un alto rendimiento de los registros y, al mismo tiempo, mantener la estabilidad del sistema y garantizar que no se pierdan datos.
Para obtener información acerca de cómo utilizar archivos de configuración personalizados con FireLens, consulte [Uso de un archivo de configuración personalizado](firelens-taskdef.md#firelens-taskdef-customconfig). Para ver más ejemplos, consulte [Ejemplos de FireLens en Amazon ECS](https://github.com/aws-samples/amazon-ecs-firelens-examples) en GitHub.
**nota**
Algunas opciones de configuración de esta sección, como `workers` y `threaded`, requieren AWS para la versión 3 o posterior de Fluent Bit. Para obtener información sobre las versiones disponibles, consulte [Versiones de AWS para Fluent Bit](https://github.com/aws/aws-for-fluent-bit/releases).
## Utilizar el almacenamiento en búfer del sistema de archivos
De forma predeterminada, Fluent Bit almacena en búfer todos los datos de la memoria. Cuando los datos se ingieren más rápido de lo que pueden transferirse a las salidas, el búfer se llena. Una vez lleno, el complemento de entrada se detiene hasta que hay espacio disponible en el búfer, lo que puede provocar una contrapresión y ralentizar la aplicación.
Para escenarios de alto rendimiento, recomendamos utilizar el almacenamiento en búfer del sistema de archivos. Para obtener más información sobre cómo Fluent Bit gestiona el almacenamiento en búfer y el almacenamiento, consulte [Almacenamiento en búfer y almacenamiento en la documentación](https://docs.fluentbit.io/manual/administration/buffering-and-storage) de Fluent Bit.
El uso del almacenamiento en búfer del sistema de archivos proporciona los siguientes beneficios:
+ **Mayor capacidad de búfer**: el espacio en disco suele ser más abundante que la memoria.
+ **Persistencia**: los datos almacenados en búfer sobreviven a los reinicios de Fluent Bit.
+ **Degradación gradual**: durante los errores de salida, los datos se acumulan en el disco en lugar de agotar la memoria.
Para activar el almacenamiento en búfer del sistema de archivos, proporciona un archivo de configuración personalizado de Fluent Bit. A continuación se muestra un ejemplo de configuración recomendada:
```
[SERVICE]
# Flush logs every 1 second
Flush 1
# Wait 120 seconds during shutdown to flush remaining logs
Grace 120
# Directory for filesystem buffering
storage.path /var/log/flb-storage/
# Limit chunks stored 'up' in memory (reduce for memory-constrained environments)
storage.max_chunks_up 32
# Flush backlog chunks to destinations during shutdown (prevents log loss)
storage.backlog.flush_on_shutdown On
[INPUT]
Name forward
unix_path /var/run/fluent.sock
# Run input in separate thread to prevent blocking
threaded true
# Enable filesystem buffering for persistence
storage.type filesystem
[OUTPUT]
Name cloudwatch_logs
Match *
region us-west-2
log_group_name /aws/ecs/my-app
log_stream_name $(ecs_task_id)
# Use multiple workers for parallel processing
workers 2
# Retry failed flushes up to 15 times
retry_limit 15
# Maximum disk space for buffered data for this output
storage.total_limit_size 10G
```
Parámetros principales de configuración:
`storage.path`
El directorio donde Fluent Bit almacena los fragmentos almacenados en búfer en el disco.
`storage.backlog.flush_on_shutdown`
Cuando está activado, Fluent Bit intenta vaciar todos los fragmentos del sistema de archivos pendientes y llevarlos a sus destinos durante el apagado. Esto ayuda a garantizar la entrega de los datos antes de que Fluent Bit se detenga, pero puede aumentar el tiempo de apagado.
`storage.max_chunks_up`
El número de fragmentos que permanecen en la memoria. El valor predeterminado es de 128 fragmentos, que pueden consumir más de 500 MB de memoria, ya que cada bloque puede utilizar entre 4 y 5 MB. En entornos con limitaciones de memoria, reduzca este valor. Por ejemplo, si tiene 50 MB disponibles para almacenar en búfer, configúrelo entre 8 y 10 fragmentos.
`storage.type filesystem`
Active el almacenamiento en el sistema de archivos para el complemento de entrada. A pesar del nombre, Fluent Bit utiliza `mmap` para asignar fragmentos tanto en la memoria como en el disco, lo que proporciona persistencia sin sacrificar el rendimiento.
`threaded true`
Ejecuta la entrada en su propio hilo, separado del bucle de eventos principal de Fluent Bit. Esto evita que las entradas lentas bloqueen toda la canalización.
## Optimizar configuración de salida
Los problemas de red, las interrupciones del servicio y la limitación del destino pueden impedir que se entreguen los registros. La configuración de salida adecuada garantiza la resiliencia sin pérdida de datos.
Cuando se produce un error al vaciar la salida, Fluent Bit puede volver a intentar la operación. Los clústeres de la región pueden obtener los siguientes beneficios.
`retry_limit`
El número máximo de reintentos antes de eliminar registros. El valor predeterminado es 1. Para los entornos de producción, recomendamos 15 o más, lo que cubre varios minutos de interrupción con un retraso exponencial.
`scheduler.base`
El mínimo de segundos entre reintentos. Recomendamos 10 segundos.
`scheduler.cap`
El máximo de segundos entre reintentos cuando se utiliza un retroceso exponencial. Recomendamos 60 segundos.
`workers`
El número de hilos para el procesamiento de salida en paralelo. Varios trabajos permiten vaciados concurrentes, lo que mejora el rendimiento al procesar muchos fragmentos.
El parámetro `Grace` de la sección `[SERVICE]` establece el tiempo de espera de Fluent Bit durante el apagado para vaciar los datos almacenados en el búfer. El período de `Grace` debe coordinarse con el valor de `stopTimeout` del contenedor. Asegúrese de que el valor `stopTimeout` supere el período `Grace` para permitir que Fluent Bit complete la descarga antes de recibir `SIGKILL`. Por ejemplo, si el valor de `Grace` es de 120 segundos, establezca el de `stopTimeout` en 150 segundos.
El siguiente ejemplo muestra una configuración de Fluent Bit completa con todos los ajustes recomendados para escenarios de alto rendimiento:
```
[SERVICE]
# Flush logs every 1 second
Flush 1
# Wait 120 seconds during shutdown to flush remaining logs
Grace 120
# Directory for filesystem buffering
storage.path /var/log/flb-storage/
# Limit chunks stored 'up' in memory (reduce for memory-constrained environments)
storage.max_chunks_up 32
# Flush backlog chunks to destinations during shutdown (prevents log loss)
storage.backlog.flush_on_shutdown On
# Minimum seconds between retries
scheduler.base 10
# Maximum seconds between retries (exponential backoff cap)
scheduler.cap 60
[INPUT]
Name forward
unix_path /var/run/fluent.sock
# Run input in separate thread to prevent blocking
threaded true
# Enable filesystem buffering for persistence
storage.type filesystem
[OUTPUT]
Name cloudwatch_logs
Match *
region us-west-2
log_group_name /aws/ecs/my-app
log_stream_name $(ecs_task_id)
# Use multiple workers for parallel processing
workers 2
# Retry failed flushes up to 15 times
retry_limit 15
# Maximum disk space for buffered data for this output
storage.total_limit_size 10G
```
## Utilice el registro multidestino para garantizar la fiabilidad
El envío de registros a varios destinos elimina los puntos únicos de error. Por ejemplo, si Registros de CloudWatch sufre una interrupción, los registros seguirán llegando a Amazon S3.
El registro multidestino ofrece los siguientes beneficios. El complemento de salida de Amazon S3 también admite opciones de compresión como los formatos .gzip y Parquet, lo que puede reducir los costos de almacenamiento. Para obtener más información, consulte [Compresión de S3](https://docs.fluentbit.io/manual/pipeline/outputs/s3#compression) en la documentación de Fluent Bit.
El registro multidestino puede ofrecer los siguientes beneficios:
+ **Redundancia**: si un destino falla, los registros siguen llegando al otro.
+ **Recuperación**: reconstruya las brechas en un sistema respecto al otro.
+ **Durabilidad**: archive registros en Amazon S3 para la retención a largo plazo.
+ **Optimización de costos**: guarde los registros recientes en un servicio de consultas rápido como Registros de CloudWatch con una retención más corta y, al mismo tiempo, archive todos los registros en un almacenamiento de Amazon S3 de menor costo para conservarlos a largo plazo.
La siguiente configuración de Fluent Bit envía registros tanto a Registros de CloudWatch como a Amazon S3:
```
[OUTPUT]
Name cloudwatch_logs
Match *
region us-west-2
log_group_name /aws/ecs/my-app
log_stream_name $(ecs_task_id)
workers 2
retry_limit 15
[OUTPUT]
Name s3
Match *
bucket my-logs-bucket
region us-west-2
total_file_size 100M
s3_key_format /fluent-bit-logs/$(ecs_task_id)/%Y%m%d/%H/%M/$UUID
upload_timeout 10m
# Maximum disk space for buffered data for this output
storage.total_limit_size 5G
```
Ambas salidas utilizan el mismo patrón de `Match *`, por lo que todos los registros se envían a ambos destinos de forma independiente. Durante una interrupción en un destino, los registros siguen fluyendo hacia el otro, mientras que las descargas fallidas se acumulan en el búfer del sistema de archivos para volver a intentarlo más adelante.
## Utilice el registro basado en archivos con el complemento de entrada trasera
Para escenarios de alto rendimiento en los que la pérdida de registros es un problema fundamental, puede utilizar un enfoque alternativo: haga que la aplicación escriba los registros en los archivos del disco y configure Fluent Bit para leerlos mediante el complemento de entrada `tail`. Este enfoque evita por completo la capa del controlador de registro de Docker.
El registro basado en archivos con el complemento de entrada trasera proporciona los siguientes beneficios:
+ **Seguimiento del desplazamiento**: el complemento de entrada trasera puede almacenar los desplazamientos de los archivos en un archivo de base de datos (mediante la opción `DB`), lo que proporciona durabilidad tras los reinicios de Fluent Bit. Esto ayuda a evitar la pérdida de registros al reiniciar el contenedor.
+ **Almacenamiento en búfer a nivel de entrada**: puede configurar los límites del búfer de memoria directamente en el complemento de entrada mediante `Mem_Buf_Limit`, lo que proporciona un control más detallado del uso de la memoria.
+ **Evita la sobrecarga de Docker**: los registros pasan directamente de un archivo a Fluent Bit, sin pasar por los búferes de registro de Docker.
Para utilizar este enfoque, la aplicación debe escribir los registros en los archivos en lugar de hacerlo `stdout`. Tanto el contenedor de aplicaciones como el contenedor de Fluent Bit montan un volumen compartido donde se almacenan los archivos de registro.
El siguiente ejemplo muestra una configuración de entrada secundaria con las mejores prácticas:
```
[INPUT]
Name tail
# File path or glob pattern to tail
Path /var/log/app.log
# Database file for storing file offsets (enables resuming after restart)
DB /var/log/flb_tail.db
# when true, controls that only fluent-bit will access the database (improves performance)
DB.locking true
# Skip long lines instead of skipping the entire file
Skip_Long_Lines On
# How often (in seconds) to check for new files matching the glob pattern
Refresh_Interval 10
# Extra seconds to monitor a file after rotation to account for pending flush
Rotate_Wait 30
# Maximum size of the buffer for a single line
Buffer_Max_Size 10MB
# Initial allocation size for reading file data
Buffer_Chunk_Size 1MB
# Maximum memory buffer size (tail pauses when full)
Mem_Buf_Limit 75MB
```
Cuando utilice el complemento de entrada trasera, tenga en cuenta lo siguiente:
+ Implemente la rotación de registros en los registros de sus aplicaciones para evitar que se agote el disco. Supervise las métricas de volumen subyacentes para medir el rendimiento.
+ Considere configuraciones como `Ignore_Older`, `Read_from_Head` y analizadores multilínea según el formato de registro.
Para obtener más información, consulte [Entrada trasera](https://docs.fluentbit.io/manual/pipeline/inputs/tail) en la documentación de Fluent Bit. Si desea conocer las prácticas recomendadas, consulte la sección [Configuración de entrada trasera con las prácticas recomendadas](https://github.com/aws/aws-for-fluent-bit/blob/mainline/troubleshooting/debugging.md#tail-config-with-best-practices) en la guía de solución de problemas de AWS para Fluent Bit.
## Iniciar sesión directamente en FireLens
Cuando se especifica el controlador de registros `awsfirelens` en una definición de tarea, el agente de contenedor de Amazon ECS introduce las siguientes variables de entorno en el contenedor:
`FLUENT_HOST`
La dirección IP que está asignada al contenedor FireLens.
Si utiliza EC2 con el modo de red `bridge`, la variable de entorno `FLUENT_HOST` del contenedor de aplicaciones puede dejar de ser precisa tras reiniciar el contenedor del router de registro de FireLens (el contenedor con el objeto `firelensConfiguration` en su definición de contenedor). Esto se debe a que `FLUENT_HOST` es una dirección IP dinámica y puede cambiar tras un reinicio. El registro directo desde el contenedor de la aplicación en la dirección IP `FLUENT_HOST` puede empezar a fallar después de que la dirección cambie. Para obtener más información acerca de cómo reiniciar contenedores individuales, consulte [Reinicio de contenedores individuales en tareas de Amazon ECS con políticas de reinicio de contenedores](container-restart-policy.md).
`FLUENT_PORT`
El puerto en el que se está escuchando el protocolo Fluent Forward.
Puede utilizar estas variables de entorno para enviar registros directamente al enrutador de registro de Fluent Bit desde el código de su aplicación mediante el protocolo Fluent Forward, en lugar de escribir en `stdout`. Este enfoque evita la capa de controladores de registro de Docker, lo que proporciona las siguientes ventajas:
+ **Menor latencia**: los registros se transfieren directamente a Fluent Bit sin pasar por la infraestructura de registro de Docker.
+ **Registro estructurado**: envíe datos de registro estructurados de forma nativa sin sobrecargas de codificación JSON.
+ **Mejor control**: su aplicación puede implementar su propia lógica de almacenamiento en búfer y gestión de errores.
Las siguientes bibliotecas de registradores de Fluent son compatibles con el protocolo Fluent Forward y se pueden utilizar para enviar los registros directamente a Fluent Bit:
+ **Go**: [fluent-logger-golang](https://github.com/fluent/fluent-logger-golang)
+ **Python**: [fluent-logger-python](https://github.com/fluent/fluent-logger-python)
+ **Java**: [fluent-logger-java](https://github.com/fluent/fluent-logger-java)
+ **Node.js**: [fluent-logger-node](https://github.com/fluent/fluent-logger-node)
+ **Ruby**: [fluent-logger-ruby](https://github.com/fluent/fluent-logger-ruby)
## Configurar el límite de búfer de Docker
Al crear una definición de tareas, puede indicar el número de líneas de registro que se almacenan en búfer en la memoria mediante la especificación del valor en `log-driver-buffer-limit`. Esto controla el búfer entre Docker y Fluent Bit. Para obtener más información, consulte [Controladores de registro Fluentd](https://docs.docker.com/engine/logging/drivers/fluentd/) en la documentación de Docker.
Utilice esta opción cuando haya un alto rendimiento, ya que Docker podría quedarse sin memoria de búfer y descartar mensajes de búfer para poder agregar nuevos mensajes.
Tenga en cuenta lo siguiente cuando utilice esta opción:
+ Esta opción se admite en el tipo de EC2 y de Fargate con la versión de la plataforma `1.4.0` o posterior.
+ La opción solo es válida cuando `logDriver` se establece en `awsfirelens`.
+ El límite de búfer predeterminado es de `1048576` líneas de registro.
+ El límite del búfer debe ser igual o mayor que `0` y menor que las líneas de registro `536870912`.
+ La cantidad máxima de memoria utilizada para este búfer es el producto del tamaño de cada línea de registro y el tamaño del búfer. Por ejemplo, si las líneas de registro de la aplicación tienen un promedio de `2` KiB, un límite de búfer de 4096 utilizaría como máximo `8` MiB. La cantidad total de memoria asignada a nivel de tarea debe ser superior a la cantidad de memoria asignada a todos los contenedores, además del búfer de memoria del controlador de registro.
La siguiente definición de tarea muestra cómo configurar `log-driver-buffer-limit`:
```
{
"containerDefinitions": [
{
"name": "my_service_log_router",
"image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:3",
"cpu": 0,
"memoryReservation": 51,
"essential": true,
"firelensConfiguration": {
"type": "fluentbit"
}
},
{
"essential": true,
"image": "public.ecr.aws/docker/library/httpd:latest",
"name": "app",
"logConfiguration": {
"logDriver": "awsfirelens",
"options": {
"Name": "firehose",
"region": "us-west-2",
"delivery_stream": "my-stream",
"log-driver-buffer-limit": "52428800"
}
},
"dependsOn": [
{
"containerName": "my_service_log_router",
"condition": "START"
}
],
"memoryReservation": 100
}
]
}
```
# AWS para repositorios de imágenes de Fluent Bit para Amazon ECS
AWS proporciona una imagen de Fluent Bit con complementos para Registros de CloudWatch y Firehose. Recomendamos usar Fluent Bit como router de registro porque tiene una tasa de utilización de recursos más baja que Fluentd. Para obtener más información, consulte [CloudWatch Logs para Fluent Bit](https://github.com/aws/amazon-cloudwatch-logs-for-fluent-bit) y [Amazon Kinesis Firehose para Fluent Bit](https://github.com/aws/amazon-kinesis-firehose-for-fluent-bit).
La imagen de **AWS para Fluent Bit** está disponible en Galería pública de Amazon ECR y en un repositorio de Amazon ECR para lograr una alta disponibilidad.
## Galería pública de Amazon ECR
La imagen de AWS para Fluent Bit está disponible en la galería pública de Amazon ECR. Esta es la ubicación recomendada para descargar la imagen de AWS para Fluent Bit, ya que es un repositorio público y está disponible para su uso desde todas las Regiones de AWS. Para obtener más información, consulte [aws-por-fluent-bit](https://gallery.ecr.aws/aws-observability/aws-for-fluent-bit) en la galería pública de Amazon ECR.
### Linux
La imagen de AWS para Fluent Bit de la galería pública de Amazon ECR es compatible con el sistema operativo Amazon Linux con la arquitectura `ARM64` o `x86-64`.
Para extraer la imagen de AWS para Fluent Bit de la galería pública de Amazon ECR, puede especificar la URL del repositorio con la etiqueta de imagen deseada. Para ver las etiquetas de imágenes disponibles, consulte la pestaña **Image tags** (Etiquetas de imágenes) en la galería pública de Amazon ECR.
A continuación, se muestra la sintaxis que se debe usar para la CLI de Docker.
```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:tag
```
Por ejemplo, puede extraer la imagen más reciente de la familia “3.x” de versiones de AWS para Fluent Bit mediante este comando de la CLI de Docker.
```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:3
```
**nota**
Se permiten extracciones sin autenticación, pero tienen un límite de tasa inferior al de las extracciones autenticadas. Para autenticar el uso de la cuenta de AWS antes de la extracción, utilice el comando a continuación.
```
aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
```
#### AWS para Fluent Bit 3.0.0
Además de las versiones `2.x` existentes de AWS para Fluent Bit, AWS para Fluent Bit admite una nueva versión `3.x` principal. La nueva versión principal incluye la actualización de imágenes de Amazon Linux 2 a Amazon Linux 2023 y de la versión de Fluent Bit `1.9.10` a la `4.1.1`. Para obtener más información, consulte el [repositorio de AWS para Fluent Bit](https://github.com/aws/aws-for-fluent-bit/blob/mainline/VERSIONS.md) en GitHub.
En los ejemplos siguientes se muestran las etiquetas actualizadas de las imágenes de AWS para Fluent Bit `3.x`.
Puede utilizar etiquetas de la arquitectura múltiple para la imagen de AWS para Fluent Bit.
```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:3
```
### Windows
La imagen Fluent Bit de AWS de la galería pública de Amazon ECR es compatible con la arquitectura `AMD64` con los siguientes sistemas operativos:
+ Windows Server 2022 Full
+ Windows Server 2022 Core
+ Windows Server 2019 Full
+ Windows Server 2019 Core
Los contenedores de Windows que están en AWS Fargate no admiten FireLens.
Para extraer la imagen de AWS para Fluent Bit de la galería pública de Amazon ECR, puede especificar la URL del repositorio con la etiqueta de imagen deseada. Para ver las etiquetas de imágenes disponibles, consulte la pestaña **Image tags** (Etiquetas de imágenes) en la galería pública de Amazon ECR.
A continuación, se muestra la sintaxis que se debe usar para la CLI de Docker.
```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:tag
```
Por ejemplo, para extraer la imagen de AWS para Fluent Bit estable más nueva, puede utilizar este comando de la CLI de Docker.
```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:windowsservercore-stable
```
**nota**
Se permiten extracciones sin autenticación, pero tienen un límite de tasa inferior al de las extracciones autenticadas. Para autenticar el uso de la cuenta de AWS antes de la extracción, utilice el comando a continuación.
```
aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
```
## Amazon ECR
La imagen de AWS para Fluent Bit está disponible en Amazon ECR para lograr alta disponibilidad. Los comandos siguientes se pueden utilizar para recuperar los URI de las imágenes y establecer la disponibilidad de las imágenes en una Región de AWS determinada.
### Linux
Para recuperar la URI de la imagen de AWS para Fluent Bit más estable, utilice el siguiente comando.
```
aws ssm get-parameters \
--names /aws/service/aws-for-fluent-bit/stable \
--region us-east-1
```
Para obtener una lista de todas las versiones de la imagen de AWS para Fluent Bit y consultar el parámetro del Parameter Store de Systems Manager, utilice el siguiente comando.
```
aws ssm get-parameters-by-path \
--path /aws/service/aws-for-fluent-bit \
--region us-east-1
```
Para consultar la imagen de AWS para Fluent Bit estable más nueva en una plantilla de CloudFormation, puede hacer referencia al nombre del almacén de parámetros de Systems Manager. A continuación, se muestra un ejemplo:
```
Parameters:
FireLensImage:
Description: Fluent Bit image for the FireLens Container
Type: AWS::SSM::Parameter::Value
Default: /aws/service/aws-for-fluent-bit/stable
```
**nota**
Si se produce un error en el comando o no hay ningún resultado, la imagen no está disponible en la Región de AWS en la que se llama al comando.
### Windows
Para recuperar la URI de la imagen de AWS para Fluent Bit más estable, utilice el siguiente comando.
```
aws ssm get-parameters \
--names /aws/service/aws-for-fluent-bit/windowsservercore-stable \
--region us-east-1
```
Para obtener una lista de todas las versiones de la imagen de AWS para Fluent Bit y consultar el parámetro del Parameter Store de Systems Manager, utilice el siguiente comando.
```
aws ssm get-parameters-by-path \
--path /aws/service/aws-for-fluent-bit/windowsservercore \
--region us-east-1
```
Para consultar la imagen de AWS para Fluent Bit más estable en una plantilla de CloudFormation, puede hacer referencia al nombre del Parameter Store de Systems Manager. A continuación, se muestra un ejemplo:
```
Parameters:
FireLensImage:
Description: Fluent Bit image for the FireLens Container
Type: AWS::SSM::Parameter::Value
Default: /aws/service/aws-for-fluent-bit/windowsservercore-stable
```
# Definición de tareas de Amazon ECS de ejemplo: enrutar registros a FireLens
Para utilizar el enrutamiento de registros personalizado con FireLens, debe especificar lo siguiente en la definición de tareas:
+ Un contenedor del enrutador de registros que incluye una configuración de FireLens. Recomendamos que el contenedor se marque como `essential`.
+ Uno o varios contenedores de aplicaciones que incluyen una configuración de registro que especifica el controlador de registros `awsfirelens`.
+ Un nombre de recurso de Amazon (ARN) de rol de IAM de tarea que incluya los permisos necesarios para que la tarea envíe los registros.
Al crear una nueva definición de tarea mediante la Consola de administración de AWS, hay una sección de integración de FireLens que permite añadir fácilmente un contenedor de router de registros. Para obtener más información, consulte [Creación de una definición de tareas de Amazon ECS mediante la consola](create-task-definition.md).
Amazon ECS convierte la configuración de registros y genera la configuración de salida de Fluentd o Fluent Bit. La configuración de salida se monta en el contenedor de enrutamiento de registros en `/fluent-bit/etc/fluent-bit.conf` para Fluent Bit y `/fluentd/etc/fluent.conf` para Fluentd.
**importante**
FireLens escucha en el puerto `24224`. Por lo tanto, para asegurarse de que el direccionador de registros FireLens no sea accesible fuera de la tarea, debe permitir la entrada de tráfico en el puerto `24224` en el grupo de seguridad que utiliza la tarea. Para tareas que utilizan el modo de red `awsvpc`, es el grupo de seguridad asociado a la tarea. Para tareas que utilizan el modo de red `host`, es el grupo de seguridad asociado a la instancia de Amazon EC2 que aloja la tarea. Para tareas que utilizan el modo de red `bridge`, no cree asignaciones de puertos que utilicen el puerto `24224`.
De forma predeterminada, Amazon ECS agrega campos adicionales a las entradas de registro, que ayudan a identificar su origen.
+ `ecs_cluster`: el nombre del clúster del que forma parte la tarea.
+ `ecs_task_arn`: nombre de recurso de Amazon (ARN) de la tarea de la que el contenedor forma parte.
+ `ecs_task_definition`: el nombre y la revisión de la definición de tareas que utiliza la tarea.
+ `ec2_instance_id`: el ID de la instancia de Amazon EC2 en la que está alojado el contenedor. Este campo solo es válido para las tareas que utilizan el tipo de lanzamiento EC2.
Puede establecer `enable-ecs-log-metadata` en `false` si no quiere los metadatos.
En el siguiente ejemplo de definición de tarea, se define un contenedor de enrutamiento de registros que utiliza Fluent Bit para enrutar sus registros a CloudWatch Logs. También define un contenedor de aplicaciones que utiliza una configuración de registros para dirigirlos a Amazon Data Firehose y establecer en 2 MiB la memoria que se utiliza para guardar en búfer los eventos.
**nota**
Para ver más ejemplos de definiciones de tareas, consulte [Ejemplos de FireLens en Amazon ECS](https://github.com/aws-samples/amazon-ecs-firelens-examples) en GitHub.
```
{
"family": "firelens-example-firehose",
"taskRoleArn": "arn:aws:iam::123456789012:role/ecs_task_iam_role",
"containerDefinitions": [
{
"name": "log_router",
"image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:3",
"cpu": 0,
"memoryReservation": 51,
"portMappings": [],
"essential": true,
"environment": [],
"mountPoints": [],
"volumesFrom": [],
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/ecs-aws-firelens-sidecar-container",
"mode": "non-blocking",
"awslogs-create-group": "true",
"max-buffer-size": "25m",
"awslogs-region": "us-east-1",
"awslogs-stream-prefix": "firelens"
},
"secretOptions": []
},
"systemControls": [],
"firelensConfiguration": {
"type": "fluentbit"
}
},
{
"essential": true,
"image": "public.ecr.aws/docker/library/httpd:latest",
"name": "app",
"logConfiguration": {
"logDriver": "awsfirelens",
"options": {
"Name": "firehose",
"region": "us-west-2",
"delivery_stream": "my-stream",
"log-driver-buffer-limit": "1048576"
}
},
"memoryReservation": 100
}
]
}
```
Los pares de clave-valor especificados como opciones en el objeto `logConfiguration` se utilizan para generar la configuración de salida de Fluentd o Fluent Bit. A continuación, se muestra un ejemplo de código de una definición de salida de Fluent Bit.
```
[OUTPUT]
Name firehose
Match app-firelens*
region us-west-2
delivery_stream my-stream
```
**nota**
FireLens administra la configuración `match`. No se especifica la configuración de `match` en la definición de tarea.
## Uso de un archivo de configuración personalizado
Puede especificar un archivo de configuración personalizado. El formato del archivo de configuración es el formato nativo del enrutador de registros que está utilizando. Para obtener más información, consulte [Fluentd Config File Syntax](https://docs.fluentd.org/configuration/config-file) y [YAML Configuration](https://docs.fluentbit.io/manual/administration/configuring-fluent-bit/yaml).
En el archivo de configuración personalizado, en el caso de las tareas que utilizan el modo de red `bridge` o `awsvpc`, no establezca una entrada directa Fluentd o Fluent Bit a través de TCP porque FireLens la agrega a la configuración de entrada.
La configuración de FireLens debe incluir las siguientes opciones para especificar un archivo de configuración personalizado:
`config-file-type`
La ubicación de origen del archivo de configuración personalizado. Las opciones disponibles son `s3` o `file`.
Las tareas que están alojadas en AWS Fargate solo admiten el tipo de archivo de configuración `file`. Sin embargo, puede usar los archivos de configuración alojados en Amazon S3 en AWS Fargate mediante el contenedor init de AWS para Fluent Bit. Para obtener más información, consulte [Proceso de init para Fluent Bit en ECS, compatibilidad con configuraciones múltiples](https://github.com/aws/aws-for-fluent-bit/blob/mainline/use_cases/init-process-for-fluent-bit/README.md) en GitHub.
`config-file-value`
El origen del archivo de configuración personalizado. Si se utiliza el tipo de archivo de configuración `s3`, el valor del archivo de configuración es el ARN completo del bucket y el archivo de Amazon S3. Si se utiliza el tipo de archivo de configuración `file`, el valor del archivo de configuración es la ruta completa del archivo de configuración que existe en la imagen del contenedor o en un volumen que se monta en el contenedor.
Cuando se utilice un archivo de configuración personalizado, se debe especificar una ruta diferente a la que utiliza FireLens. Amazon ECS reserva la ruta de archivo `/fluent-bit/etc/fluent-bit.conf` para Fluent Bit y la `/fluentd/etc/fluent.conf` para Fluentd.
En el ejemplo siguiente se muestra la sintaxis necesaria al especificar una configuración personalizada.
**importante**
Para especificar un archivo de configuración personalizado alojado en Amazon S3, asegúrese de haber creado un rol de IAM de ejecución de tareas con los permisos adecuados.
A continuación se muestra la sintaxis necesaria al especificar una configuración personalizada.
```
{
"containerDefinitions": [
{
"essential": true,
"image": "906394416424.dkr.ecr.us-west-2.amazonaws.com/aws-for-fluent-bit:3",
"name": "log_router",
"firelensConfiguration": {
"type": "fluentbit",
"options": {
"config-file-type": "s3 | file",
"config-file-value": "arn:aws:s3:::amzn-s3-demo-bucket/fluent.conf | filepath"
}
}
}
]
}
```
**nota**
Las tareas alojadas en AWS Fargate solo admiten el tipo de archivo de configuración `file`. Sin embargo, puede usar los archivos de configuración alojados en Amazon S3 en AWS Fargate mediante el contenedor init de AWS para Fluent Bit. Para obtener más información, consulte [Proceso de init para Fluent Bit en ECS, compatibilidad con configuraciones múltiples](https://github.com/aws/aws-for-fluent-bit/blob/mainline/use_cases/init-process-for-fluent-bit/README.md) en GitHub.