So installieren Sie OpenSearch über Docker auf Ubuntu 22.04

OpenSearch ist ein von der Community betriebenes Projekt von Amazon und ein Fork von Elasticsearch und Kibana. Es ist eine vollständig Open-Source-Suchmaschine und Analysesoftware mit umfangreichen Funktionen und innovativer Funktionalität. Die Hauptkomponente des OpenSearch-Projekts ist OpenSearch (ein Fork von Elasticsearch) und die OpenSearch Dashboards (ein Fork von Kibana). Beide Komponenten bieten Funktionen wie Unternehmenssicherheit, Alarmierung, maschinelles Lernen, SQL, Indexstatusverwaltung und mehr.

OpenSearch ist 100 % Open Source und lizenziert unter Apache 2.0. Es ermöglicht Ihnen, Daten für eine Vielzahl von Anwendungsfällen wie Log-Analysen, Anwendungssuche, Unternehmenssuche und mehr einfach zu ingestieren, zu sichern, zu durchsuchen, zu aggregieren, anzuzeigen und zu analysieren.

In diesem Tutorial installieren und richten Sie OpenSearch - eine Open-Source-Suchmaschine und Analysesoftware - und OpenSearch Dashboards - ein Open-Source-Visualisierungstool - über Docker auf einem Ubuntu 22.04-Server ein. Sie werden ein OpenSearch-Cluster mit mehreren Containern und einem einzelnen OpenSearch-Dashboard über Docker und Docker Compose bereitstellen. Sie sichern auch Ihre Bereitstellung mit benutzerdefinierten TLS-Zertifikaten sowie aktivierter Authentifizierung und Autorisierung.

Dieser Leitfaden verwendet einen frischen generischen Ubuntu-Server, daher umfasst dieses Tutorial die Installation der Docker-Engine und von Docker Compose auf einem Ubuntu 22.04-System.

Voraussetzungen

Um diesen Leitfaden abzuschließen, müssen Sie die folgenden Anforderungen erfüllen:

• Ein Ubuntu 22.04-Server mit mindestens 4-8 GB RAM - Dieses Beispiel verwendet einen Ubuntu-Server mit dem Hostnamen ‘’ und einer IP-Adresse ‘’.
• Ein Nicht-Root-Benutzer mit sudo/root-Administratorrechten.

Wenn diese Anforderungen bereit sind, können Sie nun mit der Installation von OpenSearch beginnen.

System einrichten

In diesem ersten Schritt bereiten Sie Ihr Ubuntu-System für die OpenSearch-Bereitstellung vor. Sie müssen SWAP und Paging deaktivieren, dann erhöhen Sie die maximale Speicherzuordnung über die Datei ‘/etc/sysctl.conf ‘.

Führen Sie den folgenden Befehl aus, um den Swap auf Ihrem System zu deaktivieren. Der ‘sed’-Befehl hier wird den Swap dauerhaft über die Datei ‘/etc/fstab ‘ deaktivieren, indem er den Kommentar ‘# ‘ an den Anfang der Zeile der Swap-Konfiguration hinzufügt. Der ‘swapoff ‘ Befehl wird den Swap in der aktuellen Sitzung deaktivieren.

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

Als Nächstes überprüfen Sie den Swap-Status über den folgenden Befehl. Wenn deaktiviert, sollten Sie eine Ausgabe von ‘0 ‘ im Swap-Bereich erhalten.

free -m

Ausgabe:

Schließlich fügen Sie die Konfiguration zur Datei ‘/etc/sysctl.conf ‘ hinzu, um die maximalen Speicherzuweisungen auf Ihrem Ubuntu-System zu erhöhen.

Führen Sie den folgenden Befehl aus, um den Parameter ‘vm.max_map_count=262144 ‘ an das Ende der Zeile der Datei ‘/etc/sysctl.conf ‘ hinzuzufügen. Wenden Sie dann die Änderungen über den Befehl ‘sysctl -p ‘ an.

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

Überprüfen Sie nun die maximalen Speicherzuweisungen, indem Sie den folgenden Befehl ausführen. Wenn erfolgreich, sollte Ihre maximale Speicherzuordnung ‘262144 ‘ sein.

cat /proc/sys/vm/max_map_count

Ausgabe:

