Come installare OpenSearch tramite Docker su Ubuntu 22.04

OpenSearch è un progetto guidato dalla comunità di Amazon e un fork di Elasticsearch e Kibana. È un motore di ricerca e una suite di analisi completamente open-source con funzionalità ricche e innovative. Il componente principale del progetto OpenSearch è OpenSearch (un fork di Elasticsearch) e OpenSearch Dashboards (un fork di Kibana). Entrambi i componenti forniscono funzionalità come sicurezza aziendale, avvisi, apprendimento automatico, SQL, gestione dello stato degli indici e altro ancora.

OpenSearch è 100% open-source e con licenza Apache 2.0. Ti consente di ingerire, proteggere, cercare, aggregare, visualizzare e analizzare facilmente i dati per una serie di casi d’uso come analisi dei log, ricerca di applicazioni, ricerca aziendale e altro.

In questo tutorial, installerai e configurerai OpenSearch - un motore di ricerca open-source e una suite di analisi - e OpenSearch Dashboards - uno strumento di visualizzazione open-source - tramite Docker su un server Ubuntu 22.04. Distribuirai un cluster OpenSearch con più contenitori e un singolo OpenSearch Dashboard tramite Docker e Docker Compose. Inoltre, proteggerai la tua distribuzione con certificati TLS personalizzati e autenticazione e autorizzazione abilitate.

Questa guida utilizza un server Ubuntu generico fresco, quindi questo tutorial include l’installazione del motore Docker e di Docker Compose su un sistema Ubuntu 22.04.

Requisiti

Per completare questa guida, devi avere i seguenti requisiti:

• Un server Ubuntu 22.04 con RAM minima 4-8GB - Questo esempio utilizza un server Ubuntu con il nome host ‘’ e un indirizzo IP ‘’.
• Un utente non root con privilegi di amministratore sudo/root.

Quando questi requisiti sono pronti, puoi ora iniziare l’installazione di OpenSearch.

Configurazione del sistema

In questo primo passaggio, preparerai il tuo sistema Ubuntu per la distribuzione di OpenSearch. Dovrai disabilitare SWAP e paging, quindi aumenterai la mappa di memoria massima tramite il file ‘/etc/sysctl.conf ‘.

Esegui il comando sottostante per disabilitare lo swap sul tuo sistema. Il comando ‘sed’ qui disabiliterà permanentemente lo swap tramite il file ‘/etc/fstab ‘ aggiungendo il commento ‘ # ‘ all’inizio della riga di configurazione dello swap. Il comando ‘ swapoff ‘ disabiliterà lo swap nella sessione corrente.

sudo sed -i '/ swap / s/^\(.*\)$/#
1/g' /etc/fstab  
sudo swapoff -a

Successivamente, verifica lo stato dello swap tramite il comando sottostante. Se disabilitato, dovresti ottenere un output ‘ 0 ‘ nella sezione swap.

free -m

Output:

Infine, aggiungerai la configurazione al file ‘ /etc/sysctl.conf’ per aumentare le mappe di memoria massima sul tuo sistema Ubuntu.

Esegui il comando sottostante per aggiungere il parametro ‘ vm.max_map_count=262144 ‘ alla fine della riga del file ‘ /etc/sysctl.conf’ . Quindi, applica le modifiche tramite il comando ‘ sysctl -p ‘.

sudo echo "vm.max_map_count=262144" >> /etc/sysctl.conf  
sudo sysctl -p

Ora verifica le mappe di memoria massima eseguendo il comando sottostante. Se ha successo, la tua mappa di memoria massima dovrebbe essere ‘ 262144 ‘.

cat /proc/sys/vm/max_map_count

Output:

Con lo swap disabilitato e la mappa di memoria massima aumentata a ‘262144’, inizierai ora l’installazione del motore Docker e di Docker Compose.

Installazione di Docker CE e Docker Compose

Ci sono più modi per distribuire e installare OpenSearch, puoi installare OpenSearch in modo tradizionale su una macchina virtuale, o installarlo nell’ambiente del contenitore.

Se preferisci l’installazione tradizionale su una macchina virtuale, puoi installare OpenSearch manualmente tramite Tarball, o tramite il gestore pacchetti (per distribuzioni basate su RHEL). Per la distribuzione nei contenitori, puoi installare OpenSearch con Docker e Kubernetes.

In questo esempio, installerai OpenSearch nell’ambiente containerizzato tramite il motore Docker e Docker Compose. Quindi ora installerai i pacchetti Docker dal repository ufficiale di Docker.

Per iniziare, esegui il comando apt sottostante per installare le dipendenze di base. Inserisci y quando richiesto e premi INVIO per procedere.

sudo apt install ca-certificates curl gnupg lsb-release

Output:

Successivamente, esegui il comando sottostante per aggiungere la chiave GPG e il repository per i pacchetti Docker.

