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à.
# 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
}
]
}
```