Mit deaktiviertem Swap und erhöhter maximaler Speicherzuordnung auf ‘262144 ‘ beginnen Sie nun mit der Installation der Docker-Engine und von Docker Compose.

Docker CE und Docker Compose installieren

Es gibt mehrere Möglichkeiten, OpenSearch bereitzustellen und zu installieren. Sie können OpenSearch auf herkömmliche Weise auf einer virtuellen Maschine installieren oder in einer Containerumgebung installieren.

Wenn Sie die traditionelle Installation auf einer virtuellen Maschine bevorzugen, können Sie OpenSearch manuell über Tarball oder über den Paketmanager (für RHEL-basierte Distributionen) installieren. Für die Containerbereitstellung können Sie OpenSearch mit Docker und Kubernetes installieren.

In diesem Beispiel installieren Sie OpenSearch in der containerisierten Umgebung über die Docker-Engine und Docker Compose. Daher installieren Sie jetzt die Docker-Pakete aus dem offiziellen Docker-Repository.

Um zu beginnen, führen Sie den folgenden apt-Befehl aus, um die grundlegenden Abhängigkeiten zu installieren. Geben Sie y ein, wenn Sie dazu aufgefordert werden, und drücken Sie ENTER, um fortzufahren.

sudo apt install ca-certificates curl gnupg lsb-release

Ausgabe:

Führen Sie als Nächstes den folgenden Befehl aus, um den GPG-Schlüssel und das Repository für Docker-Pakete hinzuzufügen.

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

Ausgabe:

Danach aktualisieren und aktualisieren Sie Ihr Ubuntu-Paket-Index über den folgenden apt-Befehl.

sudo apt update

Ausgabe:

Mit dem hinzugefügten Docker-Repository können Sie jetzt die Docker-Engine und das Docker Compose-Plugin mit dem folgenden apt-Befehl installieren. Wenn Sie dazu aufgefordert werden, geben Sie y ein und drücken Sie ENTER, um fortzufahren.

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

Ausgabe:

Der Docker-Dienst wird automatisch gestartet und aktiviert. Sie können den Docker-Dienst über das folgende Systemctl-Befehlsdienstprogramm überprüfen.

sudo systemctl is-enabled docker  
sudo systemctl status docker

Sie sollten eine Ausgabe erhalten, dass der Docker-Dienst aktiviert ist und automatisch beim Booten ausgeführt wird. Und der Status des Docker-Dienstes ist aktiv.

Schließlich, um Ihrem Nicht-Root-Benutzer zu erlauben, den Docker-Container auszuführen, müssen Sie Ihren Benutzer zur Gruppe ‘docker ‘ hinzufügen. Führen Sie den folgenden usermod-Befehl aus, um Ihren Benutzer zur Gruppe ‘docker ‘ hinzuzufügen. Stellen Sie auch sicher, dass Sie den Benutzernamen mit Ihrem Benutzer ändern.

sudo usermod -aG docker alice

Sie können sich jetzt als Ihr Benutzer anmelden und den Docker-Container über den folgenden Befehl ausführen.

su - alice  
docker run hello-world

Wenn erfolgreich, sollten Sie die hello-world-Nachricht vom Docker-Container wie im folgenden Screenshot erhalten.

OpenSearch Docker-Images herunterladen

In diesem Schritt laden Sie OpenSearch- und OpenSearch Dashboards-Images von DockerHub herunter. Dann werden Sie auch einen neuen OpenSearch-Container zu Testzwecken ausführen.

Führen Sie den folgenden Befehl aus, um die OpenSearch- und OpenSearch Dashboards-Images herunterzuladen.

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

Ausgabe:

Nachdem die Downloads abgeschlossen sind, führen Sie den folgenden Befehl aus, um die Liste der Docker-Images auf Ihrem System zu überprüfen. Sie sollten sehen, dass die OpenSearch- und OpenSearch Dashboards-Images auf Ihrem System verfügbar sind.

docker images

Ausgabe:

Als Nächstes können Sie OpenSearch auch direkt über Docker mit dem folgenden Befehl ausführen. Dies wird den OpenSearch-Container im Einzelmodus erstellen und ausführen und den Standard-TCP-Port 9200 und 9600 auf dem Host-Rechner freigeben.

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