sudo mkdir -p /etc/apt/keyrings  
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

echo \  
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \  
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Output:

Dopo di che, aggiorna e aggiorna l’indice dei pacchetti di Ubuntu tramite il comando apt sottostante.

sudo apt update

Output:

Con il repository Docker aggiunto, ora puoi installare il motore Docker e il plugin Docker Compose utilizzando il comando apt sottostante. Quando richiesto, inserisci y, quindi premi INVIO per procedere.

sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Output:

Il servizio Docker si avvierà e si abiliterà automaticamente. Puoi verificare il servizio Docker tramite il seguente comando systemctl.

sudo systemctl is-enabled docker  
sudo systemctl status docker

Dovresti ottenere un output che indica che il servizio Docker è abilitato e verrà eseguito automaticamente all’avvio. E lo stato del servizio Docker è in esecuzione.

Infine, per consentire al tuo utente non root di eseguire il contenitore Docker, devi aggiungere il tuo utente al gruppo ‘ docker ‘. Esegui il comando usermod sottostante per aggiungere il tuo utente al gruppo ‘ docker ‘. Assicurati anche di cambiare il nome utente con il tuo utente.

sudo usermod -aG docker alice

Ora puoi accedere come tuo utente e eseguire il contenitore Docker tramite il comando sottostante.

su - alice  
docker run hello-world

Quando ha successo, dovresti ricevere il messaggio hello-world dal contenitore Docker come nello screenshot seguente.

Download delle immagini Docker di OpenSearch

In questo passaggio, scaricherai le immagini di OpenSearch e OpenSearch Dashboards da DockerHub. Quindi, eseguirai anche un nuovo contenitore OpenSearch per scopi di test.

Esegui il seguente comando per scaricare le immagini di OpenSearch e OpenSearch Dashboards.

docker pull opensearchproject/opensearch:latest  
docker pull opensearchproject/opensearch-dashboards:latest

Output:

Dopo che i download sono terminati, esegui il comando sottostante per controllare l’elenco delle immagini Docker sul tuo sistema. Vedrai che le immagini di OpenSearch e OpenSearch Dashboards sono disponibili sul tuo sistema.

docker images

Output:

Successivamente, puoi anche eseguire OpenSearch tramite Docker direttamente utilizzando il comando sottostante. Questo creerà ed eseguirà il contenitore OpenSearch in modalità singola ed esporrà le porte TCP predefinite 9200 e 9600 sulla macchina host.

docker run -d -p 9200:9200 -p 9600:9600 -e "discovery.type=single-node" opensearchproject/opensearch:latest

Verifica l’elenco del contenitore in esecuzione tramite il comando ‘ docker ps ‘ sottostante.

docker ps

Dovresti ricevere un output come questo - Il contenitore OpenSearch è stato creato ed è in esecuzione. Le porte TCP esposte 9200 e 9600 sia sul contenitore che sull’host Docker.

Puoi accedere al tuo contenitore OpenSearch tramite il comando curl sottostante. Il nome utente e la password predefiniti per il contenitore OpenSearch sono ‘ admin ‘.

curl https://localhost:9200 -ku 'admin:admin'

Quando ha successo, dovresti ottenere un output come questo - Il contenitore OpenSearch è in esecuzione ed è accessibile tramite la macchina host Docker.

Puoi ora eseguire il comando ‘docker’ sottostante per fermare e eliminare il contenitore OpenSearch. Perché nel passaggio successivo, creerai un cluster OpenSearch tramite Docker Compose. Assicurati di cambiare il nome del contenitore nel seguente comando.

docker stop container-name o container-id  
docker rm container-name o container-id

Per assicurarti che il contenitore OpenSearch venga rimosso, esegui il comando ‘docker ps ‘ con l’opzione aggiuntiva ‘ -a ‘. Questo ti mostrerà i contenitori disponibili con entrambi gli stati, in esecuzione ed usciti.

docker ps -a

Output:

Configura la directory del progetto

Accedi al tuo utente con il seguente comando. Questo esempio utilizza un utente ‘alice’, quindi assicurati di cambiare il nome utente nel comando sottostante.

su - alice

Ora crea una nuova directory di progetto ‘ opensearch-project ‘ che sarà utilizzata come la directory principale del tuo progetto, e la directory ‘ certs ‘ che sarà utilizzata per memorizzare i certificati TLS personalizzati.

mkdir -p ~/opensearch-project/certs; cd ~/opensearch-project

All’interno della directory ‘ opensearch-project’, esegui il comando sottostante per creare nuovi file che saranno utilizzati per creare contenitori OpenSearch e OpenSearch Dashboards.

touch docker-compose.yml opensearch.yml opensearch_dashboards.yml internal_users.yml

L’elenco dei file:

