Come installare il stack di logging Elasticsearch, Fluentd e Kibana (EFK) su Ubuntu 22.04
Il monitoraggio e l’analisi dei log sono una parte essenziale dell’infrastruttura del server o del container e sono utili quando si gestiscono applicazioni complesse. Una delle soluzioni di logging più popolari è il stack Elasticsearch, Fluentd e Kibana (EFK). Prima di approfondire il tutorial, impariamo a conoscere i componenti del stack.
Elasticsearch è un motore di ricerca distribuito, scalabile e in tempo reale che consente la ricerca e l’analisi di testo completo. Viene utilizzato per indicizzare e cercare grandi quantità di dati. Viene comunemente distribuito insieme a Kibana, un potente cruscotto di visualizzazione dei dati per Elasticsearch. Kibana consente di esplorare i dati di log di Elasticsearch e di costruire cruscotti e query per ottenere informazioni sulla propria applicazione. Fluentd raccoglie, trasforma e invia i dati di log al backend di Elasticsearch.
In questo tutorial, installeremo il stack EFK utilizzando Docker su una macchina Ubuntu 22.04 e invieremo i log dei container a Kibana dopo averli filtrati e trasformati utilizzando Fluentd.
Requisiti
Un server che esegue Ubuntu 22.04 con un minimo di 6 GB di RAM.
Un utente non root con privilegi sudo.
Il firewall Uncomplicated Firewall (UFW) è abilitato e in esecuzione.
Un nome di dominio completamente qualificato (FQDN) che punta al server come kibana.example.com.
Tutto è aggiornato. $ sudo apt update && sudo apt upgrade
Passo 1 - Configurare il Firewall
Prima di installare qualsiasi pacchetto, il primo passo è configurare il firewall per consentire le connessioni HTTP e HTTPS.
Controlla lo stato del firewall.
$ sudo ufw status
Dovresti vedere qualcosa di simile al seguente.
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
Consenti le porte HTTP e HTTPS.
$ sudo ufw allow http
$ sudo ufw allow https
Controlla di nuovo lo stato per confermare.
$ sudo ufw status
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
80/tcp ALLOW Anywhere
443 ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
80/tcp (v6) ALLOW Anywhere (v6)
443 (v6) ALLOW Anywhere (v6)
Questo tutorial utilizzerà il plugin Docker Compose v2 invece del vecchio binario legacy. Pertanto, il comando per eseguirlo è cambiato da docker-compose a docker compose e questo è riflesso qui.
Docker viene eseguito con privilegi elevati, quindi dovrai usare sudo frequentemente per eseguire comandi. L’opzione migliore è aggiungere il tuo account utente Linux al gruppo utente docker.
$ sudo usermod -aG docker ${USER}
La variabile ${USER} raccoglie l’account di sistema attualmente connesso. Se non sei connesso con l’utente a cui vuoi dare privilegi, sostituisci ${USER} con il nome utente.
Per applicare la nuova appartenenza al gruppo, disconnettiti dal server e riconnettiti, oppure usa il seguente comando. Ti verrà chiesto di inserire la password dell’utente.
$ su - ${USER}
Passo 3 - Creare il file Docker Compose
Prima, crea la directory per il progetto EFK.
$ mkdir ~/efk
Passa alla directory.
$ cd ~/efk
Crea e apri il file docker-compose.yml per la modifica.
$ nano docker-compose.yml
Incolla il seguente codice in esso.
services:
# Distribuisci utilizzando l'immagine personalizzata creata automaticamente durante il processo di build.
fluentd:
build: ./fluentd
volumes:
- ./fluentd/conf:/fluentd/etc
links: # Invia i log in arrivo al container elasticsearch.
- elasticsearch
depends_on:
- elasticsearch
ports: # Espone la porta 24224 sia sul protocollo TCP che UDP per l'aggregazione dei log
- 24224:24224
- 24224:24224/udp
elasticsearch:
image: elasticsearch:8.7.1
expose:
- 9200
environment:
- discovery.type=single-node # Esegue come un nodo singolo
- xpack.security.enabled=false
volumes: # Memorizza i dati di elasticsearch localmente sul volume Docker esdata
- esdata:/usr/share/elasticsearch/data
kibana:
image: kibana:8.7.1
links: # Collega il servizio kibana al container elasticsearch
- elasticsearch
depends_on:
- elasticsearch
ports:
- 5601:5601
environment: # Configurazione dell'host definita
- ELASTICSEARCH_HOSTS=http://elasticsearch:9200
# Definisci il volume Docker chiamato esdata per il container Elasticsearch.
volumes:
esdata:
Salva il file premendo Ctrl + X e inserendo Y quando richiesto. Abbiamo configurato per avviare tre servizi, uno per ciascuno, Fluentd, Elasticsearch e Kibana.
Per Fluentd, costruiremo un container invece di un’immagine pronta. I file di build per Fluentd saranno impostati nel passo successivo. Abbiamo montato una directory per i suoi file di build, e un volume per i file di configurazione, e abbiamo esposto la porta 24224 sia sul protocollo TCP che UDP per l’aggregazione dei log.
Il servizio successivo è Elasticsearch e stiamo utilizzando l’ultima versione disponibile al momento della scrittura di questo tutorial. L’abbiamo esposto tramite la porta 9200 e impostato alcune variabili ambientali in modo da poterlo eseguire come un cluster a nodo singolo e abbiamo disabilitato le funzionalità di sicurezza. Questo non è generalmente raccomandato, ma abilitare la sicurezza è al di fuori dell’ambito di questo tutorial. Abbiamo anche montato un volume locale per i dati di Elasticsearch.
Infine, configuriamo Kibana e lo esponiamo tramite la porta 5601 che sarà utilizzata per accedere al cruscotto. Abbiamo anche impostato una variabile per configurare l’host Elasticsearch per accedervi.
Passo 4 - Configurare i file di build di Fluentd
Crea Fluentd e la directory di configurazione.
$ mkdir fluentd/conf -p
Esegui il comando tree per verificare la struttura della directory.
$ tree
Dovrebbe apparire simile al seguente.
Passa alla directory Fluentd.
$ cd fluentd
Crea e apri il Dockerfile per la modifica.
$ nano Dockerfile
Incolla il seguente codice in esso. Questo codice estrae l’immagine Docker Debian di Fluentd e installa il plugin Fluentd per Elasticsearch.
# fluentd/Dockerfile
FROM fluent/fluentd:v1.16-debian-1
USER root
RUN ["gem", "install", "fluent-plugin-elasticsearch", "--no-document", "--version", "5.3.0"]
USER fluent
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Passa alla directory di configurazione.
$ cd conf
Crea e apri il file fluentd.conf per la modifica.
$ nano fluentd.conf
Incolla il seguente codice in esso.
# bind fluentd su IP 0.0.0.0
# porta 24224
@type forward
port 24224
bind 0.0.0.0
# invia log a elasticsearch
# l'host deve corrispondere al servizio del container elasticsearch
@type copy
@type elasticsearch_dynamic
hosts elasticsearch:9200
logstash_format true
logstash_prefix fluentd
logstash_dateformat %Y%m%d
include_tag_key true
tag_key @log_name
include_timestamp true
flush_interval 30s
@type stdout
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
La direttiva source sopra utilizza il plugin forward che trasforma Fluentd in un endpoint TCP per accettare pacchetti TCP.
La direttiva match cerca eventi con tag corrispondenti, il che in questo caso significa che corrisponde a tutti gli eventi. Utilizzeremo il plugin elasticsearch_dynamic per la memorizzazione, che consente di specificare i valori di configurazione in modo dinamico. Il campo hosts specifica il nome host per l’applicazione Elasticsearch, che è il nome del servizio nel file Docker compose. Il logstash_format è impostato su true, il che significa che Fluentd utilizza il formato di nome convenzionale logstash-%Y.%m.%dlogstash-%Y.%m.%d. Il nome del prefisso per scrivere gli eventi è impostato su fluend. L’opzione include_tag_key è impostata su true, il che aggiunge il tag Fluentd nel formato JSON. La tag_key è il nome del campo da estrarre per il tag. Impostando la variabile include_timestamp su true, viene aggiunto un campo timestamp al log. L’intervallo flush_interval specifica l’intervallo tra i flush dei dati. Utilizziamo anche il plugin stdout per stampare eventi/log al output standard.
Passo 5 - Eseguire i container Docker
Torna alla directory EFK.
$ cd ~/efk
Avvia i container utilizzando il seguente comando.
$ docker compose up -d
Controlla lo stato dei container in esecuzione.
$ docker ps
b3780c311154 efk-fluentd "tini -- /bin/entryp…" 9 seconds ago Up 8 seconds 5140/tcp, 0.0.0.0:24224->24224/tcp, 0.0.0.0:24224->24224/udp, :::24224->24224/tcp, :::24224->24224/udp efk-fluentd-1
5a48f0a9ade1 kibana:8.7.1 "/bin/tini -- /usr/l…" 9 seconds ago Up 7 seconds 0.0.0.0:5601->5601/tcp, :::5601->5601/tcp efk-kibana-1
dab3a0ab0312 elasticsearch:8.7.1 "/bin/tini -- /usr/l…" 9 seconds ago Up 8 seconds 9200/tcp, 9300/tcp efk-elasticsearch-1
Puoi anche usare il seguente comando per questo.
$ docker compose ps
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
efk-elasticsearch-1 elasticsearch:8.7.1 "/bin/tini -- /usr/l…" elasticsearch 37 seconds ago Up 36 seconds 9200/tcp, 9300/tcp
efk-fluentd-1 efk-fluentd "tini -- /bin/entryp…" fluentd 37 seconds ago Up 36 seconds 5140/tcp, 0.0.0.0:24224->24224/tcp, 0.0.0.0:24224->24224/udp, :::24224->24224/tcp, :::24224->24224/udp
efk-kibana-1 kibana:8.7.1 "/bin/tini -- /usr/l…" kibana 37 seconds ago Up 36 seconds 0.0.0.0:5601->5601/tcp, :::5601->5601/tcp
Esegui i seguenti comandi per controllare i log del processo di build di EFK.
Come puoi vedere, il container ha ricevuto 172.23.0.2 come indirizzo IP. Esegui il seguente comando per verificare se Elasticsearch sta funzionando correttamente.
Ora che il stack EFK è stato distribuito, è tempo di configurare Kibana. Apri l’URL http://:5601 nel browser.
Clicca sul pulsante Esplora da solo per procedere al cruscotto di Kibana.
Clicca sul link Gestione stack per impostare la vista dei dati di Kibana. Seleziona l’opzione Kibana >> Viste dati dalla barra laterale sinistra per aprire la pagina della vista dei dati.
Clicca sul pulsante Crea vista dati per procedere.
Inserisci il nome della vista dati e il modello di indice come fluentd-*. Assicurati che il campo Timestamp sia impostato su @timestamp. Il campo sorgente verrà aggiornato automaticamente. Clicca sul pulsante Salva vista dati in Kibana per completare la creazione della vista dati.
Successivamente, clicca sul menu in alto (ellissi) e clicca sull’opzione Scopri per mostrare il monitoraggio dei log.
Otterrai la seguente pagina che conferma che la tua configurazione sta funzionando perfettamente. I log vengono tutti presi da Elasticsearch e inviati dall’aggregazione dei log di Fluentd.
Passo 7 - Installare Nginx
Ubuntu 22.04 viene fornito con una versione più vecchia di Nginx. Devi scaricare il repository ufficiale di Nginx per installare l’ultima versione.
Il primo passo è installare il certificato SSL di Let’s Encrypt. Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot utilizzando il repository di Ubuntu o scaricare l’ultima versione utilizzando lo strumento Snapd. Utilizzeremo la versione Snapd.
Ubuntu 22.04 viene fornito con Snapd installato per impostazione predefinita. Esegui i seguenti comandi per assicurarti che la tua versione di Snapd sia aggiornata.
Controlla il servizio di pianificazione del rinnovo di Certbot.
$ sudo systemctl list-timers
Troverai snap.certbot.renew.service come uno dei servizi programmati per l’esecuzione.
NEXT LEFT LAST PASSED UNIT ACTIVATES
------------------------------------------------------------------------------------------------------------------------------------
Mon 2023-05-06 13:37:57 UTC 3h 45min left Mon 2023-05-01 07:20:42 UTC 2h 31min ago ua-timer.timer ua-timer.service
Mon 2023-05-06 14:39:29 UTC 4h 47min left Sat 2023-02-04 16:04:18 UTC 2 months ago motd-news.timer motd-news.service
Mon 2023-05-06 15:53:00 UTC 6h left n/a n/a snap.certbot.renew.timer snap.certbot.renew.service
Fai un tentativo di prova del processo per controllare se il rinnovo SSL funziona correttamente.
$ sudo certbot renew --dry-run
Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.
Passo 9 - Configurare Nginx
Crea e apri il file di configurazione Nginx per Kibana.
$ sudo nano /etc/nginx/conf.d/kibana.conf
Incolla il seguente codice in esso. Sostituisci l’indirizzo IP con l’indirizzo IP privato del tuo server Elasticsearch.
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Apri il file /etc/nginx/nginx.conf per la modifica.
$ sudo nano /etc/nginx/nginx.conf
Aggiungi la seguente riga prima della riga include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Verifica la configurazione.
$ sudo nginx -t
nginx: il file di configurazione /etc/nginx/nginx.conf ha una sintassi corretta
nginx: il test del file di configurazione /etc/nginx/nginx.conf è riuscito
Riavvia il servizio Nginx.
$ sudo systemctl restart nginx
C’è un ulteriore passo necessario. Apri il file Docker compose per la modifica.
$ nano ~/docker-compose.yml
Incolla la riga SERVER_PUBLICBASEURL=https://kibana.example.com sotto la sezione ambiente del servizio Kibana come segue.
Salva il file premendo Ctrl + X e inserendo Y quando richiesto una volta completato.
Ferma e rimuovi i container.
$ docker compose down --remove-orphans
Avvia di nuovo i container con la configurazione aggiornata.
$ docker compose up -d
Il tuo cruscotto Kibana dovrebbe essere accessibile tramite l’URL https://kibana.example.com da qualsiasi luogo tu voglia.
Passo 10 - Eseguire un container Docker con il driver di log Fluentd
Ora, eseguiremo un container Docker con il driver di log Fluentd, inviando automaticamente i log allo stack. Testeremo utilizzando il container Nginx.
Scarica l’immagine Nginx dal registro Docker Hub. Stiamo utilizzando la versione alpine perché è la versione più piccola dell’immagine.
$ docker pull nginx:alpine
Esegui il seguente comando per creare e avviare il container Nginx. Abbiamo impostato il driver di log su Fluentd e la porta su 8080 perché la porta predefinita 80 è già in uso dal server Nginx in modalità proxy.
$ docker run --name nginx-fluentd-test -d --log-driver=fluentd -p 8080:80 nginx:alpine
Controlla lo stato del container.
$ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
038c43e4e1a3 nginx:alpine "/docker-entrypoint.…" 12 seconds ago Up 11 seconds 0.0.0.0:8080->80/tcp, :::8080->80/tcp nginx-fluentd-test
a94ca706bd0c efk-fluentd "tini -- /bin/entryp…" 8 hours ago Up 8 hours 5140/tcp, 0.0.0.0:24224->24224/tcp, 0.0.0.0:24224->24224/udp, :::24224->24224/tcp, :::24224->24224/udp efk-fluentd-1
0cf04a446425 kibana:8.7.1 "/bin/tini -- /usr/l…" 8 hours ago Up 8 hours 0.0.0.0:5601->5601/tcp, :::5601->5601/tcp efk-kibana-1
7c7ad8f9b123 elasticsearch:8.7.1 "/bin/tini -- /usr/l…" 8 hours ago Up 8 hours 9200/tcp, 9300/tcp efk-elasticsearch-1
Esegui il seguente comando per accedere al container Nginx e generare log di accesso.
$ curl localhost:8080
Benvenuto in nginx!
Benvenuto in nginx!
Se vedi questa pagina, il server web nginx è stato installato e
funziona correttamente. Ulteriori configurazioni sono necessarie.
Per documentazione e supporto online, si prega di fare riferimento a
nginx.org.
Il supporto commerciale è disponibile su
nginx.com.
Grazie per aver utilizzato nginx.
In alternativa, puoi aprire l’URL http://:8080 nel tuo browser e otterrai la seguente pagina.
Apri il cruscotto Kibana e clicca sul link Scopri nel menu della barra laterale sinistra. Clicca sul segno + nel menu in alto per far apparire il popup Aggiungi filtro.
Seleziona il campo container_name dal menu a discesa, è come operatore e compila il nome del container (nginx-fluentd-test) come valore del campo.
Clicca sul pulsante Aggiungi filtro per visualizzare i dati dal container Nginx.
Conclusione
Questo conclude il nostro tutorial sull’installazione del stack di logging Elasticsearch, Fluentd e Kibana (EFK) su una macchina Ubuntu 22.04. Se hai domande, postale nei commenti qui sotto.