Überprüfen Sie die Liste der laufenden Container über den Befehl ‘docker ps ‘ unten.

docker ps

Sie sollten eine Ausgabe wie diese erhalten - Der OpenSearch-Container wurde erstellt und läuft. Freigegebene TCP-Ports 9200 und 9600 sowohl im Container als auch auf dem Docker-Host.

Sie können auf Ihren OpenSearch-Container über den curl-Befehl unten zugreifen. Der Standardbenutzername und das Passwort für den OpenSearch-Container sind ‘admin ‘.

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

Wenn erfolgreich, sollten Sie eine Ausgabe wie diese erhalten - Der OpenSearch-Container läuft und ist über die Docker-Hostmaschine zugänglich.

Sie können jetzt den folgenden ‘docker’-Befehl ausführen, um den OpenSearch-Container zu stoppen und zu löschen. Denn im nächsten Schritt werden Sie ein OpenSearch-Cluster über Docker Compose erstellen. Stellen Sie sicher, dass Sie den Containernamen im folgenden Befehl ändern.

docker stop container-name oder container-id  
docker rm container-name oder container-id

Um sicherzustellen, dass der OpenSearch-Container entfernt wurde, führen Sie den ‘docker ps ‘ Befehl mit der zusätzlichen Option ‘-a ‘ aus. Dies zeigt Ihnen verfügbare Container mit beiden Status, laufend und beendet.

docker ps -a

Ausgabe:

Projektverzeichnis einrichten

Melden Sie sich mit dem folgenden Befehl bei Ihrem Benutzer an. Dieses Beispiel verwendet einen Benutzer ‘alice’, also stellen Sie sicher, dass Sie den Benutzernamen im folgenden Befehl ändern.

su - alice

Erstellen Sie nun ein neues Projektverzeichnis ‘opensearch-project ‘, das als Hauptstammverzeichnis Ihres Projekts verwendet wird, und das ‘certs ‘ Verzeichnis, das verwendet wird, um benutzerdefinierte TLS-Zertifikate zu speichern.

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

Innerhalb des ‘opensearch-project’ Verzeichnisses führen Sie den folgenden Befehl aus, um neue Dateien zu erstellen, die verwendet werden, um OpenSearch-Container und die OpenSearch Dashboards zu erstellen.

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

Die Liste der Dateien:

• docker-compose.yml - die Hauptkonfiguration von Docker Compose für das OpenSearch-Projekt.
• opensearch.yml - benutzerdefinierte Konfiguration für OpenSearch-Container.
• opensearch_dashbaords.yml - benutzerdefinierte Konfiguration für den OpenSearch Dashboards-Container.
• internal_users.yml - benutzerdefinierte Benutzer-Authentifizierung und -Autorisierung für OpenSearch und OpenSearch Dashboards.

SSL/TLS-Zertifikate generieren

In diesem Schritt generieren Sie mehrere TLS-Zertifikate, die verwendet werden, um Ihre OpenSearch-Bereitstellung zu sichern. Sie werden die folgenden Zertifikate generieren:

• Root-CA-Zertifikate: Diese Zertifikate werden verwendet, um andere Zertifikate zu signieren.
• Admin-Zertifikate: Diese Zertifikate werden verwendet, um administrative Rechte zu erhalten, um alle Aufgaben im Zusammenhang mit dem Sicherheitsplugin auszuführen.
• OpenSearch Dashboards-Zertifikate: Diese Zertifikate werden verwendet, um die OpenSearch Dashboards zu sichern und ermöglichen Ihnen den Zugriff auf die OpenSearch Dashboards über HTTPS-Verbindungen.
• Node- und Client-Zertifikate: Diese Zertifikate werden von Knoten und Clients innerhalb des OpenSearch-Clusters verwendet.

Um zu beginnen, führen Sie den folgenden Befehl aus, um neue Verzeichnisse zu erstellen, die für die Speicherung von TLS-Zertifikaten verwendet werden.

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

Erstellen Sie eine neue Umgebungsvariable ‘MYDN’, die verwendet wird, um neue TLS-Zertifikate zu erstellen. Stellen Sie sicher, dass Sie die Details mit Ihren Informationen ändern.

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

Jetzt sind Sie bereit, TLS-Zertifikate für Ihre OpenSearch-Bereitstellung zu generieren.