• docker-compose.yml - la configurazione principale di Docker Compose per il progetto OpenSearch.
• opensearch.yml - configurazione personalizzata per i contenitori OpenSearch.
• opensearch_dashbaords.yml - configurazione personalizzata per il contenitore OpenSearch Dashboards.
• internal_users.yml - autenticazione e autorizzazione degli utenti personalizzati per OpenSearch e OpenSearch Dashboards.

Generazione di certificati SSL/TLS

In questo passaggio, genererai più certificati TLS che saranno utilizzati per proteggere la tua distribuzione OpenSearch. Genererai i seguenti certificati:

• Certificati CA Root: Questi certificati saranno utilizzati per firmare altri certificati.
• Certificati Admin: Questi certificati saranno utilizzati per ottenere diritti amministrativi per eseguire tutte le attività relative al plugin di sicurezza.
• Certificati OpenSearch Dashboards: Questi certificati saranno utilizzati per proteggere gli OpenSearch Dashboards e ti consentono di accedere a OpenSearch Dashboards tramite connessioni HTTPS.
• Certificati Node e Client: Questi certificati saranno utilizzati dai nodi e dai client all’interno del cluster OpenSearch.

Per iniziare, esegui il comando sottostante per creare nuove directory che saranno utilizzate per memorizzare i certificati TLS.

mkdir -p certs/{ca,os-dashboards}

Crea una nuova variabile di ambiente ‘MYDN’ che sarà utilizzata per creare nuovi certificati TLS. Assicurati di cambiare i dettagli con le tue informazioni.

export MYDN="/C=CA/ST=ONTARIO/L=TORONTO/O=HWDOMAIN"

Ora sei pronto per generare certificati TLS per la tua distribuzione OpenSearch.

Genera certificati CA

Genera una chiave privata per i certificati CA root utilizzando il seguente comando.

openssl genrsa -out certs/ca/ca.key 2048

Ora genera un certificato CA root autofirmato tramite il seguente comando. Il valore del parametro ‘- subj’ utilizza la variabile di ambiente ‘ MYDN ‘ che hai creato nella tua sessione corrente.

openssl req -new -x509 -sha256 -days 1095 -subj "$MYDN/CN=CA" -key certs/ca/ca.key -out certs/ca/ca.pem

Con questo, dovresti ottenere la chiave privata CA root ‘ ca.key ‘ e il certificato CA root ‘ ca.pem ‘. Puoi verificare i certificati CA che hai generato tramite il seguente comando.

ls certs/ca/

Output - Dovresti ottenere la chiave privata CA ‘ ca.key ‘ e il file del certificato CA ‘ ca.pem ‘.

Genera certificati Admin

Genera la nuova chiave privata del certificato admin ‘ admin-temp.key ‘ e converti il certificato generato in un algoritmo compatibile con PKCS#12 (3DES). Con questo, la tua chiave privata admin dovrebbe essere ‘ admin.key ‘.

openssl genrsa -out certs/ca/admin-temp.key 2048  
openssl pkcs8 -inform PEM -outform PEM -in certs/ca/admin-temp.key -topk8 -nocrypt -v1 PBE-SHA1-3DES -out certs/ca/admin.key

Successivamente, esegui il comando sottostante per generare la CSR (Richiesta di firma del certificato) admin dalla chiave privata ‘ admin.key ‘. La tua CSR generata dovrebbe ora essere il file ‘ admin.csr ‘.

openssl req -new -subj "$MYDN/CN=ADMIN" -key certs/ca/admin.key -out certs/ca/admin.csr

Ora esegui il comando sottostante per firmare la CSR admin con il certificato CA root e la chiave privata. L’output del certificato admin è il file ‘ admin.pem ‘.

openssl x509 -req -in certs/ca/admin.csr -CA certs/ca/ca.pem -CAkey certs/ca/ca.key -CAcreateserial -sha256 -out certs/ca/admin.pem

Infine, verifica l’elenco dei tuoi certificati tramite il seguente comando.

ls certs/ca/

Output - Dovresti vedere i file del certificato admin ‘ admin.pem ‘ e la chiave privata ‘ admin.key ‘.

Genera certificati OpenSearch Dashboards

Genera il nuovo certificato che sarà utilizzato per gli OpenSearch Dashboards.

Esegui il seguente comando per generare la chiave privata ‘os-dashboards-temp.key’ e convertire il certificato generato in un algoritmo compatibile con PKCS#12 (3DES). Con questo, la tua chiave privata admin dovrebbe essere ‘ os-dashboards.key ‘.

openssl genrsa -out certs/os-dashboards/os-dashboards-temp.key 2048  
openssl pkcs8 -inform PEM -outform PEM -in certs/os-dashboards/os-dashboards-temp.key -topk8 -nocrypt -v1 PBE-SHA1-3DES -out certs/os-dashboards/os-dashboards.key

