Il monitoraggio e l'analisi dei log sono diventati fondamentali al giorno d'oggi, sia per le applicazioni che per l'infrastruttura di server/container. Uno degli stack software più popolari per l'analisi e il monitoraggio dei log che puoi scegliere è Elasticsearch, Fluentd e Kibana (stack EFK).
EFK stack è un motore di ricerca distribuito e scalabile che consente ricerche e analisi strutturate. E in questo tutorial imparerai come configurare il monitoraggio dei log dello stack EFK con Docker e centralizzare i log dei container nello stack EFK.
Pronto? Continua a leggere e semplifica l'analisi del registro!
Prerequisiti
Questo tutorial comprende dimostrazioni pratiche. Per seguire, assicurati di avere quanto segue:
- Un host Linux – Questo esempio utilizza il server Debian 11 Bullseye con una capacità di memoria di 6 GB.
- Docker CE (Community Edition) e Docker Compose installati sul tuo host Linux.
Impostazione di un progetto EFK Stack
EFK Stack è un framework di aggregazione e analisi dei log pronto per l'azienda per infrastrutture bare-metal e container. Ma prima di distribuire uno stack EFK, devi prima configurare una directory di progetto e creare una configurazione Docker per distribuire lo stack EFK sul tuo host Docker.
Per questo esempio, utilizzerai le immagini Docker con le seguenti specifiche:
- Elasticsearch 7.17.0 – Capace di archiviare dati con funzionalità di ricerca rapide basate su Apache Lucene
- Kibana 7.17.0 – Raccolta e aggregazione di dati open source che supporta i dati JSON e
- Fluentd Immagine personalizzata basata su v1.14.1 – Software di visualizzazione dei dati per Elasticsearch.
Per impostare il tuo progetto stack EFK:
1. Apri un terminale e accedi al tuo server.
2. Eseguire i comandi seguenti per verificare che sia Docker che Docker Compose siano installati sul sistema.
# Checking Docker version
docker --version
# Checking docker-compose version
docker-compose versionCome puoi vedere di seguito, le versioni installate di Docker CE (Community Edition) v20.10.12 e Docker Compose v1.29.2.
3. Eseguire il comando seguente per creare una nuova directory di progetto (mkdir ) e impostarlo come directory di lavoro (cd ).
Puoi nominare la directory come preferisci, ma in questo tutorial, la directory si chiama efk. Questa directory memorizzerà tutti i file di configurazione di EFK Stack in questo tutorial.
mkdir -p ~/efk; cd ~/efk
4. Ora crea un nuovo file di configurazione (docker-compose.yml ) utilizzando il tuo editor preferito e popolare le seguenti configurazioni.
La configurazione seguente utilizza lo script Docker Compose v3 e definisce tutti i contenitori dello stack EFK.
version: "3"
# Define the Docker volume named esdata for the Elasticsearch container.
volumes:
esdata:
# Deploying three container services (fluentd, elasticsearch, and kibana)
services:
# Deploy using the custom image automatically be created during the build process.
fluentd:
build: ./fluentd
links: # Sends incoming logs to the elasticsearch container.
- elasticsearch
depends_on:
- elasticsearch
ports: # Exposes the port 24224 on both TCP and UDP protocol for log aggregation
- 24224:24224
- 24224:24224/udp
# Created using the Docker image elasticsearch:7.17.0
elasticsearch:
image: elasticsearch:7.17.0
expose: # Exposes the default port 9200
- 9200
environment:
- discovery.type=single-node # Runs as a single-node
volumes: # Stores elasticsearch data locally on the esdata Docker volume
- esdata:/usr/share/elasticsearch/data
# Created using the Docker image kibana:7.17.0
kibana:
image: kibana:7.17.0
links: # Links kibana service to the elasticsearch container
- elasticsearch
depends_on:
- elasticsearch
ports: # Runs kibana service on default port 5601
- 5601:5601
environment: # Defined host configuration
- ELASTICSEARCH_HOSTS=http://elasticsearch:9200
5. Eseguire il comando seguente per creare una nuova directory fluentd e vai a quella directory. Il fluentd la directory memorizzerà fluentd configurazioni di servizio.
mkdir -p fluentd/; cd fluentd/6. All'interno di ~/efk/fluentd directory, crea un nuovo Dockerfile utilizzando il tuo editor preferito e popolare la configurazione seguente.
Questa configurazione crea l'immagine personalizzata fluente contenente il driver del client elasticsearch e il plugin fluentd-elasticsearch.
Assicurati di utilizzare la stessa versione tra elasticsearch e il driver client elasticsearch:questo tutorial utilizza la versione 7.17.0.
# image based on fluentd v1.14-1
FROM fluentd:v1.14-1
# Use root account to use apk
USER root
# below RUN includes plugin as examples elasticsearch is not required# you may customize including plugins as you wish
RUN apk add --no-cache --update --virtual .build-deps \
sudo build-base ruby-dev \
&& gem uninstall -I elasticsearch \
&& gem install elasticsearch -v 7.17.0 \
&& sudo gem install fluent-plugin-elasticsearch \
&& sudo gem sources --clear-all \
&& apk del .build-deps \
&& rm -rf /tmp/* /var/tmp/* /usr/lib/ruby/gems/*/cache/*.gem
# copy fluentd configuration from host image
COPY ./conf/fluent.conf /fluentd/etc/
# copy binary start file
COPY entrypoint.sh /bin/
RUN chmod +x /bin/entrypoint.sh
USER fluent
7. Quindi, crea un altro file di configurazione (entrypoint.sh ) utilizzando l'editor preferito e compilare la configurazione seguente. Questo script viene eseguito quando il fluentd viene avviato il servizio contenitore.
Di seguito è riportato lo script iniziale per il servizio fluentd container, che esegue il comando di base fluentd –config /fluentd/etc/fluentd.conf –plugin /etc/fluentd/plugins.
#!/bin/sh
#source vars if file exists
DEFAULT=/etc/default/fluentd
if [ -r $DEFAULT ]; then
set -o allexport
. $DEFAULT
set +o allexport
fi
# If the user has supplied only arguments append them to `fluentd` commandif [ "${1#-}" != "$1" ]; then
set -- fluentd "[email protected]"
fi
# If user does not supply config file or plugins, use the defaultif [ "$1" = "fluentd" ]; then
if ! echo [email protected] | grep -e ' \-c' -e ' \-\-config' ; then
set -- "[email protected]" --config /fluentd/etc/${FLUENTD_CONF}
fi
if ! echo [email protected] | grep -e ' \-p' -e ' \-\-plugin' ; then
set -- "[email protected]" --plugin /fluentd/plugins
fi
fi
8. Eseguire il comando seguente per creare una nuova directory conf sotto ~/efk/fluentd directory.
mkdir -p conf9. Ora crea una configurazione fluida (conf/fluentd.conf ) utilizzando l'editor preferito e compilare la configurazione seguente.
Questa configurazione consente al servizio contenitore fluente di ricevere messaggi di registro e di inoltrarli al servizio contenitore elasticsearch.
# bind fluentd on IP 0.0.0.0
# port 24224
<source>
@type forward
port 24224
bind 0.0.0.0
</source>
# sendlog to the elasticsearch
# the host must match to the elasticsearch
# container service
<match *.**>
@type copy
<store>
@type elasticsearch
host elasticsearch
port 9200
logstash_format true
logstash_prefix fluentd
logstash_dateformat %Y%m%d
include_tag_key true
type_name access_log
tag_key @log_name
flush_interval 300s
</store>
<store>
@type stdout
</store>
</match>10. Infine, eseguire i comandi seguenti per verificare la struttura della directory del progetto EFK Stack.
Se non hai il comando tree, installalo usando il seguente comando:apt install tree -y
# Checking list of files and directory
ls
# Checking directory structure
treeDi seguito è riportata la struttura completa della directory del progetto EFK Stack.
Distribuzione dello stack EFK con Docker
Ora hai creato tutti i file di configurazione per la distribuzione di EFK Stack utilizzando Docker e Docker Compose. Il passaggio successivo consiste nel distribuire lo stack EFK utilizzando docker-compose comando e la distribuzione avverrà nella directory del progetto (~/efk ).
1. Per prima cosa, esegui il comando seguente per cambiare la directory di lavoro in efk directory di progetto.
cd ~/efk/
2. Quindi, esegui docker-compose comando seguente per distribuire (up ) il sistema di analisi dei log e monitoraggio dei log EFK Stack.
Questo comando scarica automaticamente le immagini Docker Elasticsearch e Kibana. E l'immagine Fluentd Docker viene creata automaticamente utilizzando il Dockerfile nel fluente directory.
La distribuzione potrebbe richiedere del tempo, a seconda delle specifiche dell'host Docker.
docker-compose up -dDi seguito è riportato lo screenshot del processo di compilazione dell'immagine Fluentd Docker.
Di seguito è riportato lo screenshot che mostra che la distribuzione è completa e il servizio contenitore Kibana è in esecuzione.
3. Eseguire ogni comando seguente per controllare i registri del processo di compilazione dello stack EFK. Eseguire sempre questi comandi ogni volta che si verifica un errore nel processo di distribuzione.
# Checking logs for service fluentd
docker-compose logs fluentd
# Checking logs for service kibana
docker-compose logs kibanaDi seguito è riportato il messaggio di registro quando è in esecuzione il servizio fluentd container.
E sotto c'è il registro per il contenitore kibana.
4. Ora, esegui il comando seguente per controllare lo stato di tutti i servizi contenitore (ps ).
docker-compose psCome puoi vedere di seguito, il servizio contenitore EFK Stack è attivo. Annota il nome del contenitore elasticsearch (efk_elasticsearch_1) per verificare ulteriormente che il contenitore funzioni correttamente nel passaggio successivo.
5. Inoltre, eseguire il comando seguente per verificare il servizio contenitore elasticsearch. Questo comando stampa le impostazioni dettagliate di efk_elasticsearch_1 contenitore.
docker inspect efk_elasticsearch_1Come puoi vedere di seguito, il contenitore efk_elasticsearch_1 ottiene un indirizzo IP di 172.18.0.2.
6. Infine, esegui il comando seguente per accedere e verificare il contenitore elasticsearch per indirizzo IP (172.18.0.2 ). Porta 9200 è la porta predefinita per il container elasticsearch.
curl 172.18.0.2:9200Vedrai un output simile a quello qui sotto se il contenitore elasticsearch sul tuo computer è in esecuzione.
Configurazione del modello di indice Kibana
Ora che hai completato la distribuzione di EFK Stack nell'ambiente Docker, aprirai Kibana dal tuo browser web. Imposterai un modello di indice per il monitoraggio e l'analisi dei log.
1. Apri il tuo browser web preferito e vai all'indirizzo IP del server seguito dalla porta del servizio Kibana 5601 (cioè, http://172.16.1.10:5601).
2. Quindi, fai clic su Esplora da solo pulsante nella pagina di benvenuto in basso.
3. Fare clic su Gestione stack opzione per impostare il modello di indice Kibana nella sezione Gestione.
4. Sul Kibana sezione del menu a sinistra, fai clic sul menu Modelli di indice e fai clic su Crea pattern indice pulsante per creare un nuovo modello di indice.
5. Ora, inserisci il modello di indice Nome come fluente- *, imposta il campo Timestamp a @timestamp e fai clic su Crea modello di indice per confermare le impostazioni del modello di indice.
Sul lato destro, puoi vedere i modelli di indice disponibili dal fluente come fluente-%Y%m%d. Il formato della data %Y%m%d si basa sulla configurazione fluente (fluentd.conf ).
6. Infine, fai clic sul menu in alto a sinistra (puntini di sospensione), quindi fai clic su Scopri menu per mostrare il monitoraggio dei log.
Di seguito è riportato lo screenshot del dashboard di monitoraggio e analisi del registro di Kibana. Tutti i log elencati sono presi da Elasticsearch e spediti dall'aggregazione di log Fluentd.
Esecuzione di un Docker Container con Fluentd Log Driver
Dopo aver configurato il modello di indice Kibana, eseguirai un container Docker con unità log Fluentd, inviando automaticamente i log allo stack EFK.
1. Esegui il comando seguente per scaricare l'immagine NGINX. L'alpine la versione è più piccola delle normali immagini basate su Ubuntu, CentOS o Fedora.
docker pull nginx:alpine
2. Quindi, esegui il comando seguente per avviare un nuovo contenitore NGINX (nginx_container ) in modalità separata (-d ).
Il comando imposta anche l'unità di registro su Fluentd (–log-driver=fluentd) ed espone la porta 8080 sulla macchina host Docker per il container (nginx_container).
docker run --name nginx_container -d --log-driver=fluentd -p 8080:80 nginx:alpine
3. Dopo aver eseguito il contenitore, eseguire la docker comando seguente per controllare tutti i contenitori in esecuzione.
docker psDovresti vedere che nginx_container è attivo e in esecuzione sulla porta host 8080.
4. Ora, esegui il comando seguente per accedere a nginx_container e generare log di accesso.
curl localhost:8080
In alternativa, apri una nuova scheda sul tuo browser web e digita l'indirizzo IP del server seguito dalla porta 8080 (cioè, http://172.168.1.10:8080).
Se tutto va bene, vedrai il valore predefinito index.html pagina da nginx_container.
5. Infine, torna alla dashboard di Kibana e fai clic su Scopri menu sul lato sinistro.
Fai clic sulla query container_name:nginx_container nel campo KQL (Kibana Query Language) e vedrai i log da nginx_container, come mostrato di seguito.
Conclusione
Hai imparato come distribuire EFK Stack (Elasticsearch, Fluentd e Kibana) in questo tutorial per il monitoraggio e l'analisi dei log utilizzando Docker. Hai anche imparato a configurare la registrazione per il contenitore Docker utilizzando il driver di registro Fluentd. E a questo punto, ora hai un monitoraggio del registro completamente funzionale per applicazioni e servizi.
Per la fase successiva, potresti essere interessato a utilizzare KQL (Kibana Query Language) per visualizzare il monitoraggio e l'analisi dei registri.