CA-Zertifikate generieren

Generieren Sie einen privaten Schlüssel für die Root-CA-Zertifikate mit dem folgenden Befehl.

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

Generieren Sie nun ein selbstsigniertes Root-CA-Zertifikat über den folgenden Befehl. Der Wert des Parameters ‘- subj’ verwendet die Umgebungsvariable ‘MYDN ‘, die Sie in Ihrer aktuellen Sitzung erstellt haben.

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

Damit sollten Sie den privaten Schlüssel der Root-CA ‘ca.key ‘ und das Root-CA-Zertifikat ‘ca.pem ‘ erhalten. Sie können die CA-Zertifikate, die Sie generiert haben, über den folgenden Befehl überprüfen.

ls certs/ca/

Ausgabe - Sie sollten die CA-Privatschlüssel ‘ca.key ‘ und das CA-Zertifikat ‘ca.pem ‘ erhalten.

Admin-Zertifikate generieren

Generieren Sie den neuen privaten Schlüssel für das Admin-Zertifikat ‘admin-temp.key ‘ und konvertieren Sie das generierte Zertifikat in einen PKCS#12-kompatiblen Algorithmus (3DES). Damit sollte Ihr privater Schlüssel für den Admin ‘admin.key ‘ sein.

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

Führen Sie als Nächstes den folgenden Befehl aus, um die Admin-CSR (Certificate Signing Request) aus dem privaten Schlüssel ‘admin.key ‘ zu generieren. Ihre generierte CSR sollte jetzt die Datei ‘admin.csr ‘ sein.

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

Führen Sie nun den folgenden Befehl aus, um die Admin-CSR mit dem Root-CA-Zertifikat und dem privaten Schlüssel zu signieren. Die Ausgabe des Admin-Zertifikats ist die Datei ‘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

Überprüfen Sie zuletzt die Liste Ihrer Zertifikate über den folgenden Befehl.

ls certs/ca/

Ausgabe - Sie sollten die Admin-Zertifikatdateien ‘admin.pem ‘ und den privaten Schlüssel ‘admin.key ‘ sehen.

OpenSearch Dashboards-Zertifikate generieren

Generieren Sie das neue Zertifikat, das für die OpenSearch Dashboards verwendet wird.

Führen Sie den folgenden Befehl aus, um den privaten Schlüssel ‘os-dashboards-temp.key ‘ zu generieren und das generierte Zertifikat in einen PKCS#12-kompatiblen Algorithmus (3DES) zu konvertieren. Damit sollte Ihr privater Schlüssel für das Admin-Zertifikat ‘os-dashboards.key ‘ sein.

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

Führen Sie als Nächstes den folgenden Befehl aus, um die CSR (Certificate Signing Request) für die OpenSearch Dashboards zu generieren. Ihre generierte CSR sollte jetzt die Datei ‘os-dashboards.csr ‘ sein.

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

Führen Sie nun den folgenden Befehl aus, um die OpenSearch Dashboards-CSR mit dem Root-CA-Zertifikat und dem privaten Schlüssel zu signieren. Die Ausgabe des Admin-Zertifikats ist die Datei ‘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

Führen Sie zuletzt den folgenden Befehl aus, um die OpenSearch Dashboards-CSR-Datei zu löschen und die Liste Ihrer Zertifikate für die OpenSearch Dashboards zu überprüfen.

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

Ausgabe - Sie sollten die OpenSearch Dashboards-Zertifikatdateien ‘os-dashboards.pem ‘ und den privaten Schlüssel ‘os-dashboards.key ‘ sehen.

Zertifikate für OpenSearch-Knoten generieren

Führen Sie den folgenden Befehl aus, um Knoten-Zertifikate zu generieren. Damit erstellen Sie mehrere Verzeichnisse im Verzeichnis ‘certs ‘ und generieren TLS-Zertifikate für mehrere Hosts.

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

Überprüfen Sie die Liste der Verzeichnisse im Verzeichnis ‘certs ‘.

ls certs/

Ausgabe - Sie sollten die neuen Verzeichnisse ‘os01, os02, und os03 ‘ erhalten.