Successivamente, esegui il comando sottostante per generare la CSR (Richiesta di firma del certificato) per gli OpenSearch Dashboards. La tua CSR generata dovrebbe ora essere il file ‘ os-dashboards.csr ‘.

openssl req -new -subj "$MYDN/CN=os-dashboards" -key certs/os-dashboards/os-dashboards.key -out certs/os-dashboards/os-dashboards.csr

Ora esegui il comando sottostante per firmare la CSR degli OpenSearch Dashboards con il certificato CA root e la chiave privata. L’output del certificato admin è il file ‘ os-dashboards.pem’ .

openssl x509 -req -in certs/os-dashboards/os-dashboards.csr -CA certs/ca/ca.pem -CAkey certs/ca/ca.key -CAcreateserial -sha256 -out certs/os-dashboards/os-dashboards.pem

Infine, esegui il seguente comando per eliminare il file CSR degli OpenSearch Dashboards e verificare l’elenco dei tuoi certificati per gli OpenSearch Dashboards.

rm certs/os-dashboards/os-dashboards-temp.key certs/os-dashboards/os-dashboards.csr  
ls certs/os-dashboards/

Output - Dovresti vedere i file del certificato OpenSearch Dashboards ‘ os-dashboards.pem’ e la chiave privata ‘ os-dashboards.key ‘.

Genera certificati per i nodi OpenSearch

Esegui il seguente comando per generare certificati per i nodi. Con questo, creerai più directory sotto la directory ‘certs’ e genererai certificati TLS per più host.

for NODE_NAME in "os01" "os02" "os03"  
do  
    mkdir "certs/${NODE_NAME}"  
    openssl genrsa -out "certs/$NODE_NAME/$NODE_NAME-temp.key" 2048  
    openssl pkcs8 -inform PEM -outform PEM -in "certs/$NODE_NAME/$NODE_NAME-temp.key" -topk8 -nocrypt -v1 PBE-SHA1-3DES -out "certs/$NODE_NAME/$NODE_NAME.key"  
    openssl req -new -subj "$MYDN/CN=$NODE_NAME" -key "certs/$NODE_NAME/$NODE_NAME.key" -out "certs/$NODE_NAME/$NODE_NAME.csr"  
    openssl x509 -req -extfile <(printf "subjectAltName=DNS:localhost,IP:127.0.0.1,DNS:$NODE_NAME") -in "certs/$NODE_NAME/$NODE_NAME.csr" -CA certs/ca/ca.pem -CAkey certs/ca/ca.key -CAcreateserial -sha256 -out "certs/$NODE_NAME/$NODE_NAME.pem"  
    rm "certs/$NODE_NAME/$NODE_NAME-temp.key" "certs/$NODE_NAME/$NODE_NAME.csr"  
done

Verifica l’elenco delle directory nella directory ‘certs’.

ls certs/

Output - Dovresti ottenere nuove directory ‘ os01, os02, e os03.

Infine, verifica l’elenco dei certificati disponibili nelle directory os01, os02, e os03 tramite il comando sottostante.

ls certs/os01/  
ls certs/os02/  
ls certs/os03/

Output - In ogni directory, dovresti ottenere due certificati ‘ osX.key ‘ e ‘ osX.pem ‘.

Infine, devi cambiare la proprietà della directory ‘ certs ‘ in ‘ 1000 ‘ tramite il comando sottostante. Questo consentirà ai contenitori Docker di accedere alla directory ‘ certs ‘.

sudo chown -R 1000:1000 certs/

Con i certificati TLS generati, ora genererai password hash e definirai gli utenti OpenSearch.

Configurazione dell’utente

In questo passaggio, genererai un hash della password che sarà utilizzato da OpenSearch e OpenSearch Dashboards. Genererai due hash di password per due utenti diversi, quindi modificherai il file di configurazione ‘internal_users.yml’ e gli utenti OpenSearch.

Esegui il seguente comando docker per generare un nuovo hash della password. Questo eseguirà un contenitore OpenSearch temporaneo e eseguirà lo script ‘ hash.sh ‘ per generare un hash della password.

docker run -it --rm opensearchproject/opensearch sh -c "/usr/share/opensearch/plugins/opensearch-security/tools/hash.sh"

Ora inserisci la tua password e dovresti ottenere l’hash della password nel tuo terminale. Copia l’hash della password generato e riesegui il comando per generare un altro hash della password.

Output - Per l’hash della password generato per gli utenti OpenSearch.

Successivamente, apri il file ‘ internal_users.yml ‘ utilizzando il seguente comando dell’editor nano.

nano internal_users.yml

Aggiungi le seguenti righe al file e assicurati di cambiare l’hash della password con la tua password generata. Con questo, definirai due utenti per la tua distribuzione OpenSearch. l’utente ‘ admin ‘ come amministratore per OpenSearch e l’utente ‘ kibanaserver ‘ che sarà utilizzato per connettersi a OpenSearch Dashboards.

