**Contribuisci a migliorare questa pagina** 

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Per contribuire a questa guida per l'utente, scegli il GitHub link **Modifica questa pagina** nel riquadro destro di ogni pagina.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Avviare la registrazione di log AWS Fargate per il cluster
<a name="fargate-logging"></a>

Amazon EKS su Fargate offre un router di registro integrato basato su Fluent Bit. Ciò significa che non viene eseguito esplicitamente un container Fluent Bit come sidecar, ma è Amazon a eseguirlo. Tutto quello che devi fare è configurare il router di log. La configurazione avviene attraverso un `ConfigMap` dedicato che deve soddisfare i seguenti criteri:
+ Deve essere denominato `aws-logging` 
+ Creato in uno spazio dei nomi dedicato denominato `aws-observability` 
+ Non può contenere più di 5.300 caratteri.

Una volta creato `ConfigMap`, Amazon EKS su Fargate lo rileva in automatico e lo utilizza per configurare il router di log. Fargate utilizza una versione di AWS per Fluent Bit, una distribuzione upstream conforme di Fluent Bit gestita da AWS. Per ulteriori informazioni, consultare [AWS per Fluent Bit](https://github.com/aws/aws-for-fluent-bit) su GitHub.

Il router di log consente di utilizzare la vasta gamma di servizi AWS per l'analisi e per l'archiviazione dei log. È possibile trasmettere i registri da Fargate direttamente ad Amazon CloudWatch, un servizio OpenSearch di Amazon. È possibile trasmettere i log anche a destinazioni come [Amazon S3](https://aws.amazon.com/s3/) e [flusso di dati Amazon Kinesis](https://aws.amazon.com/kinesis/data-streams/), così come a strumenti partner tramite [Amazon Data Firehose](https://aws.amazon.com/kinesis/data-firehose/).
+ Un profilo Fargate esistente che specifichi un namespace Kubernetes esistente in cui si implementano i pod Fargate. Per ulteriori informazioni, consulta [Fase 3: creare un profilo Fargate per il cluster](fargate-getting-started.md#fargate-gs-create-profile).
+ Un ruolo di esecuzione del pod Fargate esistente. Per ulteriori informazioni, consulta [Fase 2: creare un ruolo di esecuzione del pod Fargate](fargate-getting-started.md#fargate-sg-pod-execution-role).

## Configurazione del router di log
<a name="fargate-logging-log-router-configuration"></a>

**Importante**  
Affinché i log vengano pubblicati correttamente, deve essere possibile accedere alla rete dal VPC in cui si trova il cluster alla destinazione dei log. Ciò riguarda principalmente gli utenti che personalizzano le regole di uscita per il VPC. Per ulteriori informazioni sull’utilizzo di CloudWatch, consultare la pagina [Using CloudWatch Logs with interface VPC endpoints](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html) della *Guida per l’utente di Amazon CloudWatch Logs*.

Nelle fasi seguenti, sostituire ogni *valore di esempio* con i propri valori.

1. Creare uno spazio dei nomi Kubernetes dedicato denominato `aws-observability`.

   1. Salva nel tuo computer i seguenti contenuti in un file denominato `aws-observability-namespace.yaml`. Il valore per `name` deve essere `aws-observability` e l'etichetta `aws-observability: enabled` è obbligatoria.

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

   1. Crea lo spazio dei nomi.

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

1. Crea una `ConfigMap` con valore dei dati `Fluent Conf` per spedire i log del container verso una destinazione. Fluent Conf è Fluent Bit, un linguaggio di configurazione del processore di log veloce e leggero che viene utilizzato per instradare i log del container verso una destinazione di log selezionata. Per ulteriori informazioni, consultare [File di configurazione](https://docs.fluentbit.io/manual/administration/configuring-fluent-bit/classic-mode/configuration-file) nella documentazione di Fluent Bit.
**Importante**  
In una `Fluent Conf` tipica, le sezioni principali incluse sono `Service`, `Input`, `Filter` e `Output`. Tuttavia, il router di log di Fargate accetta solo:  
Le sezioni `Filter` e `Output`.
Una sezione `Parser`.
Se fornisci altre sezioni, queste verranno rifiutate.

   Il router di log Fargate gestisce le sezioni `Service` e `Input`. Ha la sezione `Input` seguente, che non può essere modificata e non è necessaria in `ConfigMap`. Tuttavia, è possibile ricavarne informazioni, ad esempio il limite del buffer di memoria e il tag applicato per i log.

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

   Quando crei la `ConfigMap`, ricorda le seguenti regole utilizzate da Fargate per convalidare i campi:
   +  `[FILTER]`, `[OUTPUT]`, e `[PARSER]` dovrebbero essere specificati sotto ogni chiave corrispondente. Ad esempio: `[FILTER]` deve essere in `filters.conf`. È possibile avere uno o più `[FILTER]` in `filters.conf`. Anche le sezioni `[OUTPUT]` e `[PARSER]` dovrebbero essere specificate sotto le chiavi corrispondenti. Specificando più sezioni `[OUTPUT]`, è possibile instradare i registritha a destinazioni diverse contemporaneamente.
   + Fargate convalida le chiavi richieste per ogni sezione. `Name` e `match` sono necessari per ogni `[FILTER]` e `[OUTPUT]`. `Name` e `format` sono necessari per ogni `[PARSER]`. Le chiavi non fanno distinzione tra maiuscole e minuscole.
   + Variabili di ambiente come `${ENV_VAR}` non sono ammesse in `ConfigMap`.
   + La rientranza deve essere la stessa sia per la direttiva che per la coppia chiave-valore all'interno di ogni `filters.conf`, `output.conf` e `parsers.conf`. Le coppie chiave-valore devono essere rientranti piuttosto che direttive.
   + Fargate effettua la convalida in base ai seguenti filtri supportati: `grep`, `parser`, `record_modifier`, `rewrite_tag`, `throttle`, `nest`, `modify` e `kubernetes`.
   + Fargate effettua la convalida in base al seguente output supportato: `es`, `firehose`, `kinesis_firehose`, `cloudwatch`, `cloudwatch_logs`, e `kinesis`.
   + In `ConfigMap` deve essere fornito almeno un plugin `Output` supportato per abilitare la registrazione di log. `Filter` e `Parser` non sono necessari per abilitarla.

     È possibile anche eseguire Fluent Bit su Amazon EC2 utilizzando la configurazione desiderata per risolvere eventuali problemi derivanti dalla convalida. Crea il `ConfigMap` utilizzando uno degli esempi seguenti.
**Importante**  
La registrazione di log Fargate di Amazon EKS non supporta la configurazione dinamica di `ConfigMap`. Eventuali modifiche a `ConfigMap` vengono applicate solo ai nuovi pod. Le modifiche non vengono applicate ai pod esistenti.

     Crea un `ConfigMap` utilizzando l'esempio per la destinazione di log desiderata.
**Nota**  
Puoi anche utilizzare Flusso di dati Amazon Kinesis come destinazione dei log. Se utilizzi Flusso di dati Kinesis, assicurati che al ruolo di esecuzione del pod sia stata concessa l'autorizzazione `kinesis:PutRecords`. Per ulteriori informazioni, consulta la sezione [Permissions](https://docs.fluentbit.io/manual/pipeline/outputs/kinesis#permissions) relativa a flusso di dati Amazon Kinesis in *Fluent Bit: Official Manual*.  
**Example**  

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

   Quando utilizzi CloudWatch, hai a disposizione due opzioni di output:
   +  [Un plug-in di output scritto in C](https://docs.fluentbit.io/manual/v/1.5/pipeline/outputs/cloudwatch) 
   +  [Un plug-in di output scritto in Golang](https://github.com/aws/amazon-cloudwatch-logs-for-fluent-bit) 

   Nell'esempio seguente viene illustrato come utilizzare il plug-in `cloudwatch_logs` per inviare i log a CloudWatch.

   1. Salva i contenuti seguenti in un file denominato `aws-logging-cloudwatch-configmap.yaml`. Sostituire *region-code* con la Regione AWS in cui si trova il cluster. I parametri in `[OUTPUT]` sono obbligatori.

      ```
      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. Applica il manifesto al cluster.

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

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

   Per inviare log al Servizio OpenSearch di Amazon, è possibile utilizzare l’output [es](https://docs.fluentbit.io/manual/v/1.5/pipeline/outputs/elasticsearch), ovvero un plugin scritto in C. L’esempio seguente spiega come utilizzare il plugin per inviare log a OpenSearch.

   1. Salva i contenuti seguenti in un file denominato `aws-logging-opensearch-configmap.yaml`. Sostituire ogni *valore di esempio* con i propri valori.

      ```
      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. Applica il manifesto al cluster.

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

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

   Sono disponibili due opzioni di output per l’invio di log a Firehose:
   +  [kinesis\$1firehose](https://docs.fluentbit.io/manual/pipeline/outputs/firehose): un plugin di output scritto in C.
   +  [firehose](https://github.com/aws/amazon-kinesis-firehose-for-fluent-bit): un plugin di output scritto in Golang.

     Nell’esempio seguente viene illustrato come utilizzare il plugin `kinesis_firehose` per inviare log a Firehose.

     1. Salva i contenuti seguenti in un file denominato `aws-logging-firehose-configmap.yaml`. Sostituire *region-code* con la Regione AWS in cui si trova il cluster.

        ```
        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. Applica il manifesto al cluster.

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

------

1. Configurare le autorizzazioni per il ruolo di esecuzione del pod Fargate per inviare log alla destinazione.

   1. Eseguire il download della policy IAM per la destinazione sul computer.  
**Example**  

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

      Esegui il download della policy IAM CloudWatch sul computer. Puoi anche [consultare la policy](https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/cloudwatchlogs/permissions.json) su GitHub.

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

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

      Esegui il download della policy IAM OpenSearch per il computer. Il [documento di policy](https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/amazon-elasticsearch/permissions.json) può essere visualizzato su GitHub.

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

      Assicurati che il controllo di accesso di OpenSearch Dashboard sia configurato correttamente. `all_access role` in OpenSearch Dashboards deve avere il ruolo di esecuzione del pod Fargate e il ruolo IAM mappati. La stessa mappatura deve essere eseguita per il ruolo `security_manager`. È possibile aggiungere i mapping precedenti selezionando `Menu`, `Security`, `Roles`, quindi selezionare i rispettivi ruoli. Per ulteriori informazioni, consulta [Come posso risolvere i problemi relativi ai File di log CloudWatch in modo che vengano trasmessi al mio dominio Amazon ES?](https://aws.amazon.com/tr/premiumsupport/knowledge-center/es-troubleshoot-cloudwatch-logs/).

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

      Eseguire il download della policy IAM Firehose sul computer Puoi anche [consultare la policy](https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/kinesis-firehose/permissions.json) su GitHub.

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

------

   1. Creare una policy IAM utilizzando il file della policy scaricato nella fase precedente.

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

   1. Collega la policy IAM al ruolo di esecuzione del pod specificato per il profilo Fargate con il seguente comando. Sostituire *111122223333* con l'ID account. Sostituire *AmazonEKSFargatePodExecutionRole* con il ruolo di esecuzione del pod (per ulteriori informazioni, consultare [Fase 2: creare un ruolo di esecuzione del pod 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
      ```

### Supporto filtri Kubernetes
<a name="fargate-logging-kubernetes-filter"></a>

Il filtro Fluent Bit Kubernetes consente di aggiungere metadati Kubernetes ai file di log. Per ulteriori informazioni sul filtro, consultare [Kubernetes](https://docs.fluentbit.io/manual/pipeline/filters/kubernetes) nella documentazione di Fluent Bit. È possibile applicare un filtro utilizzando l'endpoint del server 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` e `Kube_Token_File` sono parametri di configurazione di proprietà del servizio e non devono essere specificati. Amazon EKS Fargate popola questi valori.
 `Kube_Meta_Cache_TTL` è il momento in cui Fluent Bit attende il momento in cui comunica al server API i metadati più recenti. Se `Kube_Meta_Cache_TTL` non è specificato, Amazon EKS Fargate aggiunge un valore predefinito di 30 minuti per ridurre il carico sul server API.

### Per inviare log di processo Fluent Bit all’account
<a name="ship-fluent-bit-process-logs"></a>

È possibile inviare i log di processo Fluent Bit ad Amazon CloudWatch utilizzando la seguente `ConfigMap`. La spedizione dei log di processo Fluent Bit a CloudWatch richiede costi aggiuntivi di acquisizione e archiviazione dei log. Sostituire *region-code* con la Regione AWS in cui si trova il cluster.

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

I log si trovano nella stessa Regione AWS in cui si trova il cluster. Il nome del gruppo di log è ` my-cluster-fluent-bit-logs` e il nome del flusso di log Fluent Bit è `fluent-bit-podname-pod-namespace `.

**Nota**  
I log dei processi vengono spediti solo quando il processo Fluent Bit viene avviato correttamente. Se si verifica un errore durante l'avvio di Fluent Bit, i log di processo vengono mancati. È possibile spedire i log di processo solo a CloudWatch.
Per eseguire il debug della spedizione dei log di processo sull’account, è possibile applicare la `ConfigMap` precedente per ottenere i log di processo. Il mancato avvio di Fluent Bit solitamente è dovuto al fatto che la `ConfigMap` non viene analizzata o accettata da Fluent Bit durante l'avvio.

### Per interrompere l’invio dei log di processo Fluent Bit
<a name="stop-fluent-bit-process-logs"></a>

La spedizione dei log di processo Fluent Bit a CloudWatch richiede costi aggiuntivi di acquisizione e archiviazione dei log. Per escludere i registri dei processii in una configurazione `ConfigMap` esistente, effettua le seguenti operazioni.

1. Individuare il gruppo di log CloudWatch creato automaticamente per i log di processo Fluent Bit del cluster Amazon EKS dopo aver abilitato la registrazione di log Fargate. Segue il formato ` my-cluster-fluent-bit-logs`.

1. Eliminare i flussi di log CloudWatch esistenti creati per i log di processo di ogni pod nel gruppo di log di CloudWatch.

1. Modifica la `ConfigMap` e imposta `flb_log_cw: "false"`.

1. Riavviare tutti i pod esistenti nel cluster.

## Applicazione di prova
<a name="fargate-logging-test-application"></a>

1. Implementare un pod di esempio.

   1. Salva nel tuo computer i seguenti contenuti in un file denominato `sample-app.yaml`.

      ```
      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. Applica il file manifesto al cluster.

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

1. Visualizza i log NGINX utilizzando la/le destinazione/i configurata/e nel `ConfigMap`.

## Considerazioni sulle dimensioni
<a name="fargate-logging-size-considerations"></a>

Si consiglia di pianificare fino a 50 MB di memoria per il router di log. Se prevedi che l'applicazione generi registri a velocità di trasmissione effettiva molto elevata, dovresti pianificarla fino a 100 MB.

## Risoluzione dei problemi
<a name="fargate-logging-troubleshooting"></a>

Per confermare se la funzionalità di registrazione di log è abilitata o disabilitata per qualche motivo, ad esempio per una `ConfigMap` non valida, e perché questa non è valida, controllare gli eventi pod con `kubectl describe pod pod-name `. L’output potrebbe includere eventi pod che chiariscono se la registrazione di log è abilitata o meno, ad esempio l’output di esempio seguente.

```
[...]
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
```

Gli eventi di pod sono effimeri, con un periodo di tempo che dipende dalle impostazioni. È inoltre possibile visualizzare le annotazioni di un pod tramite `kubectl describe pod pod-name `. Nell’annotazione del pod, è possibile sapere se, e per quale motivo, la funzionalità di registrazione di log è abilitata o disabilitata.