Überprüfen Sie zuletzt die Liste der Zertifikate, die in den Verzeichnissen os01, os02, und os03 verfügbar sind, über den folgenden Befehl.

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

Ausgabe - In jedem Verzeichnis sollten Sie zwei Zertifikate ‘osX.key ‘ und ‘osX.pem ‘ erhalten.

Zuletzt müssen Sie den Besitz des Verzeichnisses ‘certs ‘ über den folgenden Befehl auf ‘1000 ‘ ändern. Dies ermöglicht es den Docker-Containern, auf das Verzeichnis ‘certs ‘ zuzugreifen.

sudo chown -R 1000:1000 certs/

Mit generierten TLS-Zertifikaten werden Sie nun gehashte Passwörter generieren und OpenSearch-Benutzer definieren.

Benutzer einrichten

In diesem Schritt generieren Sie einen Passwort-Hash, der von OpenSearch und OpenSearch Dashboards verwendet wird. Sie generieren zwei Passwort-Hashes für zwei verschiedene Benutzer und ändern dann die Konfigurationsdatei ‘internal_users.yml ‘ und die OpenSearch-Benutzer.

Führen Sie den folgenden Docker-Befehl aus, um einen neuen Passwort-Hash zu generieren. Dies wird einen temporären OpenSearch-Container ausführen und das Skript ‘hash.sh ‘ zum Generieren eines Passwort-Hashes ausführen.

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

Geben Sie jetzt Ihr Passwort ein und Sie sollten den gehashten Passwort-Hash in Ihrem Terminal erhalten. Kopieren Sie das generierte Hash-Passwort und führen Sie den Befehl erneut aus, um ein weiteres Hash-Passwort zu generieren.

Ausgabe - Zum gehashten Passwort, das für OpenSearch-Benutzer generiert wurde.

Öffnen Sie als Nächstes die Datei ‘internal_users.yml ‘ mit dem folgenden Nano-Editor-Befehl.

nano internal_users.yml

Fügen Sie die folgenden Zeilen in die Datei ein und stellen Sie sicher, dass Sie das gehashte Passwort mit Ihrem generierten Passwort ändern. Damit definieren Sie zwei Benutzer für Ihre OpenSearch-Bereitstellung. Der Benutzer ‘admin ‘ als Administrator für OpenSearch und der Benutzer ‘kibanaserver ‘, der verwendet wird, um sich mit den OpenSearch Dashboards zu verbinden.

---  
# Dies ist die interne Benutzerdatenbank  
# Der Hashwert ist ein bcrypt-Hash und kann mit plugin/tools/hash.sh generiert werden  

_meta:  
  type: "internalusers"  
  config_version: 2  

# Definieren Sie hier Ihre internen Benutzer  

admin:  
  hash: "$2y$12$y8UzXWoZKQc8GTgGsRz4g.CarjlC6sMPYN8XOD/NPQysRi2oq.Ws6"  
  reserved: true  
  backend_roles:  
  - "admin"  
  description: "Admin-Benutzer"  
  
kibanaserver:  
  hash: "$2y$12$AKpGe4tM5nIWYFoM56yRue22pQh0jFfx59MUgUKnBu8qnyGeAm2Ze"  
  reserved: true  
  description: "OpenSearch Dashboards-Benutzer"

Speichern Sie die Datei und beenden Sie den Editor, wenn Sie fertig sind.

Docker-Compose.yml-Skript einrichten

In diesem Schritt erstellen Sie ein neues Docker Compose-Skript für die Bereitstellung von OpenSearch und OpenSearch Dashboards. Sie erstellen mehrere OpenSearch-Container, um das OpenSearch-Cluster einzurichten, und Sie richten einen OpenSearch Dashboards-Container ein, der mit dem OpenSearch-Cluster verbunden ist.

Öffnen Sie die Datei ‘docker-compose.yml ‘ mit dem folgenden Nano-Editor-Befehl.

nano docker-compose.yml

Fügen Sie die folgenden Zeilen in die Datei ein.

version: '3.7'  
  