---  
# Questo è il database utente interno  
# Il valore hash è un hash bcrypt e può essere generato con plugin/tools/hash.sh  
  
_meta:  
  type: "internalusers"  
  config_version: 2  
  
# Definisci i tuoi utenti interni qui  
  
admin:  
  hash: "$2y$12$y8UzXWoZKQc8GTgGsRz4g.CarjlC6sMPYN8XOD/NPQysRi2oq.Ws6"  
  reserved: true  
  backend_roles:  
  - "admin"  
  description: "Utente Admin"  
  
kibanaserver:  
  hash: "$2y$12$AKpGe4tM5nIWYFoM56yRue22pQh0jFfx59MUgUKnBu8qnyGeAm2Ze"  
  reserved: true  
  description: "Utente OpenSearch Dashboards"

Salva il file ed esci dall’editor quando hai finito.

Configura lo script docker-compose.yml

In questo passaggio, creerai un nuovo script Docker Compose per distribuire OpenSearch e OpenSearch Dashboards. Creerai più contenitori OpenSearch per impostare il cluster OpenSearch e configurerai un contenitore OpenSearch Dashboards che sarà connesso al cluster OpenSearch.

Apri il file ‘ docker-compose.yml ‘ utilizzando il seguente comando dell’editor nano.

nano docker-compose.yml

Aggiungi le seguenti righe al file.

version: '3.7'  
  
services:  
  
  os01:  
    restart: always  
    image: opensearchproject/opensearch:latest  
    environment:  
      OPENSEARCH_JAVA_OPTS: "-Xms1024m -Xmx1024m" # dimensione minima e massima dell'heap Java, si consiglia di impostare entrambi al 50% della RAM di sistema  
      node.name: os01  
      discovery.seed_hosts: os01,os02,os03  
      cluster.initial_master_nodes: os01,os02,os03  
      plugins.security.ssl.transport.pemkey_filepath: certificates/os01/os01.key # percorso relativo  
      plugins.security.ssl.transport.pemcert_filepath: certificates/os01/os01.pem  
      plugins.security.ssl.http.pemkey_filepath: certificates/os01/os01.key  
      plugins.security.ssl.http.pemcert_filepath: certificates/os01/os01.pem  
      DISABLE_INSTALL_DEMO_CONFIG: "true"  
      JAVA_HOME: /usr/share/opensearch/jdk  
      bootstrap.memory_lock: "true" # insieme alle impostazioni memlock sottostanti, disabilita lo swapping  
      network.host: "0.0.0.0"  
    ulimits:   
      memlock:  
        soft: -1  
        hard: -1  
    volumes:  
      - "./opensearch.yml:/usr/share/opensearch/config/opensearch.yml"  
      - "./internal_users.yml:/usr/share/opensearch/config/opensearch-security/internal_users.yml"  
      - "os-data1:/usr/share/opensearch/data"  
      - "./certs:/usr/share/opensearch/config/certificates:ro"  
    ports:  
      - 9200:9200  
      - 9600:9600 # richiesto per Performance Analyzer  
  
  os02:  
    restart: always  
    image: opensearchproject/opensearch:latest  
    environment:  
      OPENSEARCH_JAVA_OPTS: "-Xms1024m -Xmx1024m" # dimensione minima e massima dell'heap Java, si consiglia di impostare entrambi al 50% della RAM di sistema  
      node.name: os02  
      discovery.seed_hosts: os01,os02,os03  
      cluster.initial_master_nodes: os01,os02,os03  
      plugins.security.ssl.transport.pemkey_filepath: certificates/os02/os02.key # percorso relativo  
      plugins.security.ssl.transport.pemcert_filepath: certificates/os02/os02.pem  
      plugins.security.ssl.http.pemkey_filepath: certificates/os02/os02.key  
      plugins.security.ssl.http.pemcert_filepath: certificates/os02/os02.pem  
      DISABLE_INSTALL_DEMO_CONFIG: "true"  
      JAVA_HOME: /usr/share/opensearch/jdk  
      bootstrap.memory_lock: "true" # insieme alle impostazioni memlock sottostanti, disabilita lo swapping  
      network.host: "0.0.0.0"  
    ulimits:   
      memlock:  
        soft: -1  
        hard: -1  
    volumes:  
      - "./opensearch.yml:/usr/share/opensearch/config/opensearch.yml"  
      - "./internal_users.yml:/usr/share/opensearch/config/opensearch-security/internal_users.yml"  
      - "os-data2:/usr/share/opensearch/data"  
      - "./certs:/usr/share/opensearch/config/certificates:ro"  
  
  os03:  
    restart: always  
    image: opensearchproject/opensearch:latest  
    environment:  
      OPENSEARCH_JAVA_OPTS: "-Xms1024m -Xmx1024m" # dimensione minima e massima dell'heap Java, si consiglia di impostare entrambi al 50% della RAM di sistema  
      node.name: os03  
      discovery.seed_hosts: os01,os02,os03  
      cluster.initial_master_nodes: os01,os02,os03  
      plugins.security.ssl.transport.pemkey_filepath: certificates/os03/os03.key # percorso relativo  
      plugins.security.ssl.transport.pemcert_filepath: certificates/os03/os03.pem  
      plugins.security.ssl.http.pemkey_filepath: certificates/os03/os03.key  
      plugins.security.ssl.http.pemcert_filepath: certificates/os03/os03.pem  
      DISABLE_INSTALL_DEMO_CONFIG: "true"  
      JAVA_HOME: /usr/share/opensearch/jdk  
      bootstrap.memory_lock: "true" # insieme alle impostazioni memlock sottostanti, disabilita lo swapping  
      network.host: "0.0.0.0"  
    ulimits:   
      memlock:  
        soft: -1  
        hard: -1  
    volumes:  
      - "./opensearch.yml:/usr/share/opensearch/config/opensearch.yml"  
      - "./internal_users.yml:/usr/share/opensearch/config/opensearch-security/internal_users.yml"  
      - "os-data3:/usr/share/opensearch/data"  
      - "./certs:/usr/share/opensearch/config/certificates:ro"  
  
  osdashboards:  
    restart: always  
    image: opensearchproject/opensearch-dashboards:latest  
    ports:  
      - 5601:5601  
    volumes:  
      - "./certs:/usr/share/opensearch-dashboards/config/certificates:ro"  
      - "./opensearch_dashboards.yml:/usr/share/opensearch-dashboards/config/opensearch_dashboards.yml"  
    environment:  
      OPENSEARCH_HOSTS: '["https://os01:9200","https://os02:9200","https://os03:9200"]' # deve essere una stringa senza spazi quando specificata come variabile di ambiente  
      DISABLE_INSTALL_DEMO_CONFIG: "true"  
  
