Installare Elastic Stack (Elasticsearch, Logstash, Kibana) su CentOS 8

Introduzione

Elasticsearch è un motore di ricerca open source basato su Lucene, sviluppato in Java. Fornisce una ricerca full-text distribuita e multitenant con interfaccia HTTP e dashboard (Kibana). I dati sono organizzati come documenti JSON: si interrogano, memorizzano e recuperano documenti JSON. Elasticsearch è scalabile e adatto a molti tipi di documenti di testo, inclusi i file di log. È il nucleo dello “Elastic Stack” (ELK Stack).

Logstash è uno strumento open source per la gestione di eventi e log. Fornisce pipeline in tempo reale per la raccolta e la trasformazione dei dati: raccoglie i log, li converte in documenti JSON e li invia a Elasticsearch.

Kibana è uno strumento open source per la visualizzazione dei dati in Elasticsearch. Offre una dashboard web bella e funzionale. Ti permette di gestire, esplorare e visualizzare i dati salvati in Elasticsearch.

Questa guida mostra passo dopo passo come installare e configurare Elastic Stack su CentOS 8. Installeremo Elasticsearch, Logstash e Kibana sul server CentOS 8 principale (elk-master). Poi configureremo Filebeat su due client (CentOS e Ubuntu) per instradare i log verso Logstash.

Varianti dell’intento principale (SEO)

• Installazione Elastic Stack su CentOS 8
• Configurare Elasticsearch, Logstash, Kibana su CentOS
• Deploy ELK Stack su CentOS con Filebeat
• Setup Kibana reverse proxy Nginx
• Inviare log con Filebeat a Logstash

Prerequisiti

• CentOS 8 64 bit con almeno 4 GB di RAM — elk-master (server ELK)
• CentOS 8 64 bit con 1 GB di RAM — client01 (client filebeat)
• Ubuntu 18.04 64 bit con 1 GB di RAM — client02 (client filebeat)
• Accesso sudo/root su tutte le macchine
• Connettività di rete tra client e server (porta 5044 aperta lato server)

Important: adattare i parametri di memoria JVM in base alla RAM disponibile sul server.

Cosa faremo

• Aggiungere il repository Elastic su CentOS 8
• Installare e configurare Elasticsearch
• Installare e configurare Kibana
• Configurare Nginx come reverse proxy per Kibana (con autenticazione base)
• Installare e configurare Logstash
• Installare e configurare Filebeat su client CentOS e Ubuntu
• Verificare l’intero flusso tramite Kibana

Passo 1 - Aggiungere il repository Elastic

Per installare i pacchetti Elastic (Elasticsearch, Logstash, Kibana, Beats) su CentOS 8 dobbiamo aggiungere la chiave GPG e il repository ufficiale.

Importa la chiave Elastic:

rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

Crea il file repository in /etc/yum.repos.d/elasticsearch.repo:

cd /etc/yum.repos.d/
vim elasticsearch.repo

Incolla il contenuto seguente:

[elasticsearch-7.x]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md

Salva e chiudi. Controlla i repository disponibili:

dnf repolist

Questo permette di installare i pacchetti Elastic tramite dnf.

Passo 2 - Installare e configurare Elasticsearch

Installiamo Elasticsearch sul server CentOS 8:

sudo dnf install elasticsearch -y

Configura il file principale /etc/elasticsearch/elasticsearch.yml:

cd /etc/elasticsearch/
vim elasticsearch.yml

Modifica le seguenti direttive (rimuovi il commento e imposta i valori):

network.host: 127.0.0.1
http.port: 9200

Nota: in ambienti di produzione non usare 127.0.0.1 se desideri che i nodi siano raggiungibili da remoto. Configura invece un indirizzo di rete o usa il bind su interfaccia di gestione sicura.

Opzionale: regola la dimensione dell’heap JVM in /etc/elasticsearch/jvm.options in base alla RAM disponibile. Esempio per 1 GB di RAM:

vim jvm.options

-Xms512m
-Xmx512m

Ricarica systemd, abilita il servizio all’avvio e avvia Elasticsearch:

sudo systemctl daemon-reload
sudo systemctl enable elasticsearch
sudo systemctl start elasticsearch

Ora Elasticsearch dovrebbe ascoltare su 127.0.0.1:9200. Verifica con curl:

curl -XGET 'http://127.0.0.1:9200/?pretty'

