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à.
# Inviare i log di Amazon ECS a un servizio o AWS AWS Partner
Puoi utilizzare Amazon ECS FireLens per utilizzare i parametri di definizione delle attività per indirizzare i log verso un AWS servizio o una destinazione AWS Partner Network (APN) per l'archiviazione e l'analisi dei log. AWS Partner Network È una comunità globale di partner che sfrutta programmi, competenze e risorse per creare, commercializzare e vendere offerte ai clienti. Per ulteriori informazioni, consulta [AWS Partner](https://aws.amazon.com/partners/work-with-partners/). FireLens funziona con [Fluentd](https://www.fluentd.org/) e [Fluent Bit](https://fluentbit.io/). Forniamo l'immagine AWS for Fluent Bit oppure puoi utilizzare la tua immagine Fluentd o Fluent Bit.
Per impostazione predefinita, Amazon ECS configura la dipendenza del container in modo che il container Firelens si avvii prima di qualsiasi container che lo utilizza. Inoltre, il container Firelens si ferma dopo che tutti i container che lo utilizzano si fermano.
Per utilizzare questa funzionalità, devi creare un ruolo IAM per le tue attività che fornisca le autorizzazioni necessarie per utilizzare tutti AWS i servizi richiesti dalle attività. Ad esempio, se un container esegue il routing dei log a Firehose, allora l'attività richiede l'autorizzazione per chiamare l'API `firehose:PutRecordBatch`. Per ulteriori informazioni, consulta [Aggiunta e rimozione di autorizzazioni per identità IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) nella *Guida per l'utente di IAM*.
Il processo potrebbe richiedere anche il ruolo di esecuzione del processo di Amazon ECS nelle seguenti condizioni. Per ulteriori informazioni, consulta [Ruolo IAM di esecuzione di attività Amazon ECS](task_execution_IAM_role.md).
+ Se la tua attività è ospitata su Fargate e stai estraendo immagini di container da Amazon ECR o stai facendo riferimento Gestione dei segreti AWS a dati sensibili dalla tua configurazione di registro, devi includere il ruolo IAM di esecuzione dell'attività.
+ Quando si utilizza un file di configurazione personalizzato ospitato in Amazon S3, il ruolo IAM per l'esecuzione dell'attività deve includere l'autorizzazione `s3:GetObject`.
Considera quanto segue quando utilizzi FireLens Amazon ECS:
+ Consigliamo di aggiungere `my_service_` al log del nome del container in modo da poter distinguere facilmente i nomi dei container nella console.
+ Per impostazione predefinita, Amazon ECS aggiunge una dipendenza dall'ordine iniziale del container tra i container dell'applicazione e il container FireLens. Quando si specifica un ordine del container tra i container dell'applicazione e il container FireLens, l'ordine di avvio predefinito del container viene sovrascritto.
+ FireLens per Amazon ECS è supportato per le attività ospitate sia su AWS Fargate su Linux che su Amazon EC2 su Linux. I container di Windows non supportano FireLens.
Per informazioni su come configurare la registrazione centralizzata per i container di Windows, consulta [Registrazione centralizzata per container di Windows su Amazon ECS tramite Fluent Bit](https://aws.amazon.com/blogs/containers/centralized-logging-for-windows-containers-on-amazon-ecs-using-fluent-bit/).
+ Puoi utilizzare CloudFormation modelli FireLens per configurare Amazon ECS. Per ulteriori informazioni, consulta la [AWS::ECS::TaskDefinition FirelensConfiguration](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-firelensconfiguration.html)Guida per l'*AWS CloudFormation utente*
+ FireLensascolta sulla porta`24224`, quindi per garantire che il FireLens log router non sia raggiungibile al di fuori dell'operazione, non devi consentire il traffico `24224` in entrata sulla porta del gruppo di sicurezza utilizzato dall'attività. Per attività che utilizzano la modalità di rete `awsvpc`, questo è il gruppo di sicurezza associato all'attività. Per attività che utilizzano la modalità di rete `host`, questo è il gruppo di sicurezza associato all'istanza Amazon EC2 che ospita l'attività. Per attività che utilizzano la modalità di rete `bridge`, non creare mappature di porte che utilizzano la porta `24224`.
+ Per le attività che utilizzano la modalità di `bridge` rete, il contenitore con la FireLens configurazione deve avviarsi prima dell'avvio di qualsiasi contenitore di applicazioni che si basa su di essa. Per controllare l'ordine di avvio dei container, utilizza le condizioni di dipendenza nella definizione di attività. Per ulteriori informazioni, consulta [Dipendenze per i container](task_definition_parameters.md#container_definition_dependson).
**Nota**
Se utilizzi i parametri delle condizioni di dipendenza nelle definizioni dei contenitori con una FireLens configurazione, assicurati che ogni contenitore abbia un requisito di `HEALTHY` condizione `START` or.
+ Per impostazione predefinita, FireLens aggiunge il nome del cluster e della definizione dell'attività e l'Amazon Resource Name (ARN) del cluster come chiavi di metadati ai stdout/stderr log del contenitore. Di seguito è riportato un esempio del formato dei metadati.
```
"ecs_cluster": "cluster-name",
"ecs_task_arn": "arn:aws:ecs:region:111122223333:task/cluster-name/f2ad7dba413f45ddb4EXAMPLE",
"ecs_task_definition": "task-def-name:revision",
```
Se non desideri i metadati nei tuoi log, imposta `enable-ecs-log-metadata` su `false` nella sezione `firelensConfiguration` della definizione di attività.
```
"firelensConfiguration":{
"type":"fluentbit",
"options":{
"enable-ecs-log-metadata":"false",
"config-file-type":"file",
"config-file-value":"/extra.conf"
}
```
Puoi configurare il FireLens contenitore in modo che venga eseguito come utente non root. Considera i seguenti aspetti:
+ Per configurare il FireLens contenitore in modo che venga eseguito come utente non root, è necessario specificare l'utente in uno dei seguenti formati:
+ `uid`
+ `uid:gid`
+ `uid:group`
Per ulteriori informazioni sulla specificazione di un utente in una definizione di contenitore, consulta [ContainerDefinition](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html)*Amazon Elastic Container Service API Reference*.
Il FireLens contenitore riceve i log delle applicazioni tramite un UNIX socket. L'agente Amazon ECS utilizza il `uid` per assegnare la proprietà della directory socket al FireLens contenitore.
+ La configurazione del FireLens contenitore per l'esecuzione come utente non root è supportata nelle versioni di Amazon ECS Agent `1.96.0` e successive e nelle versioni AMI ottimizzate per Amazon ECS e successive. `v20250716`
+ Quando si specifica un utente per il FireLens contenitore, questo `uid` deve essere univoco e non deve essere utilizzato per altri processi appartenenti ad altri contenitori nell'attività o nell'istanza del contenitore.
Per informazioni su come utilizzare più file di configurazione con Amazon ECS, inclusi i file ospitati o i file in Amazon S3, consultare [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).
Per informazioni sulle configurazioni di esempio, vedere[Esempio di definizione dell'attività Amazon ECS: indirizzare i log a FireLens](firelens-taskdef.md).
Per ulteriori informazioni sulla configurazione dei log per un throughput elevato, vedere. [Configurazione dei log di Amazon ECS per un throughput elevato](firelens-docker-buffer-limit.md)
# Configurazione dei log di Amazon ECS per un throughput elevato
Per scenari con elevata velocità di trasmissione dei log, consigliamo di utilizzare il driver di registro con and. `awsfirelens` FireLens Fluent Bit Fluent Bitè un processore di log leggero, efficiente in termini di risorse e in grado di gestire milioni di record di log. Tuttavia, per ottenere prestazioni ottimali su larga scala è necessario ottimizzarne la configurazione.
Questa sezione illustra le tecniche di Fluent Bit ottimizzazione avanzate per gestire un elevato throughput di log, mantenendo al contempo la stabilità del sistema e garantendo l'assenza di perdita di dati.
Per informazioni su come utilizzare i file di configurazione personalizzati con FireLens, vedere[Utilizzo di un file di configurazione personalizzato](firelens-taskdef.md#firelens-taskdef-customconfig). Per ulteriori esempi, consulta gli [ FireLens esempi di Amazon ECS](https://github.com/aws-samples/amazon-ecs-firelens-examples) su GitHub.
**Nota**
Alcune opzioni di configurazione in questa sezione, come `workers` e`threaded`, richiedono AWS la Fluent Bit versione 3 o successiva. Per informazioni sulle versioni disponibili, vedere le versioni [AWS di Fluent Bit](https://github.com/aws/aws-for-fluent-bit/releases).
## Comprendere i blocchi
Fluent Bit*elabora i dati in unità chiamate blocchi.* Quando un plug-in INPUT riceve dati, il motore crea un blocco che viene archiviato in memoria o sul filesystem prima di essere inviato alle destinazioni OUTPUT.
Il comportamento del buffering dipende dall'`storage.type`impostazione nelle sezioni INPUT. Per impostazione predefinita, Fluent Bit utilizza il buffering della memoria. Per scenari di produzione o ad alta velocità, il buffering del file system offre una migliore resilienza.
[Per ulteriori informazioni, consulta [Chunks nella documentazione e What is a Chunk](https://docs.fluentbit.io/manual/administration/buffering-and-storage#chunks)? Fluent Bit](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/oomkill-prevention#what-is-a-chunk) nel repository AWS for examplesFluent Bit.
## Buffering della memoria (impostazione predefinita)
Per impostazione predefinita, Fluent Bit utilizza il buffering della memoria ()`storage.type memory`. È possibile limitare l'utilizzo della memoria per il plug-in INPUT utilizzando il `Mem_Buf_Limit` parametro.
L'esempio seguente mostra una configurazione di input con buffer di memoria:
```
[INPUT]
Name tcp
Tag ApplicationLogs
Port 5170
storage.type memory
Mem_Buf_Limit 5MB
```
**Importante**
Quando `Mem_Buf_Limit` viene superato per un plugin, mette in Fluent Bit pausa l'input e i nuovi record vengono persi. Ciò può causare una contropressione e rallentare l'applicazione. Nei Fluent Bit registri viene visualizzato il seguente avviso:
```
[input] tcp.1 paused (mem buf overlimit)
```
Il buffering della memoria è adatto per casi d'uso semplici con una velocità di trasmissione dei log da bassa a moderata. Per scenari ad alta produttività o di produzione in cui la perdita di dati è un problema, utilizzate invece il buffering del file system.
Per ulteriori informazioni, vedere [Buffering and Memory nella Fluent Bit documentazione e Memory](https://docs.fluentbit.io/manual/administration/buffering-and-storage#buffering-and-memory) [Buffering](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/oomkill-prevention#case-1-memory-buffering-only-default-or-storagetype-memory) Only nel repository for examples. AWS Fluent Bit
## Buffering del file system
Per scenari con throughput elevato, consigliamo di utilizzare il buffering del file system. [Per ulteriori informazioni su come Fluent Bit gestire il buffering e lo storage, consulta Buffering and Storage nella documentazione.](https://docs.fluentbit.io/manual/administration/buffering-and-storage) Fluent Bit
Il buffering del file system offre i seguenti vantaggi:
+ **Maggiore capacità del buffer**: lo spazio su disco è in genere più abbondante della memoria.
+ **Persistenza**: i dati memorizzati nel buffer sopravvivono ai riavvii. Fluent Bit
+ **Degrado graduale: in caso di errori di** output, i dati si accumulano sul disco anziché causare l'esaurimento della memoria.
Per abilitare il buffering del file system, fornite un file di configurazione personalizzato. Fluent Bit L'esempio seguente mostra la configurazione consigliata:
```
[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
```
Parametri di configurazione chiave:
`storage.path`
La directory in cui Fluent Bit memorizza i blocchi bufferizzati sul disco.
`storage.backlog.flush_on_shutdown`
Se abilitata, Fluent Bit tenta di riportare tutti i blocchi del file system backlog verso le rispettive destinazioni durante l'arresto. Ciò aiuta a garantire la consegna dei dati prima delle interruzioni, ma può aumentare i tempi di spegnimento. Fluent Bit
`storage.max_chunks_up`
Il numero di blocchi che rimangono in memoria. L'impostazione predefinita è 128 blocchi, che possono consumare più di 500 MB di memoria perché ogni blocco può utilizzare fino a 4-5 MB. In ambienti con limiti di memoria, riduci questo valore. Ad esempio, se hai a disposizione 50 MB per il buffering, impostalo su 8-10 blocchi.
`storage.type filesystem`
Abilita l'archiviazione del filesystem per il plug-in di input. Nonostante il nome, Fluent Bit viene utilizzato `mmap` per mappare blocchi sia sulla memoria che sul disco, garantendo la persistenza senza compromettere le prestazioni.
`storage.total_limit_size`
Lo spazio massimo su disco per i dati memorizzati nel buffer per uno specifico plug-in OUTPUT. Quando viene raggiunto questo limite, i record più vecchi relativi a quell'output vengono eliminati. Per ulteriori informazioni sul dimensionamento, vedere[Comprendere `storage.total_limit_size`](#firelens-storage-sizing).
`threaded true`
Esegue l'input nel proprio thread, separato dal ciclo Fluent Bit di eventi principale. Ciò impedisce che gli input lenti blocchino l'intera pipeline.
Per ulteriori informazioni, vedere [Filesystem Buffering nella Fluent Bit documentazione e [Filesystem](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/oomkill-prevention#case-2-filesystem-and-memory-buffering-storagetype-filesystem) and Memory Buffering](https://docs.fluentbit.io/manual/administration/buffering-and-storage#filesystem-buffering) nel repository for examples. AWS Fluent Bit
## Comprendere `storage.total_limit_size`
Il `storage.total_limit_size` parametro su ogni plugin OUTPUT controlla lo spazio massimo su disco per i dati memorizzati nel buffer per quell'output. Quando viene raggiunto questo limite, i record più vecchi relativi a quell'output vengono eliminati per fare spazio a nuovi dati. Quando lo spazio su disco è completamente esaurito, i record Fluent Bit non vengono messi in coda e vengono persi.
Utilizzate la formula seguente per calcolare quella appropriata in `storage.total_limit_size` base alla frequenza di registro e alla finestra di ripristino desiderata:
```
If log rate is in KB/s, convert to MB/s first:
log_rate (MB/s) = log_rate (KB/s) / 1000
storage.total_limit_size (GB) = log_rate (MB/s) × duration (hours) × 3600 (seconds/hour) / 1000 (MB to GB)
```
La tabella seguente mostra esempi di calcoli per le frequenze di registro e le finestre di ripristino comuni:
| Frequenza di registro | 1 ora | 6 ore | 12 ore | 24 ore |
| --- | --- | --- | --- | --- |
| 0,25 MB/s | 0,9 GB | 5,4 GB | 10,8 GB | 21,6 GB |
| 0,5 MB/s | 1,8 GB | 10,8 GB | 21,6 GB | 43,2 GB |
| 1 MB/s | 3,6 GB | 21,6 GB | 43,2 GB | 86,4 GB |
| 5 MB/s | 18 GB | 108 GB | 216 GB | 432 GB |
| 10 MB/s | 36 GB | 216 GB | 432 GB | 864 GB |
[Per osservare il rendimento di picco e scegliere le dimensioni del buffer appropriate, utilizzate il campione di misurazione della produttività. FireLens ](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/measure-throughput)
Utilizzate la formula, i calcoli di esempio e l'analisi comparativa per scegliere un modello adatto `storage.total_limit_size` che fornisca la pista ideale per un recupero ottimale durante un'interruzione.
## Requisiti di archiviazione delle attività di Amazon ECS
Somma tutti i `storage.total_limit_size` valori nelle sezioni OUTPUT e aggiungi il buffer per il sovraccarico. Questo totale determina lo spazio di archiviazione necessario nella definizione delle attività di Amazon ECS. Ad esempio, 3 uscite × 10 GB ciascuna = 30 GB\$1 buffer (5-10 GB) = 35-40 GB totali richiesti. Se il totale supera lo spazio di archiviazione disponibile, è possibile che i record non Fluent Bit vengano messi in coda e che vadano persi.
Sono disponibili le seguenti opzioni di archiviazione:
Bind mount (archiviazione temporanea)
+ Per AWS Fargate, l'impostazione predefinita è 20 GB di spazio di archiviazione temporaneo (massimo 200 GB). Configurare l'utilizzo `ephemeralStorage` nella definizione dell'attività. Per ulteriori informazioni, consulta [EphemeralStorage](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-ephemeralstorage.html) nella *Guida per l'utente di AWS CloudFormation *.
+ Per EC2, l'impostazione predefinita è 30 GB quando si utilizza l'AMI ottimizzata per Amazon ECS (condivisa tra il sistema operativo e Docker). Aumenta modificando la dimensione del volume principale.
Volumi Amazon EBS
+ Fornisce storage a blocchi ad alta disponibilità, duraturo e ad alte prestazioni.
+ Richiede la configurazione del volume e `mountPoint` nella definizione dell'attività indica `storage.path` (impostazione predefinita:`/var/log/flb-storage/`).
+ Per ulteriori informazioni, consulta [Rimanda la configurazione del volume all'ora di avvio nella definizione di un'attività di Amazon ECS](specify-ebs-config.md).
Volumi Amazon EFS
+ Fornisce uno storage di file semplice e scalabile.
+ Richiede la configurazione del volume e `mountPoint` nella definizione dell'attività l'indicazione `storage.path` (impostazione predefinita:`/var/log/flb-storage/`).
+ Per ulteriori informazioni, consulta [Specificare di un file system Amazon EFS nella definizione di un'attività Amazon ECS](specify-efs-config.md).
Per ulteriori informazioni sui volumi di dati, vedere[Opzioni di archiviazione per le attività di Amazon ECS](using_data_volumes.md).
## Ottimizza la configurazione dell'output
Problemi di rete, interruzioni del servizio e limitazione della destinazione possono impedire la consegna dei log. Una corretta configurazione dell'output garantisce la resilienza senza perdita di dati.
Quando un flusso di uscita fallisce, è Fluent Bit possibile riprovare l'operazione. I seguenti parametri controllano il comportamento dei tentativi di ripetizione:
`retry_limit`
Il numero massimo di tentativi dopo il tentativo iniziale prima di eliminare i record. Il valore di default è 1. Ad esempio, `retry_limit 3` significa 4 tentativi totali (1 tentativo iniziale\$13 tentativi). Per gli ambienti di produzione, ne consigliamo 15 o più, che coprono diversi minuti di interruzione con un backoff esponenziale.
Impostato su `no_limits` o per un numero infinito di tentativi`False`:
+ Con il buffering della memoria, infiniti tentativi fanno sì che il plugin di input si interrompa quando vengono raggiunti i limiti di memoria.
+ Con il buffering del filesystem, i record più vecchi vengono eliminati quando vengono raggiunti. `storage.total_limit_size`
Dopo aver esaurito tutti i tentativi (1 tentativo iniziale \$1), i record vengono `retry_limit` eliminati. AWS i plugin con `auto_retry_requests true` (impostazione predefinita) forniscono un livello di riprova aggiuntivo prima del meccanismo di ritentativo. Fluent Bit Per ulteriori informazioni, consulta [Configurare i tentativi](https://docs.fluentbit.io/manual/administration/scheduling-and-retries#configure-retries) nella documentazione. Fluent Bit
Ad esempio, `retry_limit 3` con le impostazioni predefinite (`scheduler.base 5`,`scheduler.cap 2000`,`net.connect_timeout 10s`) fornisce circa 70 secondi di tempo di attesa dello scheduler (10s \$1 20s \$1 40 s), 40 secondi di timeout di connessione di rete (4 tentativi × 10 secondi), più nuovi tentativi di AWS plug-in, per un totale di circa 2-10 minuti a seconda delle condizioni di rete e dei timeout TCP del sistema operativo.
`scheduler.base`
I secondi base tra i tentativi (impostazione predefinita: 5). Consigliamo 10 secondi.
`scheduler.cap`
Il numero massimo di secondi tra un tentativo e l'altro (impostazione predefinita: 2000). Consigliamo 60 secondi.
Il tempo di attesa tra un tentativo e l'altro utilizza il backoff esponenziale con jitter:
```
wait_time = random(base, min(base × 2^retry_number, cap))
```
Ad esempio, con e: `scheduler.base 10` `scheduler.cap 60`
+ Primo tentativo: attesa casuale tra 10 e 20 secondi
+ Secondo tentativo: attesa casuale tra 10 e 40 secondi
+ Terzo tentativo e successivo: attesa casuale compresa tra 10 e 60 secondi (limite)
[Per ulteriori informazioni, consulta [Configurazione del tempo di attesa per un nuovo tentativo e Rete](https://docs.fluentbit.io/manual/administration/scheduling-and-retries#configure-wait-time-for-retry) nella documentazione.](https://docs.fluentbit.io/manual/administration/networking) Fluent Bit
`workers`
Il numero di thread per l'elaborazione parallela dell'output. Più operatori consentono lavaggi simultanei, migliorando la produttività quando si elaborano più blocchi.
`auto_retry_requests`
Un'impostazione AWS specifica del plug-in che fornisce un livello di riprova aggiuntivo prima del meccanismo di ritentativo integrato. Fluent Bit Il valore predefinito è `true`. Se abilitato, il plugin AWS di output riprova internamente le richieste non riuscite prima che la richiesta venga considerata fallita e soggetta alla configurazione. `retry_limit`
Il `Grace` parametro nella `[SERVICE]` sezione imposta il tempo di Fluent Bit attesa durante l'arresto per lo svuotamento dei dati memorizzati nel buffer. Il `Grace` periodo deve essere coordinato con quello del contenitore. `stopTimeout` Assicurarsi che `stopTimeout` superi il `Grace` periodo di tempo necessario per consentire il Fluent Bit completamento del lavaggio prima del ricevimento. `SIGKILL` Ad esempio, se `Grace` è 120 secondi, impostato su `stopTimeout` 150 secondi.
L'esempio seguente mostra una Fluent Bit configurazione completa con tutte le impostazioni consigliate per scenari con throughput elevato:
```
[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
```
## Comprensione degli scenari di perdita di dati
I record possono andare persi durante interruzioni prolungate o problemi con le destinazioni di output. Le raccomandazioni di configurazione contenute in questa guida rappresentano gli approcci migliori per ridurre al minimo la perdita di dati, ma non possono garantire l'assenza di perdite in caso di guasti prolungati. La comprensione di questi scenari aiuta a configurare Fluent Bit per massimizzare la resilienza.
I record possono essere persi in due modi: i record più vecchi vengono eliminati quando lo spazio di archiviazione si esaurisce, oppure i record più recenti vengono rifiutati quando il sistema non può accettare più dati.
### I record più vecchi vengono eliminati
I record memorizzati nel buffer più vecchi vengono eliminati quando i tentativi di riprova sono esauriti o quando `storage.total_limit_size` si esaurisce e occorre fare spazio a nuovi dati.
Limite di tentativi superato
Si verifica dopo un nuovo tentativo del AWS plug-in (se`auto_retry_requests true`) più 1 Fluent Bit tentativo iniziale più nuovi tentativi. `retry_limit` Per mitigare la situazione, impostate un numero infinito di `retry_limit no_limits` tentativi per ogni plugin OUTPUT:
```
[OUTPUT]
Name cloudwatch_logs
Match ApplicationLogs
retry_limit no_limits
auto_retry_requests true
```
I tentativi infiniti impediscono la perdita dei record a causa dell'esaurimento dei tentativi, ma possono causare il riempimento. `storage.total_limit_size`
Limite di archiviazione raggiunto (buffering del file system)
Si verifica quando la destinazione di output non è disponibile per un periodo superiore al buffer CAN configurato. `storage.total_limit_size` Ad esempio, un buffer da 10 GB a una frequenza di MB/s registro fornisce circa 2,7 ore di buffering. Per mitigare, aumenta `storage.total_limit_size` per ogni plug-in OUTPUT e fornisci uno spazio di archiviazione delle attività Amazon ECS adeguato:
```
[OUTPUT]
Name cloudwatch_logs
Match ApplicationLogs
storage.total_limit_size 10G
```
### Record più recenti rifiutati
I record più recenti vengono eliminati quando lo spazio su disco è esaurito o quando l'input viene sospeso a causa di. `Mem_Buf_Limit`
Spazio su disco esaurito (buffering del file system)
Si verifica quando lo spazio su disco è completamente esaurito. Fluent Bitnon riesce a mettere in coda i nuovi record e questi vengono persi. Per mitigare, somma tutti i `storage.total_limit_size` valori e fornisci uno storage di attività Amazon ECS adeguato. Per ulteriori informazioni, consulta [Requisiti di archiviazione delle attività di Amazon ECS](#firelens-storage-task-requirements).
Limite di memoria raggiunto (buffering della memoria)
Si verifica quando la destinazione di output non è disponibile e il buffer di memoria si riempie. I plugin di input in pausa smettono di accettare nuovi record. Per mitigare, usali `storage.type filesystem` per una migliore resilienza o per aumentare. `Mem_Buf_Limit`
### Le migliori pratiche per ridurre al minimo la perdita di dati
Prendi in considerazione le seguenti best practice per ridurre al minimo la perdita di dati:
+ **Usa il buffering del file system: impostato `storage.type filesystem` per una migliore resilienza durante** le interruzioni.
+ **Dimensioni dello storage appropriate**: calcola in `storage.total_limit_size` base alla frequenza di registro e alla finestra di ripristino desiderata.
+ Esegui il **provisioning di un disco adeguato**: assicurati che l'attività Amazon ECS disponga di uno storage temporaneo sufficiente, Amazon EBS o Amazon EFS.
+ **Configura il comportamento dei tentativi**: equilibrio tra `retry_limit` (elimina i record dopo aver esaurito i tentativi) e (riprova all'infinito ma può riempire lo spazio di archiviazione`no_limits`).
## Utilizza la registrazione a più destinazioni per garantire l'affidabilità
L'invio di registri a più destinazioni elimina i singoli punti di errore. Ad esempio, se CloudWatch Logs subisce un'interruzione, i log continuano a raggiungere Amazon S3.
La registrazione multidestinazione offre i seguenti vantaggi. Il plug-in di output Amazon S3 supporta anche opzioni di compressione come gzip e il formato Parquet, che possono ridurre i costi di archiviazione. Per ulteriori informazioni, consulta la sezione [Compressione S3 nella documentazione.](https://docs.fluentbit.io/manual/pipeline/outputs/s3#compression) Fluent Bit
La registrazione multidestinazione può offrire i seguenti vantaggi:
+ **Ridondanza**: se una destinazione fallisce, i log raggiungono comunque l'altra.
+ **Ripristino**: ricostruisci le lacune in un sistema rispetto all'altro.
+ **Durabilità**: archivia i log in Amazon S3 per la conservazione a lungo termine.
+ **Ottimizzazione dei costi**: conserva i log recenti in un servizio di query veloce come CloudWatch Logs con conservazione più breve, mentre archivia tutti i log su uno storage Amazon S3 a basso costo per una conservazione a lungo termine.
La seguente Fluent Bit configurazione invia i log sia a Logs che ad CloudWatch 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
```
Entrambi gli output utilizzano lo stesso `Match *` schema, quindi tutti i record vengono inviati a entrambe le destinazioni in modo indipendente. Durante l'interruzione di una destinazione, i log continuano a fluire verso l'altra, mentre i flush non riusciti si accumulano nel buffer del file system per riprovare in un secondo momento.
## Usa la registrazione basata su file con il plugin tail input
Per scenari ad alta velocità in cui la perdita di log è un problema fondamentale, puoi utilizzare un approccio alternativo: fare in modo che l'applicazione scriva i log sui file su disco e configuri Fluent Bit per leggerli utilizzando il plug-in di input. `tail` Questo approccio aggira completamente il livello dei driver di registrazione Docker.
La registrazione basata su file con il plugin tail offre i seguenti vantaggi:
+ **Tracciamento degli offset**: il plug-in tail può memorizzare gli offset dei file in un file di database (utilizzando l'`DB`opzione), garantendo la durabilità durante i riavvii. Fluent Bit Questo aiuta a prevenire la perdita di log durante il riavvio del contenitore.
+ **Buffering a livello di input**: è possibile configurare i limiti del buffer di memoria direttamente sul plug-in di input utilizzando, in questo modo`Mem_Buf_Limit`, un controllo più granulare sull'utilizzo della memoria.
+ **Evita il sovraccarico di Docker**: i log passano direttamente dal file all'altro senza passare attraverso i buffer di registro di Docker. Fluent Bit
Per utilizzare questo approccio, l'applicazione deve scrivere i log nei file anziché. `stdout` Sia il contenitore dell'applicazione che il Fluent Bit contenitore montano un volume condiviso in cui sono archiviati i file di registro.
L'esempio seguente mostra una configurazione di input di tipo tail con le migliori pratiche:
```
[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
```
Quando usi il plugin tail input, considera quanto segue:
+ Implementate la rotazione dei log per i log delle applicazioni per prevenire l'esaurimento del disco. Monitora le metriche di volume sottostanti per valutare le prestazioni.
+ Prendi in considerazione impostazioni come `Ignore_Older``Read_from_Head`, e parser multilinea in base al formato del registro.
Per ulteriori informazioni, consulta [Tail](https://docs.fluentbit.io/manual/pipeline/inputs/tail) nella Fluent Bit documentazione. Per le migliori pratiche, consulta [Tail config with best practice](https://github.com/aws/aws-for-fluent-bit/blob/mainline/troubleshooting/debugging.md#tail-config-with-best-practices) nella guida AWS per la Fluent Bit risoluzione dei problemi.
## Accedi direttamente a FireLens
Quando il driver di log `awsfirelens` è specificato in una definizione di attività, l'agente Amazon ECS inserisce le seguenti variabili di ambiente nel container:
`FLUENT_HOST`
L'indirizzo IP assegnato al FireLens contenitore.
Se utilizzi EC2 con la modalità di `bridge` rete, la variabile di `FLUENT_HOST` ambiente nel contenitore dell'applicazione può diventare imprecisa dopo il riavvio del contenitore del FireLens log router (il contenitore con l'`firelensConfiguration`oggetto nella definizione del contenitore). Questo perché `FLUENT_HOST` è un indirizzo IP dinamico e può cambiare dopo un riavvio. La registrazione diretta dal container dell'applicazione all'indirizzo IP `FLUENT_HOST` può iniziare a fallire dopo la modifica dell'indirizzo. Per ulteriori informazioni sul riavvio di singoli container, consultare [Riavviare singoli container nelle attività Amazon ECS con policy di riavvio dei container](container-restart-policy.md).
`FLUENT_PORT`
La porta su cui il protocollo Fluent Forward è in ascolto.
Puoi utilizzare queste variabili di ambiente per accedere direttamente al Fluent Bit log router dal codice dell'applicazione utilizzando il protocollo Fluent Forward, anziché scrivere su. `stdout` Questo approccio aggira il livello dei driver di registrazione Docker, che offre i seguenti vantaggi:
+ **Latenza inferiore**: i log vengono inviati direttamente all'infrastruttura di registrazione di Docker Fluent Bit senza passare attraverso l'infrastruttura di registrazione.
+ **Registrazione strutturata: invia dati di** registro strutturati in modo nativo senza sovraccarico di codifica JSON.
+ **Controllo migliore**: l'applicazione può implementare la propria logica di buffering e gestione degli errori.
Le seguenti librerie di logger Fluent supportano il protocollo Fluent Forward e possono essere utilizzate per inviare i log direttamente 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)
## Configura il limite del buffer Docker
Quando si crea una definizione di attività, è possibile specificare il numero di righe di registro memorizzate nel buffer in memoria specificando il valore in. `log-driver-buffer-limit` Questo controlla il buffer tra Docker e. Fluent Bit Per ulteriori informazioni, consulta la pagina [Driver di registro di Fluentd](https://docs.docker.com/engine/logging/drivers/fluentd/) nella documentazione Docker.
Utilizza questa opzione in caso di velocità di trasmissione effettiva elevata, perché Docker potrebbe esaurire la memoria buffer e scartare i messaggi buffer in modo da poter aggiungere nuovi messaggi.
Considerate quanto segue quando utilizzate questa opzione:
+ Questa opzione è supportata nei tipi EC2 e Fargate con versione della piattaforma `1.4.0` o successiva.
+ L'opzione è valida solo quando `logDriver` è impostato su `awsfirelens`.
+ Il limite di buffer di default è `1048576` righe di log.
+ Il limite del buffer deve essere maggiore o uguale a `0` e inferiore a `536870912` righe di log.
+ La quantità massima di memoria utilizzata per questo buffer è il prodotto della dimensione di ogni riga di log e della dimensione del buffer. Ad esempio, se le righe di registro dell'applicazione sono in media `2` KB, un limite di buffer di 4096 utilizzerebbe al massimo `8` MiB. La quantità totale di memoria allocata a livello di attività deve essere superiore a quella allocata per tutti i container oltre al driver di log del buffer di memoria.
La seguente definizione di attività mostra come configurare: `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 per gli archivi di Fluent Bit immagini per Amazon ECS
AWS fornisce un'Fluent Bitimmagine con i plugin sia per CloudWatch Logs che per Firehose. Si consiglia di utilizzare Fluent Bit come router di log perché dispone di un tasso di utilizzo delle risorse inferiore a Fluentd. Per ulteriori informazioni, consulta [CloudWatch Logs for Fluent Bit](https://github.com/aws/amazon-cloudwatch-logs-for-fluent-bit) e [Amazon Kinesis Firehose](https://github.com/aws/amazon-kinesis-firehose-for-fluent-bit) for Fluent Bit.
L'immagine **AWS per Fluent Bit** è disponibile su Amazon ECR sia nella Amazon ECR Public Gallery che in un repository Amazon ECR per l'alta disponibilità.
## Galleria pubblica di Amazon ECR
L'Fluent Bitimmagine AWS per è disponibile nella Amazon ECR Public Gallery. Questa è la posizione consigliata per scaricare l'Fluent Bitimmagine AWS for perché è un archivio pubblico e può essere utilizzato da tutti. Regioni AWS Per ulteriori informazioni, consulta la [aws-for-fluent-bit](https://gallery.ecr.aws/aws-observability/aws-for-fluent-bit)Amazon ECR Public Gallery.
### Linux
L'Fluent Bitimmagine AWS for nella galleria pubblica di Amazon ECR supporta il sistema operativo Amazon Linux con `x86-64` architettura `ARM64` or.
Puoi estrarre l'Fluent Bitimmagine AWS for dalla Amazon ECR Public Gallery specificando l'URL del repository con il tag immagine desiderato. I tag immagine disponibili sono disponibili nella scheda **Tag immagine** nella galleria pubblica di Amazon ECR.
Di seguito è mostrata la sintassi da utilizzare per la CLI di Docker.
```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:tag
```
Ad esempio, puoi estrarre l'immagine più recente della famiglia «3.x» di AWS quattro Fluent Bit versioni utilizzando questo comando CLI Docker.
```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:3
```
**Nota**
I pull non autenticati sono consentiti, ma hanno un limite di velocità inferiore rispetto ai pull autenticati. Per autenticarti utilizzando il tuo AWS account prima di estrarlo, usa il seguente comando.
```
aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
```
#### AWS per 3.0.0 Fluent Bit
Oltre alle Fluent Bit versioni AWS for esistenti`2.x`, AWS for Fluent Bit supporta una nuova versione principale. `3.x` La nuova versione principale include l'aggiornamento delle immagini da Amazon Linux 2 ad Amazon Linux 2023 e dalla Fluent Bit versione `1.9.10` a. `4.1.1` Per ulteriori informazioni, consulta il [Fluent Bitrepository AWS for](https://github.com/aws/aws-for-fluent-bit/blob/mainline/VERSIONS.md) su. GitHub
Gli esempi seguenti mostrano i tag aggiornati AWS per Fluent Bit `3.x` le immagini:
È possibile utilizzare tag multiarchitettura per l'Fluent Bitimmagine AWS for.
```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:3
```
### Windows
L'Fluent Bitimmagine AWS for nella Amazon ECR Public Gallery supporta l'`AMD64`architettura con i seguenti sistemi operativi:
+ Windows Server 2022 Full
+ Windows Server 2022 Core
+ Windows Server 2019 Full
+ Windows Server 2019 Core
I contenitori Windows che si trovano su AWS Fargate non supportano. FireLens
Puoi estrarre l'Fluent Bitimmagine AWS for dalla Amazon ECR Public Gallery specificando l'URL del repository con il tag immagine desiderato. I tag immagine disponibili sono disponibili nella scheda **Tag immagine** nella galleria pubblica di Amazon ECR.
Di seguito è mostrata la sintassi da utilizzare per la CLI di Docker.
```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:tag
```
Ad esempio, puoi estrarre la più recente stable AWS for Fluent Bit image usando questo comando Docker CLI.
```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:windowsservercore-stable
```
**Nota**
I pull non autenticati sono consentiti, ma hanno un limite di velocità inferiore rispetto ai pull autenticati. Per autenticarti utilizzando il tuo AWS account prima di estrarlo, usa il seguente comando.
```
aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
```
## Amazon ECR
L'immagine AWS for Fluent Bit è disponibile su Amazon ECR per un'elevata disponibilità. I seguenti comandi possono essere utilizzati per recuperare un'immagine URIs e stabilire la disponibilità dell'immagine in una determinata area. Regione AWS
### Linux
L'ultima versione stabile AWS dell'URI dell'immagine Fluent Bit può essere recuperata utilizzando il seguente comando.
```
aws ssm get-parameters \
--names /aws/service/aws-for-fluent-bit/stable \
--region us-east-1
```
Tutte le versioni dell'immagine AWS for Fluent Bit possono essere elencate utilizzando il comando seguente per interrogare il parametro Systems Manager Parameter Store.
```
aws ssm get-parameters-by-path \
--path /aws/service/aws-for-fluent-bit \
--region us-east-1
```
È possibile fare riferimento all'immagine stabile più recente AWS per Fluent Bit in un CloudFormation modello facendo riferimento al nome dell'archivio dei parametri di Systems Manager. Di seguito è riportato un esempio:
```
Parameters:
FireLensImage:
Description: Fluent Bit image for the FireLens Container
Type: AWS::SSM::Parameter::Value
Default: /aws/service/aws-for-fluent-bit/stable
```
**Nota**
Se il comando fallisce o non viene generato alcun output, l'immagine non è disponibile nella cartella Regione AWS in cui viene chiamato il comando.
### Windows
L'ultima versione stabile dell'URI AWS di immagine Fluent Bit può essere recuperata utilizzando il seguente comando.
```
aws ssm get-parameters \
--names /aws/service/aws-for-fluent-bit/windowsservercore-stable \
--region us-east-1
```
Tutte le versioni dell'immagine AWS for Fluent Bit possono essere elencate utilizzando il comando seguente per interrogare il parametro Systems Manager Parameter Store.
```
aws ssm get-parameters-by-path \
--path /aws/service/aws-for-fluent-bit/windowsservercore \
--region us-east-1
```
È possibile fare riferimento all'ultima immagine stabile AWS per Fluent Bit in un CloudFormation modello facendo riferimento al nome dell'archivio dei parametri di Systems Manager. Di seguito è riportato un esempio:
```
Parameters:
FireLensImage:
Description: Fluent Bit image for the FireLens Container
Type: AWS::SSM::Parameter::Value
Default: /aws/service/aws-for-fluent-bit/windowsservercore-stable
```
# Esempio di definizione dell'attività Amazon ECS: indirizzare i log a FireLens
Per utilizzare il routing di log personalizzato con FireLens, è necessario specificare quanto segue nella definizione di attività:
+ Un container router di log contenente una configurazione FireLens. Si consiglia di contrassegnare il container come `essential`.
+ Uno o più container dell'applicazione contenenti una configurazione del log che specifica il driver di log `awsfirelens`.
+ Un nome della risorsa Amazon (ARN) del ruolo IAM dell'attività contenente le autorizzazioni richieste dall'attività per instradare i log.
Quando si crea una nuova definizione di attività utilizzando il Console di gestione AWS, è disponibile una sezione di FireLens integrazione che semplifica l'aggiunta di un contenitore di log router. Per ulteriori informazioni, consulta [Creazione di una definizione di attività di Amazon ECS attraverso la nuova console](create-task-definition.md).
Amazon ECS converte la configurazione del log e genera la configurazione di output Fluentd o Fluent Bit. La configurazione di output è montata nel container di routing dei log in corrispondenza di `/fluent-bit/etc/fluent-bit.conf` for Fluent Bit e `/fluentd/etc/fluent.conf` for Fluentd.
**Importante**
FireLens è in ascolto sulla porta `24224`. Pertanto, per garantire che il FireLens log router non sia raggiungibile al di fuori dell'operazione, non è necessario consentire il traffico `24224` in ingresso sulla porta del gruppo di sicurezza utilizzato dall'attività. Per attività che utilizzano la modalità di rete `awsvpc`, questo è il gruppo di sicurezza associato all'attività. Per attività che utilizzano la modalità di rete `host`, questo è il gruppo di sicurezza associato all'istanza Amazon EC2 che ospita l'attività. Per attività che utilizzano la modalità di rete `bridge`, non creare mappature di porte che utilizzano la porta `24224`.
Di default, Amazon ECS aggiunge ulteriori campi nelle voci di log che consentono di identificare l'origine dei log.
+ `ecs_cluster`: il nome del cluster di cui fa parte il processo.
+ `ecs_task_arn`: il nome della risorsa Amazon (ARN) completo dell'attività a cui appartiene il container.
+ `ecs_task_definition`: il nome della definizione di attività e la revisione che il processo sta utilizzando.
+ `ec2_instance_id`: l'ID dell'istanza Amazon EC2 su cui il container è ospitato. Questo campo è valido solo per processi che utilizzano il tipo di avvio EC2.
È possibile impostare `enable-ecs-log-metadata` su `false` se non si desiderano i metadati.
Il seguente esempio di definizione di attività definisce un contenitore di log router che utilizza Fluent Bit per indirizzare i log verso Logs. CloudWatch Definisce inoltre un container di applicazioni che utilizza una configurazione di log per instradare i log ad Amazon Data Firehose e imposta la memoria usata per il buffer degli eventi a 2 MiB.
**Nota**
Per ulteriori esempi di definizioni di attività, consulta gli [ FireLensesempi di Amazon ECS](https://github.com/aws-samples/amazon-ecs-firelens-examples) su 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
}
]
}
```
Le coppie chiave/valore specificate come opzioni nell'oggetto `logConfiguration` vengono utilizzate per generare la configurazione di output Fluentd o Fluent Bit. Di seguito è riportato un esempio di codice da una definizione di output Fluent Bit.
```
[OUTPUT]
Name firehose
Match app-firelens*
region us-west-2
delivery_stream my-stream
```
**Nota**
FireLens gestisce la `match` configurazione. Non specificare la configurazione `match` nella definizione dell'attività.
## Utilizzo di un file di configurazione personalizzato
È possibile utilizzare un file di configurazione personalizzato. Il formato del file di configurazione è il formato nativo per il router di log in uso. Per ulteriori informazioni, consultare [Fluentd Config File Syntax](https://docs.fluentd.org/configuration/config-file) e [YAML Configuration](https://docs.fluentbit.io/manual/administration/configuring-fluent-bit/yaml).
Nel file di configurazione personalizzato, per le attività che utilizzano la modalità di rete `bridge` o `awsvpc`, non è necessario impostare un input di inoltro Fluentd o Fluent Bit su TCP perché FireLens lo aggiunge alla configurazione di input.
La configurazione di FireLens deve contenere le seguenti opzioni per specificare un file di configurazione personalizzato:
`config-file-type`
Il percorso di origine del file di configurazione personalizzato. Le opzioni disponibili sono `s3` o `file`.
Le attività ospitate su supportano AWS Fargate solo il tipo `file` di file di configurazione. Tuttavia, puoi utilizzare i file di configurazione ospitati in Amazon S3 su AWS Fargate utilizzando il AWS contenitore for init. Fluent Bit Per ulteriori informazioni, consulta [Processo di inizializzazione per Fluent Bit su ECS, supporto multi-config su](https://github.com/aws/aws-for-fluent-bit/blob/mainline/use_cases/init-process-for-fluent-bit/README.md). GitHub
`config-file-value`
L'origine del file di configurazione personalizzato. Se viene utilizzato il tipo di file di configurazione `s3`, il valore del file di configurazione è l'ARN completo del file e del bucket Amazon S3. Se viene utilizzato il tipo di file di configurazione `file`, il valore del file di configurazione è il percorso completo del file di configurazione presente nell'immagine del container o in un volume montato nel container.
Quando si utilizza un file di configurazione personalizzato, è necessario specificare un percorso diverso da quello utilizzato da FireLens. Amazon ECS riserva il percorso file `/fluent-bit/etc/fluent-bit.conf` for Fluent Bit e `/fluentd/etc/fluent.conf` for Fluentd.
L'esempio seguente mostra la sintassi richiesta quando si specifica una configurazione personalizzata.
**Importante**
Per specificare un file di configurazione personalizzato ospitato in Amazon S3, assicurati di aver creato un ruolo IAM di esecuzione dell'attività con le autorizzazioni appropriate.
Di seguito viene illustrata la sintassi richiesta quando si specifica una configurazione personalizzata.
```
{
"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**
Le attività ospitate su supportano AWS Fargate solo il tipo di file di configurazione. `file` Tuttavia, puoi utilizzare i file di configurazione ospitati in Amazon S3 su AWS Fargate utilizzando il AWS contenitore for init. Fluent Bit Per ulteriori informazioni, consulta [Processo di inizializzazione per Fluent Bit su ECS, supporto multi-config su](https://github.com/aws/aws-for-fluent-bit/blob/mainline/use_cases/init-process-for-fluent-bit/README.md). GitHub