volumes:  
  os-data1:  
  os-data2:  
  os-data3:

Salva ed esci dal file ‘ docker-compose.yml ‘ quando hai finito.

Con questo, creerai 4 contenitori/servizi per le distribuzioni OpenSearch. Di seguito sono riportate informazioni dettagliate su ciascun contenitore.

• 3 contenitori OpenSearch os01, os02 e os03 - Questo sarà utilizzato per creare il cluster OpenSearch. Questi contenitori sono basati sull’immagine ‘ opensearchproject/opensearch:latest ‘ e le stesse configurazioni ‘ opensearch.yml ‘ e ‘ internal_users.yml’.
• Un contenitore OpenSearch Dashboards ‘osdashboards’ è basato sull’immagine ‘ opensearchproject/opensearch-dashboards:latest ‘ ed è connesso a tre host di OpenSearch os01, os02 e os03. Inoltre, disabiliterai la configurazione demo sul contenitore OpenSearch Dashboards.
• Tutti i contenitori OpenSearch e OpenSearch Dashboards saranno protetti tramite certificati TLS personalizzati disponibili nella directory ‘ certs ‘.
• Il contenitore OpenSearch esporrà due porte 9200 e 9600, e il contenitore OpenSearch Dashboards esporrà la porta 5601.

Configura OpenSearch e OpenSearch Dashboards

In questo passaggio, creerai una nuova configurazione per OpenSearch ‘opensearch.yml’ e OpenSearch Dashboards ‘opensearch_dashbaords.yml’. Alla fine, devi assicurarti che tutte le configurazioni e i certificati necessari siano disponibili nella directory del progetto OpenSearch.

Apri il file di configurazione di OpenSearch ‘ opensearch.yml ‘ utilizzando il seguente comando dell’editor nano.

sudo nano opensearch.yml

Aggiungi le seguenti righe al file. Assicurati di cambiare il percorso dei certificati CA e DN per entrambi i certificati admin e nodo. Con questo, imposterai un cluster OpenSearch con il nome ‘ os-cluster ‘.

cluster.name: os-cluster  
network.host: 0.0.0.0  
  
bootstrap.memory_lock: "true" # insieme alle impostazioni memlock sottostanti, disabilita lo swapping  
  
plugins.security.allow_unsafe_democertificates: true  
plugins.security.ssl.http.enabled: true  
plugins.security.ssl.http.pemtrustedcas_filepath: certificates/ca/ca.pem  
plugins.security.ssl.transport.enabled: true  
plugins.security.ssl.transport.pemtrustedcas_filepath: certificates/ca/ca.pem  
plugins.security.ssl.transport.enforce_hostname_verification: false  
  
plugins.security.authcz.admin_dn:  
  - 'CN=ADMIN,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'  