services:  
  
  os01:  
    restart: always  
    image: opensearchproject/opensearch:latest  
    environment:  
      OPENSEARCH_JAVA_OPTS: "-Xms1024m -Xmx1024m" # minimale und maximale Java-Heap-Größe, empfehlen, beide auf 50 % des System-RAMs einzustellen  
      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 # relativer Pfad  
      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" # zusammen mit den memlock-Einstellungen unten, deaktiviert das 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 # erforderlich für Performance Analyzer  
  
  os02:  
    restart: always  
    image: opensearchproject/opensearch:latest  
    environment:  
      OPENSEARCH_JAVA_OPTS: "-Xms1024m -Xmx1024m" # minimale und maximale Java-Heap-Größe, empfehlen, beide auf 50 % des System-RAMs einzustellen  
      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 # relativer Pfad  
      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" # zusammen mit den memlock-Einstellungen unten, deaktiviert das 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" # minimale und maximale Java-Heap-Größe, empfehlen, beide auf 50 % des System-RAMs einzustellen  
      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 # relativer Pfad  
      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" # zusammen mit den memlock-Einstellungen unten, deaktiviert das 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"]' # muss eine Zeichenfolge ohne Leerzeichen sein, wenn sie als Umgebungsvariable angegeben wird  
      DISABLE_INSTALL_DEMO_CONFIG: "true"  
  
volumes:  
  os-data1:  
  os-data2:  
  os-data3:

Speichern Sie die Datei ‘docker-compose.yml ‘ und beenden Sie den Editor, wenn Sie fertig sind.

Damit erstellen Sie 4 Container/Dienste für die OpenSearch-Bereitstellungen. Nachfolgend finden Sie detaillierte Informationen zu jedem Container.

• 3 OpenSearch-Container os01, os02 und os03 - Diese werden verwendet, um das OpenSearch-Cluster zu erstellen. Diese Container basieren auf dem Image ‘opensearchproject/opensearch:latest ‘ und den gleichen Konfigurationen ‘opensearch.yml ‘ und ‘internal_users.yml ‘.
• Ein OpenSearch Dashboards-Container ‘osdashboards ‘ basiert auf dem Image ‘opensearchproject/opensearch-dashboards:latest ‘ und ist mit den drei Hosts von OpenSearch os01, os02 und os03 verbunden. Außerdem deaktivieren Sie die Demokonfiguration im OpenSearch Dashboards-Container.
• Alle OpenSearch- und OpenSearch Dashboards-Container werden über benutzerdefinierte TLS-Zertifikate gesichert, die im Verzeichnis ‘certs ‘ verfügbar sind.
• Der OpenSearch-Container gibt zwei Ports 9200 und 9600 frei, und der OpenSearch Dashboards-Container gibt den Port 5601 frei.

OpenSearch und OpenSearch Dashboards einrichten

In diesem Schritt erstellen Sie eine neue Konfiguration für OpenSearch ‘opensearch.yml ‘ und OpenSearch Dashboards ‘opensearch_dashbaords.yml ‘. Am Ende müssen Sie sicherstellen, dass alle erforderlichen Konfigurationen und Zertifikate im OpenSearch-Projektverzeichnis verfügbar sind.

Öffnen Sie die OpenSearch-Konfigurationsdatei ‘opensearch.yml ‘ mit dem folgenden Nano-Editor-Befehl.

sudo nano opensearch.yml

Fügen Sie die folgenden Zeilen in die Datei ein. Stellen Sie sicher, dass Sie den Pfad der CA-Zertifikate und den DN sowohl für die Admin- als auch für die Knoten-Zertifikate ändern. Damit richten Sie ein OpenSearch-Cluster mit dem Namen ‘os-cluster ‘ ein.

cluster.name: os-cluster  
network.host: 0.0.0.0  
  
bootstrap.memory_lock: "true" # zusammen mit den memlock-Einstellungen unten, deaktiviert das 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

Speichern Sie die Datei ‘opensearch.yml ‘ und beenden Sie den Editor, wenn Sie fertig sind.

Öffnen Sie als Nächstes die OpenSearch Dashboards-Konfigurationsdatei ‘opensearch_dashboards.yml ‘ mit dem folgenden Nano-Editor-Befehl.

nano opensearch_dashboards.yml

Fügen Sie die folgenden Zeilen in die Datei ein. Stellen Sie sicher, dass Sie den Benutzernamen und das Passwort der OpenSearch Dashboards mit den Details des Benutzers ‘kibanaserver ‘ in der Datei ‘internal_users.yml ‘ ändern.

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]  
# Verwenden Sie diese Einstellung, wenn Sie OpenSearch-Dashboards ohne https ausführen  
opensearch_security.cookie.secure: false  
  