Se ricevi una risposta JSON con informazioni sul cluster, Elasticsearch è operativo.

Passo 3 - Installare e configurare Kibana

Installa Kibana:

sudo dnf install kibana

Configura il file /etc/kibana/kibana.yml:

cd /etc/kibana/
vim kibana.yml

Modifica le seguenti impostazioni:

server.port: 5601
server.host: "127.0.0.1"
elasticsearch.url: "http://127.0.0.1:9200"

Abilita e avvia il servizio Kibana:

sudo systemctl enable kibana
sudo systemctl start kibana

Verifica lo stato del servizio e le porte in ascolto:

systemctl status kibana
netstat -plntu

Kibana è ora accessibile localmente sulla porta 5601.

Passo 4 - Configurare Nginx come reverse proxy per Kibana

Per esporre Kibana in modo sicuro via HTTP su 80 e aggiungere autenticazione di base, usiamo Nginx.

Installa nginx e httpd-tools (per htpasswd):

sudo dnf install nginx httpd-tools

Crea il file di configurazione /etc/nginx/conf.d/kibana.conf:

cd /etc/nginx/conf.d/
vim kibana.conf

Incolla la configurazione seguente (aggiorna server_name con il tuo dominio):

server {
    listen 80;

    server_name elk.hakase-labs.io;

    auth_basic "Restricted Access";
    auth_basic_user_file /etc/nginx/.kibana-user;

    location / {
        proxy_pass http://127.0.0.1:5601;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Crea un utente per l’autenticazione base (sostituisci hakase con il tuo utente):

sudo htpasswd -c /etc/nginx/.kibana-user hakase

Controlla la configurazione nginx e avvia il servizio:

nginx -t
systemctl enable nginx
systemctl start nginx

Ora Kibana è disponibile tramite http://elk.hakase-labs.io con autenticazione base.

Note: per produzione usare TLS (Let’s Encrypt o certificati validi) e limitare l’accesso a IP o tramite autenticazione centralizzata.

Passo 5 - Installare e configurare Logstash

Logstash riceverà i log dai Beats (Filebeat) e li formatterà prima di inviarli a Elasticsearch.

Installa Logstash:

sudo dnf install logstash

Regola l’heap JVM in /etc/logstash/jvm.options se necessario:

cd /etc/logstash/
vim jvm.options

-Xms512m
-Xmx512m

Crea la configurazione per l’input beats in /etc/logstash/conf.d/input-beat.conf:

cd /etc/logstash/conf.d/
vim input-beat.conf

Inserisci:

input {
  beats {
    port => 5044
  }
}

Crea il filtro syslog /etc/logstash/conf.d/syslog-filter.conf:

vim syslog-filter.conf

Inserisci:

filter {
  if [type] == "syslog" {
    grok {
      match => { "message" => "%{SYSLOGTIMESTAMP:syslog_timestamp} %{SYSLOGHOST:syslog_hostname} %{DATA:syslog_program}(?:\[%{POSINT:syslog_pid}\])?: %{GREEDYDATA:syslog_message}" }
      add_field => [ "received_at", "%{@timestamp}" ]
      add_field => [ "received_from", "%{host}" ]
    }
    date {
      match => [ "syslog_timestamp", "MMM  d HH:mm:ss", "MMM dd HH:mm:ss" ]
    }
  }
}

Crea l’output verso Elasticsearch /etc/logstash/conf.d/output-elasticsearch.conf:

vim output-elasticsearch.conf

Inserisci:

output {
  elasticsearch { hosts => ["127.0.0.1:9200"]
    hosts => "127.0.0.1:9200"
    manage_template => false
    index => "%{[@metadata][beat]}-%{+YYYY.MM.dd}"
    document_type => "%{[@metadata][type]}"
  }
}

Abilita e avvia Logstash:

systemctl enable logstash
systemctl start logstash

Verifica che Logstash sia in ascolto sulla porta 5044:

systemctl status logstash
netstat -plntu

Ora il server ELK è pronto a ricevere log tramite Filebeat.

Passo 6 - Installare Filebeat sui client

Filebeat è un agente leggero che spedisce i file di log a Logstash (o direttamente a Elasticsearch). Configureremo Filebeat sui due client:

Installare Filebeat su CentOS 8

Importa la chiave GPG e aggiungi il repository come fatto sul server:

rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
cd /etc/yum.repos.d/
vim elasticsearch.repo

Contenuto identico al repository mostrato sopra. Poi installa Filebeat:

sudo dnf install filebeat

Installare Filebeat su Ubuntu 18.04

Installa apt-transport-https, aggiungi la chiave e il repository Elastic:

sudo apt install apt-transport-https
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-7.x.list
sudo apt update
sudo apt install filebeat

Configurare Filebeat

Il file principale è /etc/filebeat/filebeat.yml. Disabilita l’output Elasticsearch e abilita l’output Logstash (sostituisci l’IP con quello del server ELK):

#output.elasticsearch:
  # Array of hosts to connect to.
  #  hosts: ["127.0.0.1:9200"]

output.logstash:
  # The Logstash hosts
  hosts: ["10.5.5.25:5044"]

Abilita i moduli Filebeat (ad esempio il modulo system per syslog/auth):

filebeat modules list
filebeat modules enable system

Il modulo system crea il file modules.d/system.yml. Configura i percorsi dei log:

Per CentOS:

# Syslog
syslog:
  enabled: true
  var.paths: ["/var/log/messages"]

# Authorization logs
auth:
  enabled: true
  var.paths: ["/var/log/secure"]

Per Ubuntu:

# Syslog
syslog:
  enabled: true
  var.paths: ["/var/log/syslog"]

# Authorization logs
auth:
  enabled: true
  var.paths: ["/var/log/auth.log"]

Abilita e avvia Filebeat:

systemctl enable filebeat
systemctl start filebeat
systemctl status filebeat

Screenshot dal client CentOS e Ubuntu che mostrano Filebeat attivo:

Se Filebeat è connesso correttamente a Logstash, i messaggi dovrebbero fluire verso Elasticsearch e diventare disponibili in Kibana.

Passo 7 - Verifica finale e test in Kibana

Apri il browser e vai all’indirizzo del server Kibana (configurato con Nginx):

http://elk.hakase-labs.io/

Accedi con l’utente di autenticazione base creato.

Nella dashboard principale vedrai l’interfaccia Kibana. Quando Filebeat ha inviato dati per la prima volta, crea un index pattern in Management => Index Patterns.

Clicca su “Connect to your Elasticsearch index” e crea un index pattern: filebeat-*. Seleziona @timestamp come campo timefilter e crea l’index pattern.

Vai su Discover per visualizzare i log arrivati:

Esempi di log ricevuti dal client CentOS 8:

Esempi di log provenienti dal client Ubuntu:

Se visualizzi messaggi, il flusso Filebeat -> Logstash -> Elasticsearch -> Kibana è operativo.

Controlli post-installazione consigliati

• Verifica che Elasticsearch risponda: curl http://127.0.0.1:9200
• Controlla i log dei servizi: journalctl -u elasticsearch, kibana, logstash, filebeat
• Monitora lo spazio disco: Elasticsearch richiede spazio libero per gli indici
• Verifica permessi e ownership dei file di configurazione

Important: pianifica snapshot/regole di retention degli indici per evitare consumo eccessivo dello storage.

Troubleshooting comune

• Nessun dato in Kibana: controlla Filebeat (connection refused a 10.5.5.25:5044) e Logstash (porta 5044 in ascolto). Controlla i log di Logstash per errori di parsing grok.
• Kibana non raggiungibile: verifica Nginx, autenticazione base, e che Kibana ascolti su 127.0.0.1:5601.
• Errore di memoria Elasticsearch: riduci heap JVM o aggiungi memoria alla VM.
• Indici corrotti o template non applicati: rivedi manage_template in Logstash config.

Quando Elastic Stack potrebbe non essere la scelta migliore

• Se hai pochi MB di log al giorno e non vuoi gestire un’infrastruttura, puoi usare servizi cloud managed (Elastic Cloud, Logz.io, Papertrail).
• Se hai requisiti estremi di latenza in scrittura e pochi campi strutturati, una soluzione più semplice come un database append-only può essere sufficiente.
• Se la privacy/retention è molto sensibile, valuta normative e pseudonimizzazione dei dati prima di indicizzarli.

Alternative e approcci ibridi

• Inviare Filebeat direttamente a Elasticsearch (senza Logstash) per ridurre complessità; utile quando non servono trasformazioni pesanti.
• Usare Fluentd o Fluent Bit come collector alternativo a Logstash/Filebeat per integrazione con Kubernetes.
• Elastic Cloud (servizio gestito) per evitare gestione dell’infrastruttura.

Mini-metodologia per un deployment in produzione

1. Pianificazione risorse: calcola heap Elasticsearch (mezzo della RAM fisica, fino a 30-32 GB massimo) e storage.
2. Deploy in staging: riproduci la topologia su macchine virtuali.
3. Hardening: attiva TLS, autenticazione (Elastic Security o proxy), firewall.
4. Test di carico: simula flusso log per validare ingestor e storage.
5. Monitoraggio: imposta alert su cluster health, spazio disco, JVM.
6. Backup: pianifica snapshot regolari degli indici e test di restore.

Runbook di incidente (checkpoint rapidi)

• Problema: Elasticsearch non accetta scritture

  • Verifica uso disco: df -h
  • Controlla health cluster: curl -s http://127.0.0.1:9200/_cluster/health?pretty
  • Se status red: controlla log /var/log/elasticsearch/elasticsearch.log
  • Se spazio insufficiente: aumentare disco o ridurre retention e cancellare indici non necessari

• Problema: Logstash non riceve Filebeat

  • Verifica Logstash in ascolto su 5044 (netstat -plntu)
  • Controlla log Filebeat per errori di connessione
  • Test con tcpdump/netcat per verificare connettività

• Problema: Kibana lento o non risponde

  • Controlla utilizzo CPU/RAM
  • Verifica che Elasticsearch non sia sovraccarico
  • Riavvia Kibana dopo controlli: systemctl restart kibana

Checklist di distribuzione (ruolo-based)

• Amministratore di sistema

  • Repository Elastic configurato su tutti i nodi
  • Servizi abilitati (elasticsearch, kibana, logstash, nginx)
  • Certificati TLS in produzione

• DevOps / SRE

  • Heap JVM dimensionato
  • Snapshot e retention configurati
  • Dashboard di monitoraggio cluster (CPU, heap, GC)

• Sicurezza

  • Autenticazione per Kibana abilitata
  • Regole firewall limitate alle porte necessarie (5044, 9200 interno)
  • Logging e auditing delle modifiche

Test cases e criteri di accettazione

• Test 1: Connessione base

  • Input: curl http://127.0.0.1:9200
  • Output atteso: risposta JSON contenente nome del cluster

• Test 2: Flusso log end-to-end

  • Input: generare una riga di log su client (es. logger test-filebeat)
  • Output atteso: evento visibile in Discover di Kibana entro 30-60 s

• Test 3: Autenticazione Kibana

  • Input: accesso via browser a http://elk.hakase-labs.io/
  • Output atteso: richiesta credenziali e accesso con utente valido

Piccolo glossario (1 riga ciascuno)

• Elasticsearch: motore di ricerca e analisi basato su Lucene.
• Logstash: pipeline per raccolta, filtraggio e inoltro dei log.
• Kibana: interfaccia di visualizzazione e gestione per Elasticsearch.
• Filebeat: agente leggero per invio di file di log a Logstash/Elasticsearch.
• Index pattern: modello in Kibana per leggere indici con nome simile (es. filebeat-*).

Note sulla sicurezza e conformità (breve)

• Non indicizzare dati sensibili senza anonimizzazione (PII).
• In produzione, attiva TLS tra Filebeat -> Logstash -> Elasticsearch e proteggi Kibana con autenticazione centralizzata.
• Valuta requisiti GDPR per conservazione e accesso ai log.

Localizzazione e suggerimenti per l’Italia

• Usa domini certificati e registrati in ambiente aziendale per l’accesso esterno.
• Coordinati con il team legale/Compliance per tempi di retention e policy di cancellazione.

Riferimenti

• Documentazione ufficiale Elastic: https://www.elastic.co/guide/index.html

Riepilogo

• Abbiamo aggiunto il repository Elastic su CentOS 8, installato e configurato Elasticsearch, Kibana, Logstash e Nginx come reverse proxy.
• Abbiamo installato Filebeat su client CentOS e Ubuntu, configurato i moduli system e inviato i log a Logstash.
• Infine abbiamo verificato il flusso in Kibana e fornito checklist, runbook e test di accettazione per un deployment più sicuro e riproducibile.

Extras:

• Social preview (suggerito): “Installare Elastic Stack su CentOS 8: guida completa per Elasticsearch, Logstash, Kibana e Filebeat”