plugins.security.nodes_dn:  
  - 'CN=os00,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'  
  - 'CN=os01,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'  
  - 'CN=os02,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'  
  - 'CN=os03,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'  
  - 'CN=os04,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'  
  - 'CN=os05,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'  
  - 'CN=os06,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'  
  - 'CN=os07,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'  
  
plugins.security.audit.type: internal_opensearch  
plugins.security.enable_snapshot_restore_privilege: true  
plugins.security.check_snapshot_restore_write_privileges: true  
plugins.security.restapi.roles_enabled: ["all_access", "security_rest_api_access"]  
cluster.routing.allocation.disk.threshold_enabled: false  
opendistro_security.audit.config.disabled_rest_categories: NONE  
opendistro_security.audit.config.disabled_transport_categories: NONE

Salva il file ‘opensearch.yml’ ed esci dall’editor quando hai finito.

Successivamente, apri il file di configurazione di OpenSearch Dashboards ‘ opensearch_dashboards.yml ‘ utilizzando il seguente comando dell’editor nano.

nano opensearch_dashboards.yml

Aggiungi le seguenti righe al file. Assicurati di cambiare il nome utente e la password degli OpenSearch Dashboards con i dettagli dell’utente ‘ kibanaserver ‘ nel file ‘internal_users.yml**.

server.name: os_dashboards  
server.host: "0.0.0.0"  
  
opensearch.username: kibanaserver  
opensearch.password: password  
opensearch.requestHeadersWhitelist: [authorization, securitytenant]  
  
opensearch_security.multitenancy.enabled: true  
opensearch_security.multitenancy.tenants.preferred: [Private, Global]  
opensearch_security.readonly_mode.roles: [kibana_read_only]  
# Usa questa impostazione se stai eseguendo opensearch-dashboards senza https  
opensearch_security.cookie.secure: false  
  
# Cripta il traffico tra il browser e OpenSearch-Dashboards  
server.ssl.enabled: true  
server.ssl.certificate: "/usr/share/opensearch-dashboards/config/certificates/os-dashboards/os-dashboards.pem"  
server.ssl.key: "/usr/share/opensearch-dashboards/config/certificates/os-dashboards/os-dashboards.key"  
  
# Cripta il traffico tra OpenSearch-Dashboards e Opensearch  
opensearch.ssl.certificateAuthorities: ["/usr/share/opensearch-dashboards/config/certificates/ca/ca.pem"]  
opensearch.ssl.verificationMode: full

Salva ed esci dal file quando hai finito.

Infine, esegui il comando apt sottostante per installare il pacchetto tree e verificare l’elenco di file e directory della tua distribuzione OpenSearch.

sudo apt install tree  
tree .

Dovresti ricevere un output come questo.

Con questo, tutta la preparazione per distribuire OpenSearch tramite Docker è finita. Sei pronto per distribuire OpenSearch tramite Docker e Docker Compose.

Distribuzione del cluster OpenSearch e di OpenSearch Dashboards

Prima di iniziare, assicurati di essere nella directory del progetto OpenSearch ‘ opensearch-project ‘. Quindi, esegui il seguente comando ‘ docker compose ‘ per creare e avviare la distribuzione di OpenSearch.

docker compose up -d

Dovresti ricevere un output come questo - Sono stati creati e avviati 3 contenitori OpenSearch os01, os02 e os03. Inoltre, il contenitore OpenSearch Dashboards ‘ osdashboards ‘ è stato creato e avviato.

Verifica l’elenco dei servizi/contenitori in esecuzione nel tuo progetto OpenSearch tramite il seguente comando.

docker compose ps

Se vedi che lo ‘ STATO ‘ è ‘ Up ‘, allora il contenitore/servizio è in esecuzione. Nella sezione ‘ PORTS ‘ dovresti vedere le porte esposte dal contenitore alla macchina host.

Con il cluster OpenSearch in esecuzione, ora devi applicare la nuova configurazione utente che hai creato tramite il file ‘ internal_users.yml ‘. Per raggiungere questo obiettivo, puoi eseguire il seguente comando ‘ docker ‘. Assicurati anche di attendere circa 30-60 secondi prima di eseguire questo comando per assicurarti che il cluster OpenSearch sia in esecuzione.

Il seguente comando eseguirà lo script bash ‘ securityadmin.sh ‘ sul contenitore/servizio ‘ os01 ‘ e applicherà i nuovi utenti al tuo cluster OpenSearch.

docker compose exec os01 bash -c "chmod +x plugins/opensearch-security/tools/securityadmin.sh && bash plugins/opensearch-security/tools/securityadmin.sh -cd config/opensearch-security -icl -nhnv -cacert config/certificates/ca/ca.pem -cert config/certificates/ca/admin.pem -key config/certificates/ca/admin.key -h localhost"

Output:

Successivamente, esegui il seguente comando per assicurarti che il contenitore sia in esecuzione. Quindi, puoi verificare l’elenco delle porte aperte sull’host Docker tramite il comando ss sottostante.

docker compose ps  
ss -tulpn

Output - le porte 9200 e 9600 sono utilizzate dal cluster OpenSearch e la porta 5601 è utilizzata da OpenSearch Dashboards.

Infine, puoi verificare di autenticarti nel cluster OpenSearch tramite il nome utente e la password che hai creato nel file ‘internal_users.yml’.

Effettua un’autenticazione come utente admin nel cluster OpenSearch.

curl https://192.168.5.100:9200 -u admin:password -k

Output - L’autenticazione ha avuto successo e dovresti vedere i dettagli del software OpenSearch che stai attualmente utilizzando nel tuo cluster.

Effettua un’autenticazione come utente kibanaserver nel cluster OpenSearch.

curl https://192.168.5.100:9200 -u kibanaserver:password -k

Output - L’autenticazione ha avuto successo e dovresti vedere i dettagli del software OpenSearch che stai attualmente utilizzando nel tuo cluster.

Con questo, hai ora distribuito il cluster OpenSearch e OpenSearch Dashboards tramite Docker e Docker Compose. Nel passaggio successivo, accederai alla tua distribuzione OpenSearch Dashboards e verificherai la connessione tra OpenSearch Dashboards e il cluster OpenSearch.

Inoltre, quando hai un errore nella tua distribuzione OpenSearch, puoi controllare i log per ciascun contenitore tramite il comando ‘ docker compose ‘ sottostante.

Utilizzo di base ‘ docker compose ‘ per controllare i log.

docker compose logs  
docker compose logs SERVICE

Controllo dei log per contenitori/servizi specifici tramite il comando ‘ docker compose ‘.

docker compose logs osdashboards  
docker compose logs os01  
docker compose logs os02  
docker compose logs os03

Accesso a OpenSearch Dashboards

Apri il tuo browser web e visita l’indirizzo IP del tuo server seguito dalla porta OpenSearch Dashboards ‘ 5601 ‘ (i.e: https://192.168.5.100:5601/). Dovresti ottenere la pagina di accesso di OpenSearch Dashboards.

Inserisci l’utente ‘kibanaserver’ e la password, quindi fai clic su ‘ Accedi ‘.

Quando ha successo, dovresti ottenere la seguente pagina. Fai clic su ‘ Esplora da solo ‘ e dovresti vedere la home page di OpenSearch Dashboard.

Con questo, hai OpenSearch Dashboards in esecuzione e l’autenticazione è abilitata. Inoltre, gli OpenSearch Dashboards sono in esecuzione sotto connessioni HTTPS sicure tramite i certificati SSL/TLS che hai generato.

Successivamente, verifica la connessione tra OpenSearch Dashboards e il cluster OpenSearch tramite l’API OpenSearch.

Fai clic sul menu a sinistra per passare alla sezione Gestione e fai clic su ‘ Strumenti per sviluppatori ‘.

Ora inserisci la query ‘ GET / ‘ nella console e fai clic sul pulsante di riproduzione. Quando ha successo, dovresti vedere l’output sul lato destro con informazioni dettagliate sul tuo server OpenSearch. Inoltre, puoi vedere in alto a destra il codice HTTP ‘ 200 - OK ‘ che conferma che la query è stata eseguita senza errori.

Inserisci un’altra query ‘ GET _cat/nodes?format=json&filter_path=ip,name ‘ per verificare i nodi OpenSearch disponibili nel cluster OpenSearch. Dovresti vedere tre nodi diversi nel cluster OpenSearch, os01 con indirizzo IP 172.23.0.5, os02 con indirizzo IP ‘ 172.23.0.3 ‘, e os3 con indirizzo IP ‘ 172.23.0.2 ‘.

Questo conferma che gli OpenSearch Dashboards sono connessi al cluster OpenSearch.

Conclusione

In questo tutorial, hai installato OpenSearch tramite Docker e Docker Compose su un server Ubuntu 22.04. Hai creato un cluster OpenSearch con 3 contenitori diversi su Docker. Hai anche protetto OpenSearch con certificati TLS, abilitato l’autenticazione e l’autorizzazione e configurato gli utenti in OpenSearch. Inoltre, hai anche configurato e ottimizzato un server Linux Ubuntu per distribuire OpenSearch.

Hai anche installato gli OpenSearch Dashboards tramite Docker e Docker Compose. Poi, hai anche connesso il contenitore OpenSearch Dashboards al cluster OpenSearch.

Con questa configurazione, ora puoi esplorare di più su OpenSearch, aggiungere alcune integrazioni al tuo OpenSearch, impostare ulteriori autenticazioni e molto altro. Puoi saperne di più su tutto ciò che riguarda OpenSearch dalla documentazione ufficiale di OpenSearch.