# Verschlüsseln Sie den Datenverkehr zwischen dem Browser und 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"  
  
# Verschlüsseln Sie den Datenverkehr zwischen OpenSearch-Dashboards und Opensearch  
opensearch.ssl.certificateAuthorities: ["/usr/share/opensearch-dashboards/config/certificates/ca/ca.pem"]  
opensearch.ssl.verificationMode: full

Speichern Sie die Datei und beenden Sie den Editor, wenn Sie fertig sind.

Führen Sie zuletzt den folgenden apt-Befehl aus, um das Paket tree zu installieren und die Liste der Dateien und Verzeichnisse Ihrer OpenSearch-Bereitstellung zu überprüfen.

sudo apt install tree  
tree .

Sie sollten eine Ausgabe wie diese erhalten.

Damit sind alle Vorbereitungen für die Bereitstellung von OpenSearch über Docker abgeschlossen. Sie sind bereit, OpenSearch über Docker und Docker Compose bereitzustellen.

Bereitstellung des OpenSearch-Clusters und der OpenSearch Dashboards

Bevor Sie beginnen, stellen Sie sicher, dass Sie sich im OpenSearch-Projektverzeichnis ‘opensearch-project ‘ befinden. Führen Sie dann den folgenden Befehl ‘docker compose ‘ aus, um die OpenSearch-Bereitstellung zu erstellen und zu starten.

docker compose up -d

Sie sollten eine Ausgabe wie diese erhalten - Es wurden 3 OpenSearch-Container os01, os02 und os03 erstellt und gestartet. Auch der OpenSearch Dashboards-Container ‘osdashboards ‘ wurde erstellt und gestartet.

Überprüfen Sie die Liste der laufenden Dienste/Container in Ihrem OpenSearch-Projekt über den folgenden Befehl.

docker compose ps

Wenn Sie sehen, dass der ‘STATUS ‘ auf ‘Up ‘ steht, dann läuft der Container/Dienst. Im Abschnitt ‘PORTS ‘ sollten Sie die von den Containern an die Hostmaschine freigegebenen Ports sehen.

Mit dem laufenden OpenSearch-Cluster müssen Sie nun die neue Benutzerkonfiguration anwenden, die Sie über die Datei ‘internal_users.yml ‘ erstellt haben. Um dies zu erreichen, können Sie den folgenden ‘docker ‘ Befehl ausführen. Stellen Sie auch sicher, dass Sie etwa 30-60 Sekunden warten, bevor Sie diesen Befehl ausführen, um sicherzustellen, dass das OpenSearch-Cluster läuft.

Der folgende Befehl führt das Bash-Skript ‘securityadmin.sh ‘ im Container/Dienst ‘os01 ‘ aus und wendet die neuen Benutzer auf Ihrem OpenSearch-Cluster an.

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"

Ausgabe:

Führen Sie als Nächstes den folgenden Befehl aus, um sicherzustellen, dass der Container läuft. Dann können Sie die Liste der offenen Ports auf dem Docker-Host über den folgenden ss-Befehl überprüfen.

docker compose ps  
ss -tulpn

Ausgabe - Ports 9200 und 9600 werden vom OpenSearch-Cluster verwendet und Port 5601 wird von OpenSearch Dashboards verwendet.

Zuletzt können Sie die Authentifizierung beim OpenSearch-Cluster über den Benutzernamen und das Passwort, die Sie in der Datei ‘internal_users.yml ‘ erstellt haben, überprüfen.

Authentifizieren Sie sich als Admin-Benutzer beim OpenSearch-Cluster.

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

Ausgabe - Die Authentifizierung war erfolgreich und Sie sollten Details der OpenSearch-Software sehen, die Sie derzeit auf Ihrem Cluster verwenden.

Authentifizieren Sie sich als Benutzer kibanaserver beim OpenSearch-Cluster.

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

Ausgabe - Die Authentifizierung war erfolgreich und Sie sollten Details der OpenSearch-Software sehen, die Sie derzeit auf Ihrem Cluster verwenden.

