**Ayude a mejorar esta página** 

Para contribuir a esta guía del usuario, elija el enlace **Edit this page on GitHub** que se encuentra en el panel derecho de cada página.

# Inicio del registro de AWS Fargate para un clúster
<a name="fargate-logging"></a>

Amazon EKS en Fargate ofrece un enrutador de registros integrado basado en Fluent Bit. Esto significa que no ejecuta explícitamente un contenedor de Fluent Bit como archivo sidecar, sino que Amazon lo ejecuta. Todo lo que tiene que hacer es configurar el enrutador de registros. La configuración se realiza a través de un `ConfigMap` dedicado que debe cumplir los siguientes criterios:
+ Tener un `aws-logging` con nombre. 
+ Haber sido creado en un espacio de nombres dedicado llamado `aws-observability`. 
+ No puede superar los 5300 caracteres.

Una vez que haya creado el `ConfigMap`, Amazon EKS en Fargate lo detecta automáticamente y configura el enrutador de registros con él. Fargate utiliza una versión de AWS para Fluent Bit, una distribución conforme del cliente al servidor de Fluent Bit administrada por AWS. Para obtener más información, consulte [AWS para Fluent Bit](https://github.com/aws/aws-for-fluent-bit) en GitHub.

El enrutador de registros le permite utilizar la amplia gama de servicios de AWS para el análisis y el almacenamiento de registros. Puede transmitir registros desde Fargate directamente a Amazon CloudWatch, Amazon OpenSearch Service. También puede transmitir registros a destinos como [Amazon S3](https://aws.amazon.com/s3/), [Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/) y herramientas de socios a través de [Amazon Data Firehose](https://aws.amazon.com/kinesis/data-firehose/).
+ Un perfil de Fargate existente que especifica un espacio de nombres de Kubernetes existente en el que se implementan pods de Fargate. Para obtener más información, consulte [Paso 3: creación de un perfil de Fargate para el clúster](fargate-getting-started.md#fargate-gs-create-profile).
+ Un rol de ejecución de pods de Fargate existente. Para obtener más información, consulte [Paso 2: creación de un rol de ejecución de pods de Fargate](fargate-getting-started.md#fargate-sg-pod-execution-role).

## Configuración del enrutador de registros
<a name="fargate-logging-log-router-configuration"></a>

**importante**  
Para que los registros se publiquen correctamente, debe haber acceso de red desde la VPC en la que se encuentra el clúster hasta el destino de los registros. Esto se aplica principalmente a los usuarios que personalizan las reglas de salida de la VPC. Para ver un ejemplo con CloudWatch, consulte la sección *Uso de Registros de CloudWatch con puntos de conexión de VPC de interfaz* en la [Guía del usuario de los Registros de Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html).

En los siguientes pasos, reemplace cada *valor de ejemplo* por valores propios.

1. Cree un espacio de nombres de Kubernetes dedicado llamado `aws-observability`.

   1. Guarde el siguiente contenido en un archivo llamado `aws-observability-namespace.yaml` en el equipo. El valor de `name` debe ser `aws-observability` y la etiqueta `aws-observability: enabled` es obligatoria.

      ```
      kind: Namespace
      apiVersion: v1
      metadata:
        name: aws-observability
        labels:
          aws-observability: enabled
      ```

   1. Cree el espacio de nombres.

      ```
      kubectl apply -f aws-observability-namespace.yaml
      ```

1. Cree un `ConfigMap` con un valor de datos de `Fluent Conf` para enviar los registros de contenedores a un destino. Fluent Conf es Fluent Bit, que es un lenguaje de configuración del procesador de registros rápido y ligero que se utiliza para dirigir los registros del contenedor a un destino de registro de su elección. Para obtener más información, consulte [Archivo de configuración](https://docs.fluentbit.io/manual/administration/configuring-fluent-bit/classic-mode/configuration-file) en la documentación de Fluent Bit.
**importante**  
En un `Fluent Conf` típico, las secciones principales incluidas son `Service`, `Input`, `Filter` y `Output`. Sin embargo, el enrutador de registros de Fargate solo acepta:  
Las secciones `Filter` y `Output`.
Una sección `Parser`.
Si proporciona otras secciones, se rechazarán.

   El enrutador de registros de Fargate administra las secciones `Service` e `Input`. Tiene la siguiente sección `Input`, la cual no se puede modificar y no es necesaria en su `ConfigMap`. Sin embargo, puede obtener información a partir de ella, como el límite del búfer de memoria y la etiqueta aplicada a los registros.

   ```
   [INPUT]
       Name tail
       Buffer_Max_Size 66KB
       DB /var/log/flb_kube.db
       Mem_Buf_Limit 45MB
       Path /var/log/containers/*.log
       Read_From_Head On
       Refresh_Interval 10
       Rotate_Wait 30
       Skip_Long_Lines On
       Tag kube.*
   ```

   Al crear el `ConfigMap`, debe tener en cuenta las siguientes reglas que Fargate utiliza para validar campos:
   +  Se supone que `[FILTER]`, `[OUTPUT]` y `[PARSER]` deben especificarse en cada clave correspondiente. Por ejemplo, `[FILTER]` debe estar en `filters.conf`. Puede tener uno o más `[FILTER]` en `filters.conf`. Las secciones `[OUTPUT]` y `[PARSER]` también deben estar en sus claves correspondientes. Mediante la especificación de varias secciones `[OUTPUT]`, puede dirigir sus registros a diferentes destinos al mismo tiempo.
   + Fargate valida las claves requeridas para cada sección. `Name` y `match` son necesarias para cada `[FILTER]` y `[OUTPUT]`. `Name` y `format` son necesarias para cada `[PARSER]`. Las claves distinguen entre mayúsculas y minúsculas.
   + Las variables de entorno, como `${ENV_VAR}` no se permiten en `ConfigMap`.
   + La sangría tiene que ser la misma para la política o el par clave-valor dentro de cada `filters.conf`, `output.conf` y `parsers.conf`. Los pares clave-valor deben tener más sangría que las políticas.
   + Fargate valida con los siguientes filtros compatibles: `grep`, `parser`, `record_modifier`, `rewrite_tag`, `throttle`, `nest`, `modify` y `kubernetes`.
   + Fargate verifica las siguientes salidas compatibles: `es`, `firehose`, `kinesis_firehose`, `cloudwatch`, `cloudwatch_logs` y `kinesis`.
   + Se debe proporcionar al menos un complemento de `Output` compatible en el `ConfigMap` a fin de habilitar el registro. `Filter` y `Parser` no son necesarios para habilitar el registro.

     También puede ejecutar Fluent Bit en Amazon EC2 con la configuración deseada para solucionar cualquier problema que surja de la validación. Cree su `ConfigMap` con uno de los siguientes ejemplos.
**importante**  
El registro de Fargate de Amazon EKS no admite la configuración dinámica del `ConfigMap`. Cualquier cambio en `ConfigMap` solo se aplica a los pods nuevos. Los cambios no se aplican a los pods existentes.

     Cree un `ConfigMap` con el ejemplo para el destino de registro deseado.
**nota**  
También puede utilizar Amazon Kinesis Data Streams como destino para su registro. Si usa Kinesis Data Streams, asegúrese de que la función de ejecución del pod tenga otorgado el permiso `kinesis:PutRecords`. Para obtener más información, consulte [Permisos](https://docs.fluentbit.io/manual/pipeline/outputs/kinesis#permissions) de Amazon Kinesis Data Streams en * Fluent Bit: Manual oficial*.  
**Example**  

------
#### [ CloudWatch ]

   Tiene dos opciones de salida al utilizar CloudWatch:
   +  [Un complemento de salida escrito en C](https://docs.fluentbit.io/manual/v/1.5/pipeline/outputs/cloudwatch) 
   +  [Un complemento de salida escrito en Golang](https://github.com/aws/amazon-cloudwatch-logs-for-fluent-bit) 

   En el siguiente ejemplo se muestra cómo utilizar el complemento de `cloudwatch_logs` para enviar registros a CloudWatch.

   1. Guarde los siguientes contenidos en un archivo llamado `aws-logging-cloudwatch-configmap.yaml`. Reemplace *region-code* por la región de AWS en la que se encuentra el clúster. Se requieren los parámetros en `[OUTPUT]`.

      ```
      kind: ConfigMap
      apiVersion: v1
      metadata:
        name: aws-logging
        namespace: aws-observability
      data:
        flb_log_cw: "false"  # Set to true to ship Fluent Bit process logs to CloudWatch.
        filters.conf: |
          [FILTER]
              Name parser
              Match *
              Key_name log
              Parser crio
          [FILTER]
              Name kubernetes
              Match kube.*
              Merge_Log On
              Keep_Log Off
              Buffer_Size 0
              Kube_Meta_Cache_TTL 300s
        output.conf: |
          [OUTPUT]
              Name cloudwatch_logs
              Match   kube.*
              region region-code
              log_group_name my-logs
              log_stream_prefix from-fluent-bit-
              log_retention_days 60
              auto_create_group true
        parsers.conf: |
          [PARSER]
              Name crio
              Format Regex
              Regex ^(?<time>[^ ]+) (?<stream>stdout|stderr) (?<logtag>P|F) (?<log>.*)$
              Time_Key    time
              Time_Format %Y-%m-%dT%H:%M:%S.%L%z
      ```

   1. Aplique el manifiesto al clúster.

      ```
      kubectl apply -f aws-logging-cloudwatch-configmap.yaml
      ```

------
#### [ Amazon OpenSearch Service ]

   Si desea enviar registros a Amazon OpenSearch Service, puede utilizar la salida [es](https://docs.fluentbit.io/manual/v/1.5/pipeline/outputs/elasticsearch), que es un complemento escrito en C. En el ejemplo siguiente se muestra cómo utilizar el complemento para enviar registros a OpenSearch.

   1. Guarde los siguientes contenidos en un archivo llamado `aws-logging-opensearch-configmap.yaml`. Reemplace los *valores de ejemplo* por sus propios valores.

      ```
      kind: ConfigMap
      apiVersion: v1
      metadata:
        name: aws-logging
        namespace: aws-observability
      data:
        output.conf: |
          [OUTPUT]
            Name  es
            Match *
            Host  search-example-gjxdcilagiprbglqn42jsty66y.region-code.es.amazonaws.com
            Port  443
            Index example
            Type  example_type
            AWS_Auth On
            AWS_Region region-code
            tls   On
      ```

   1. Aplique el manifiesto al clúster.

      ```
      kubectl apply -f aws-logging-opensearch-configmap.yaml
      ```

------
#### [ Firehose ]

   Tiene dos opciones de salida al enviar registros a Firehose:
   +  [kinesis\$1firehose](https://docs.fluentbit.io/manual/pipeline/outputs/firehose): un complemento de salida escrito en C.
   +  [firehose](https://github.com/aws/amazon-kinesis-firehose-for-fluent-bit): un complemento de salida escrito en Golang.

     En el siguiente ejemplo se muestra cómo utilizar el complemento de `kinesis_firehose` para enviar registros a Firehose.

     1. Guarde los siguientes contenidos en un archivo llamado `aws-logging-firehose-configmap.yaml`. Reemplace *region-code* por la región de AWS en la que se encuentra el clúster.

        ```
        kind: ConfigMap
        apiVersion: v1
        metadata:
          name: aws-logging
          namespace: aws-observability
        data:
          output.conf: |
            [OUTPUT]
             Name  kinesis_firehose
             Match *
             region region-code
             delivery_stream my-stream-firehose
        ```

     1. Aplique el manifiesto al clúster.

        ```
        kubectl apply -f aws-logging-firehose-configmap.yaml
        ```

------

1. Configure los permisos del rol de ejecución de pods en Fargate para enviar los registros al destino correspondiente.

   1. Descargue la política de IAM para el destino en su computadora.  
**Example**  

------
#### [ CloudWatch ]

      Descargue la política de IAM de CloudWatch en su equipo. También puede ver la [política](https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/cloudwatchlogs/permissions.json) en GitHub.

      ```
      curl -O https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/cloudwatchlogs/permissions.json
      ```

------
#### [ Amazon OpenSearch Service ]

      Descargue la política de IAM de OpenSearch en su ordenador. También puede ver la [política](https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/amazon-elasticsearch/permissions.json) en GitHub.

      ```
      curl -O https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/amazon-elasticsearch/permissions.json
      ```

      Asegúrese de que el control de acceso de OpenSearch Dashboards esté configurado correctamente. El `all_access role` de OpenSearch Dashboards debe tener el rol de ejecución de pods de Fargate y el rol de IAM asignado. Se debe hacer el mismo mapeo para el rol de `security_manager`. Puede agregar los mapeos anteriores al seleccionar `Menu`, `Security` y `Roles` y, a continuación, seleccionar los roles respectivos. Para obtener más información, consulte [¿Cómo puedo solucionar los problemas de CloudWatch Logs para que transmita a mi dominio de Amazon ES?](https://aws.amazon.com/tr/premiumsupport/knowledge-center/es-troubleshoot-cloudwatch-logs/).

------
#### [ Firehose ]

      Descargue la política de IAM de Firehose en su ordenador. También puede ver la [política](https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/kinesis-firehose/permissions.json) en GitHub.

      ```
      curl -O https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/kinesis-firehose/permissions.json
      ```

------

   1. Cree una política de IAM a partir del archivo de política que descargó.

      ```
      aws iam create-policy --policy-name eks-fargate-logging-policy --policy-document file://permissions.json
      ```

   1. Adjunte la política de IAM al rol de ejecución de pods especificado para el perfil de Fargate con el siguiente comando. Reemplace *111122223333* por el ID de su cuenta. Reemplace *AmazonEKSFargatePodExecutionRole* por el rol de ejecución de pods (para obtener más información, consulte [Paso 2: creación de un rol de ejecución de pods de Fargate](fargate-getting-started.md#fargate-sg-pod-execution-role)).

      ```
      aws iam attach-role-policy \
        --policy-arn arn:aws:iam::111122223333:policy/eks-fargate-logging-policy \
        --role-name AmazonEKSFargatePodExecutionRole
      ```

### Compatibilidad del filtro de Kubernetes
<a name="fargate-logging-kubernetes-filter"></a>

El filtro de Kubernetes de Fluent Bit permite agregar metadatos de Kubernetes a los archivos de registro. Para obtener más información acerca del filtro, consulte [Kubernetes](https://docs.fluentbit.io/manual/pipeline/filters/kubernetes) en la documentación de Fluent Bit. Puede aplicar un filtro mediante el punto de conexión del servidor de la API.

```
filters.conf: |
    [FILTER]
        Name             kubernetes
        Match            kube.*
        Merge_Log           On
        Buffer_Size         0
        Kube_Meta_Cache_TTL 300s
```

**importante**  
 `Kube_URL`, `Kube_CA_File`, `Kube_Token_Command` y `Kube_Token_File` son parámetros de configuración propiedad del servicio y no deben especificarse. Amazon EKS Fargate completa estos valores.
 `Kube_Meta_Cache_TTL` es el tiempo que Fluent Bit espera hasta que se comunica con el servidor de la API para obtener los metadatos más recientes. Si `Kube_Meta_Cache_TTL` no se especifica, Amazon EKS Fargate agrega un valor predeterminado de 30 minutos para reducir la carga en el servidor de la API.

### Envío de registros de procesos de Fluent Bit a su cuenta
<a name="ship-fluent-bit-process-logs"></a>

Opcionalmente, puede enviar registros de procesos de Fluent Bit a Amazon CloudWatch mediante el siguiente `ConfigMap`. El envío de registros de procesos de Fluent Bit a CloudWatch requiere costos adicionales de ingesta y almacenamiento de registros. Reemplace *region-code* por la región de AWS en la que se encuentra el clúster.

```
kind: ConfigMap
apiVersion: v1
metadata:
  name: aws-logging
  namespace: aws-observability
  labels:
data:
  # Configuration files: server, input, filters and output
  # ======================================================
  flb_log_cw: "true"  # Ships Fluent Bit process logs to CloudWatch.

  output.conf: |
    [OUTPUT]
        Name cloudwatch
        Match kube.*
        region region-code
        log_group_name fluent-bit-cloudwatch
        log_stream_prefix from-fluent-bit-
        auto_create_group true
```

Los registros se encuentran en CloudWatch, en la misma región de AWS que el clúster. El nombre del grupo de registros es ` my-cluster-fluent-bit-logs` y el nombre del flujo de registros de Fluent Bit es `fluent-bit-podname-pod-namespace `.

**nota**  
Los registros de proceso se envían solo cuando el proceso de Fluent Bit se inicia de forma correcta. Si se produce un error al iniciar Fluent Bit, se pierden los registros del proceso. Solo puede enviar los registros del proceso a CloudWatch.
Para depurar los registros del proceso de envío en la cuenta, puede aplicar el `ConfigMap` anterior a fin de obtener los registros del proceso. El hecho de que Fluent Bit no se inicie suele deberse a que Fluent Bit no analiza ni acepta el `ConfigMap` durante el inicio.

### Detención del envío de registros de procesos de Fluent Bit
<a name="stop-fluent-bit-process-logs"></a>

El envío de registros de procesos de Fluent Bit a CloudWatch requiere costos adicionales de ingesta y almacenamiento de registros. Para excluir los registros de procesos de una configuración de `ConfigMap` existente, siga estos pasos.

1. Busque el grupo de registro de CloudWatch creado automáticamente para los registros de procesos de Fluent Bit del clúster de Amazon EKS después de habilitar el registro de Fargate. Sigue el formato ` my-cluster-fluent-bit-logs`.

1. Elimine los flujos de registro de CloudWatch existentes creados para los registros de procesos de cada pod en el grupo de registros de CloudWatch.

1. Edite el `ConfigMap` y configure `flb_log_cw: "false"`.

1. Reinicie todos los pods existentes en el clúster.

## Probar la aplicación
<a name="fargate-logging-test-application"></a>

1. Implemente un pod de ejemplo.

   1. Guarde el siguiente contenido en un archivo llamado `sample-app.yaml` en el equipo.

      ```
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: sample-app
        namespace: same-namespace-as-your-fargate-profile
      spec:
        replicas: 3
        selector:
          matchLabels:
            app: nginx
        template:
          metadata:
            labels:
              app: nginx
          spec:
            containers:
              - name: nginx
                image: nginx:latest
                ports:
                  - name: http
                    containerPort: 80
      ```

   1. Aplique el manifiesto al clúster.

      ```
      kubectl apply -f sample-app.yaml
      ```

1. Visualización de los registros NGINX con los destinos que configuró en el `ConfigMap`.

## Consideraciones sobre el tamaño
<a name="fargate-logging-size-considerations"></a>

Le sugerimos que planee utilizar hasta 50 MB de memoria para el enrutador de registros. Si anticipa que su aplicación generará registros con un rendimiento muy alto, entonces debe planificar utilizar hasta 100 MB.

## Solución de problemas
<a name="fargate-logging-troubleshooting"></a>

Para confirmar si la característica de registro está habilitada o desactivada por algún motivo, como un `ConfigMap` que no es válido y desea saber por qué no es válido, verifique los eventos de pods con `kubectl describe pod pod-name `. La salida puede incluir eventos del pod que aclaran si el registro está habilitado o no, como la siguiente salida de ejemplo.

```
[...]
Annotations:          CapacityProvisioned: 0.25vCPU 0.5GB
                      Logging: LoggingDisabled: LOGGING_CONFIGMAP_NOT_FOUND
[...]
Events:
  Type     Reason           Age        From                                                           Message
  ----     ------           ----       ----                                                           -------
  Warning  LoggingDisabled  <unknown>  fargate-scheduler                                              Disabled logging because aws-logging configmap was not found. configmap "aws-logging" not found
```

Los eventos de pod son efímeros con un periodo de tiempo en función de la configuración. También puede ver las anotaciones de un pod con `kubectl describe pod pod-name `. En la anotación del pod, hay información sobre si la característica de registro está habilitada o desactivada y el motivo.