Damit haben Sie jetzt das OpenSearch-Cluster und die OpenSearch Dashboards über Docker und Docker Compose bereitgestellt. Im nächsten Schritt werden Sie auf Ihre OpenSearch Dashboards-Bereitstellung zugreifen und die Verbindung zwischen OpenSearch Dashboards und dem OpenSearch-Cluster überprüfen.

Zusätzlich können Sie, wenn Sie einen Fehler in Ihrer OpenSearch-Bereitstellung haben, die Protokolle für jeden Container über den folgenden ‘docker compose ‘ Befehl überprüfen.

Grundlegende Verwendung von ‘docker compose ‘ zum Überprüfen von Protokollen.

docker compose logs  
docker compose logs SERVICE

Überprüfen der Protokolle für bestimmte Container/Dienste über den ‘docker compose ‘ Befehl.

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

Zugriff auf OpenSearch Dashboards

Öffnen Sie Ihren Webbrowser und besuchen Sie Ihre Server-IP-Adresse, gefolgt vom Port der OpenSearch Dashboards ‘5601 ‘ (d.h.: https://192.168.5.100:5601/). Sie sollten die Anmeldeseite der OpenSearch Dashboards erhalten.

Geben Sie den Benutzer ‘kibanaserver’ und das Passwort ein und klicken Sie dann auf ‘Anmelden ‘.

Wenn erfolgreich, sollten Sie die folgende Seite erhalten. Klicken Sie auf ‘Erforschen Sie selbst ‘ und Sie sollten die Startseite der OpenSearch Dashboards sehen.

Damit läuft die OpenSearch Dashboards und die Authentifizierung ist aktiviert. Außerdem läuft die OpenSearch Dashboards über sichere HTTPS-Verbindungen über die SSL/TLS-Zertifikate, die Sie generiert haben.

Überprüfen Sie nun die Verbindung zwischen OpenSearch Dashboards und dem OpenSearch-Cluster über die OpenSearch-API.

Klicken Sie im linken Menü auf den Abschnitt Verwaltung und klicken Sie auf ‘Entwicklertools ‘.

Geben Sie jetzt die Abfrage ‘GET / ‘ in die Konsole ein und klicken Sie auf die Schaltfläche Abspielen. Wenn erfolgreich, sollten Sie die Ausgabe auf der rechten Seite mit detaillierten Informationen über Ihren OpenSearch-Server sehen. Außerdem können Sie oben rechts den HTTP-Code ‘200 - OK ‘ sehen, der bestätigt, dass die Abfrage ohne Fehler ausgeführt wurde.

Geben Sie eine weitere Abfrage ‘GET _cat/nodes?format=json&filter_path=ip,name ‘ ein, um die OpenSearch-Knoten zu überprüfen, die im OpenSearch-Cluster verfügbar sind. Sie sollten drei verschiedene Knoten im OpenSearch-Cluster sehen, os01 mit der IP-Adresse 172.23.0.5, os02 mit der IP-Adresse ‘172.23.0.3 ‘, und os3 mit der IP-Adresse ‘172.23.0.2 ‘.

Dies bestätigt, dass die OpenSearch Dashboards mit dem OpenSearch-Cluster verbunden sind.

Fazit

In diesem Tutorial haben Sie OpenSearch über Docker und Docker Compose auf einem Ubuntu 22.04-Server installiert. Sie haben ein OpenSearch-Cluster mit 3 verschiedenen Containern auf Docker erstellt. Sie haben OpenSearch auch mit TLS-Zertifikaten gesichert, die Authentifizierung und Autorisierung aktiviert und Benutzer in OpenSearch konfiguriert. Darüber hinaus haben Sie auch einen Ubuntu-Linux-Server für die Bereitstellung von OpenSearch konfiguriert und optimiert.

Sie haben auch die OpenSearch Dashboards über Docker und Docker Compose installiert. Dann haben Sie auch den OpenSearch Dashboards-Container mit dem OpenSearch-Cluster verbunden.

Mit diesem Setup können Sie jetzt mehr über OpenSearch erkunden, einige Integrationen zu Ihrem OpenSearch hinzufügen, zusätzliche Authentifizierungen einrichten und vieles mehr. Sie erfahren mehr über all dies über die offizielle Dokumentation von OpenSearch.