So installierst du 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 quelloffene Suchmaschine und Analyse-Suite mit umfangreichen Features und innovativen Funktionen. Die Hauptkomponenten des OpenSearch-Projekts sind OpenSearch (eine Abspaltung von Elasticsearch) und die OpenSearch Dashboards (eine Abspaltung von Kibana). Beide Komponenten bieten Funktionen wie Unternehmenssicherheit, Alarmierung, maschinelles Lernen, SQL, Indexstatusverwaltung und mehr.

OpenSearch ist zu 100 % quelloffen und unter der Apache 2.0-Lizenz lizenziert. Mit OpenSearch kannst du auf einfache Weise Daten einlesen, sichern, durchsuchen, aggregieren, anzeigen und analysieren, z. B. für Log-Analysen, Anwendungssuche, Unternehmenssuche und vieles mehr.

In diesem Lernprogramm wirst du OpenSearch – eine Open-Source-Suchmaschine und -Analyse-Suite – und OpenSearch Dashboards – ein Open-Source-Visualisierungstool – über Docker auf einem Ubuntu 22.04-Server installieren und einrichten. Du wirst einen OpenSearch-Cluster mit mehreren Containern und einem einzigen OpenSearch-Dashboard über Docker und Docker Compose einrichten. Außerdem sicherst du deinen Einsatz mit benutzerdefinierten TLS-Zertifikaten und aktivierter Authentifizierung und Autorisierung.

In dieser Anleitung wird ein neuer generischer Ubuntu-Server verwendet. Daher beinhaltet diese Anleitung die Installation der Docker-Engine und von Docker Compose auf einem Ubuntu 22.04-System.

Voraussetzungen

Um diesen Leitfaden zu erstellen, musst du die folgenden Voraussetzungen erfüllen

• Einen Ubuntu 22.04-Server mit mindestens 4-8 GB RAM – In diesem Beispiel wird ein Ubuntu-Server mit dem Hostnamen “ und einer IP-Adresse “ verwendet.
• Ein Nicht-Root-Benutzer mit sudo/root-Administrator-Rechten.

Wenn diese Voraussetzungen erfüllt sind, kannst du die Installation von OpenSearch starten.

System einrichten

In diesem ersten Schritt bereitest du dein Ubuntu-System für den Einsatz von OpenSearch vor. Du musst SWAP und Paging deaktivieren und dann die maximale Speichergröße in der Datei „/etc/sysctl.conf“ erhöhen.

Führe den folgenden Befehl aus, um den Swap auf deinem System zu deaktivieren. Der Befehl „sed“ deaktiviert den Swap dauerhaft in der Datei „/etc/fstab„, indem er den Kommentar„#“ an den Anfang der Zeile mit der Swap-Konfiguration setzt. Mit dem Befehl„swapoff“ wird der Swap in der aktuellen Sitzung deaktiviert.

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

Als Nächstes überprüfst du den Swap-Status mit dem unten stehenden Befehl. Wenn er deaktiviert ist, solltest du eine„0“ im Swap-Bereich erhalten.

free -m

Ausgabe:

Zum Schluss fügst du der Datei„/etc/sysctl.conf“ eine Konfiguration hinzu, um die maximale Speichergröße auf deinem Ubuntu-System zu erhöhen.

Führe den folgenden Befehl aus, um den Parameter„vm.max_map_count=262144“ am Ende der Zeile in der Datei„/etc/sysctl.conf“ hinzuzufügen. Anschließend wendest du die Änderungen mit dem Befehl„sysctl -p“ an.

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

Überprüfe nun die max memory maps, indem du den folgenden Befehl ausführst. Wenn der Befehl erfolgreich war, sollte die maximale Speicherkapazität„262144“ betragen.

cat /proc/sys/vm/max_map_count

Ausgabe:

Nachdem der Swap deaktiviert und die maximale Speicherkapazität auf 262144 erhöht wurde, kannst du mit der Installation der Docker-Engine und von Docker Compose beginnen.

Installation von Docker CE und Docker Compose

Es gibt mehrere Möglichkeiten, OpenSearch einzusetzen und zu installieren. Du kannst OpenSearch auf herkömmliche Weise auf einer virtuellen Maschine oder in einer Container-Umgebung installieren.

Wenn du die traditionelle Installation auf einer virtuellen Maschine bevorzugst, kannst du OpenSearch manuell per Tarball oder über den Paketmanager (für RHEL-basierte Distributionen) installieren. Für den Einsatz in Containern kannst du OpenSearch mit Docker und Kubernetes installieren.

In diesem Beispiel installierst du OpenSearch in der Container-Umgebung über die Docker-Engine und Docker Compose. Jetzt installierst du also Docker-Pakete aus dem offiziellen Docker-Repository.

Um zu beginnen, führe den folgenden apt-Befehl aus, um die grundlegenden Abhängigkeiten zu installieren. Gib y ein, wenn du dazu aufgefordert wirst, und drücke ENTER, um fortzufahren.

sudo apt install ca-certificates curl gnupg lsb-release

Ausgabe:

Als Nächstes führst du den folgenden Befehl aus, um den GPG-Schlüssel und das Repository für die 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 aktualisierst du deinen Ubuntu-Paketindex mit dem unten stehenden apt-Befehl.

sudo apt update

Ausgabe:

Nachdem du das Docker-Repository hinzugefügt hast, kannst du die Docker-Engine und das Docker Compose Plugin mit dem unten stehenden apt-Befehl installieren. Wenn du dazu aufgefordert wirst, gib y ein und drücke 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. Du kannst den Docker-Dienst mit dem folgenden systemctl-Befehl überprüfen.

sudo systemctl is-enabled docker
sudo systemctl status docker

Du solltest eine Ausgabe erhalten, dass der Docker-Dienst aktiviert ist und beim Booten automatisch ausgeführt wird. Und der Status des Docker-Dienstes lautet „running“.

Damit dein Nicht-Root-Benutzer den Docker-Container ausführen kann, musst du deinen Benutzer zur Gruppe„Docker“ hinzufügen. Führe den folgenden usermod-Befehl aus, um deinen Benutzer zur Gruppe„docker“ hinzuzufügen. Achte auch darauf, dass du den Benutzernamen mit deinem Benutzer änderst.

sudo usermod -aG docker alice

Du kannst dich jetzt als dein Benutzer anmelden und den Docker-Container mit dem unten stehenden Befehl starten.

su - alice
docker run hello-world

Wenn du erfolgreich bist, solltest du vom Docker-Container die Meldung „Hallo Welt“ erhalten, wie im folgenden Screenshot zu sehen.

Herunterladen von OpenSearch Docker Images

In diesem Schritt lädst du die Images von OpenSearch und OpenSearch Dashboards von DockerHub herunter. Anschließend startest du einen neuen OpenSearch-Container zu Testzwecken.

Führe 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 der Download abgeschlossen ist, führe den folgenden Befehl aus, um die Liste der Docker-Images auf deinem System zu überprüfen. Du siehst, dass die OpenSearch- und OpenSearch Dashboards-Images auf deinem System verfügbar sind.

docker images

Ausgabe:

Als Nächstes kannst du OpenSearch auch direkt über Docker ausführen, indem du den unten stehenden Befehl verwendest. Dadurch wird der OpenSearch-Container im Einzelmodus erstellt und ausgeführt und der Standard-TCP-Port 9200 und 9600 auf dem Host-Rechner freigegeben.

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

Überprüfe die Liste des laufenden Containers mit dem unten stehenden Befehl„docker ps„.

docker ps

Du solltest eine Ausgabe wie diese erhalten – Der OpenSearch-Container wurde erstellt und wird ausgeführt. Die TCP-Ports 9200 und 9600 sind sowohl auf dem Container als auch auf dem Docker-Host freigegeben.

Du kannst auf deinen OpenSearch-Container über den unten stehenden curl-Befehl zugreifen. Der Standard-Benutzername und das Passwort für den OpenSearch-Container sind„admin„.

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

Wenn du erfolgreich warst, solltest du eine Ausgabe wie diese erhalten – Der OpenSearch-Container läuft und ist über den Docker-Host erreichbar.

Du kannst nun den unten stehenden „Docker“-Befehl ausführen, um den OpenSearch-Container zu stoppen und zu löschen. Denn im nächsten Schritt wirst du einen OpenSearch-Cluster über Docker Compose erstellen. Achte darauf, dass du den Containernamen im folgenden Befehl änderst.

docker stop container-name or container-id
docker rm container-name or container-id

Um sicherzustellen, dass der OpenSearch-Container entfernt wird, führe den Befehl „docker ps“ mit der zusätzlichen Option„-a“ aus. Dies zeigt dir die verfügbaren Container mit den beiden Status „running“ und „exited“ an.

docker ps -a

Ausgabe:

Projektverzeichnis einrichten

Melde dich mit dem folgenden Befehl bei deinem Benutzer an. In diesem Beispiel wird der Benutzer „alice“ verwendet, also ändere den Benutzernamen im folgenden Befehl.

su - alice

Erstelle nun ein neues Projektverzeichnis„opensearch-project„, das als Hauptstammverzeichnis deines Projekts verwendet wird, und das Verzeichnis„certs„, in dem die benutzerdefinierten TLS-Zertifikate gespeichert werden.

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

Führe im Verzeichnis„opensearch-project“ den folgenden Befehl aus, um neue Dateien zu erstellen, die für die Erstellung der OpenSearch-Container und des OpenSearch-Dashboards verwendet werden.

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 Benutzerauthentifizierung und -autorisierung für OpenSearch und OpenSearch Dashboards.

SSL/TLS-Zertifikate generieren

In diesem Schritt erstellst du mehrere TLS-Zertifikate, die zur Sicherung deiner OpenSearch-Installation verwendet werden. Du wirst die folgenden Zertifikate generieren:

• Root-CA-Zertifikate: Diese Zertifikate werden zum Signieren anderer Zertifikate verwendet.
• Admin-Zertifikate: Mit diesen Zertifikaten erhältst du administrative Rechte, um alle Aufgaben im Zusammenhang mit dem Sicherheitsplugin durchzuführen.
• OpenSearch Dashboards-Zertifikate: Diese Zertifikate werden zur Sicherung der OpenSearch Dashboards verwendet und ermöglichen den Zugriff auf OpenSearch Dashboards über HTTPS-Verbindungen.
• Node- und Client-Zertifikate: Diese Zertifikate werden von den Knoten und Clients innerhalb des OpenSearch-Clusters verwendet.

Um zu beginnen, führe den folgenden Befehl aus, um neue Verzeichnisse zu erstellen, die für die String-TLS-Zertifikate verwendet werden sollen.

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

Erstelle eine neue Umgebungsvariable „MYDN“, die für die Erstellung neuer TLS-Zertifikate verwendet wird. Achte darauf, dass du die Details mit deinen Informationen änderst.

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

Jetzt kannst du TLS-Zertifikate für deinen OpenSearch-Einsatz erstellen.

CA-Zertifikate generieren

Erstelle einen privaten Schlüssel für die Root-CA-Zertifikate wie unten beschrieben.

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

Erstelle nun ein selbstsigniertes Root-CA-Zertifikat mit dem unten stehenden Befehl. Der Wert des Parameters „-subj„ verwendet die Umgebungsvariable„MYDN„, die du in deiner aktuellen Sitzung erstellt hast.

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

Damit solltest du den privaten Schlüssel der Stamm-CA„ca.key“ und das Zertifikat der Stamm-CA„ca.pem“ erhalten. Du kannst die CA-Zertifikate, die du erzeugt hast, mit dem folgenden Befehl überprüfen.

ls certs/ca/

Ausgabe – Du solltest den privaten CA-Schlüssel„ca.key“ und das CA-Zertifikat„ca.pem“ erhalten.

Admin-Zertifikate generieren

Erstelle den neuen privaten Schlüssel des Admin-Zertifikats„admin-temp.key“ und konvertiere das erzeugte Zertifikat in einen PKCS#12-kompatiblen Algorithmus (3DES). Damit sollte dein privater Admin-Schlüssel„admin.key“ lauten.

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

Als Nächstes führst du den folgenden Befehl aus, um aus dem privaten Schlüssel„admin.key“ die CSR (Certificate Signing Request) für den Administrator zu erstellen. Die erzeugte CSR sollte nun die Datei„admin.csr“ sein.

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

Führe 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üfe abschließend die Liste deiner Zertifikate mit dem folgenden Befehl.

ls certs/ca/

Ausgabe – Du solltest die Admin-Zertifikatsdateien„admin.pem“ und den privaten Schlüssel„admin.key“ sehen.

OpenSearch Dashboards-Zertifikate generieren

Erstelle das neue Zertifikat, das für die OpenSearch Dashboards verwendet werden soll.

Führe den folgenden Befehl aus, um den privaten Schlüssel „os-dashboards-temp.key“ zu erzeugen und konvertiere das erzeugte Zertifikat in einen PKCS#12-kompatiblen Algorithmus (3DES). Damit sollte dein privater Admin-Schlüssel„os-dashboards.key“ lauten.

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

Als Nächstes führst du den unten stehenden Befehl aus, um die CSR (Certificate Signing Request) für die OpenSearch Dashboards zu erzeugen. Die erzeugte CSR sollte nun 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ühre 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ühre abschließend den folgenden Befehl aus, um die OpenSearch Dashboards CSR-Datei zu löschen und die Liste deiner 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 – Du solltest die OpenSearch Dashboards-Zertifikatsdateien„os-dashboards.pem“ und den privaten Schlüssel„os-dashboards.key“ sehen.

Zertifikate für OpenSearch-Knoten generieren

Führe den folgenden Befehl aus, um Knotenzertifikate zu erzeugen. Damit erstellst du mehrere Verzeichnisse unter dem Verzeichnis „certs“ und generierst 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üfe die Liste der Verzeichnisse im „certs“-Verzeichnis.

ls certs/

Ausgabe – Du solltest neue Verzeichnisse„os01, os02 und os03“ erhalten.

Überprüfe die Liste der Zertifikate in den Verzeichnissen “ os01″, „os02“ und „os03“ mit dem folgenden Befehl.

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

Ausgabe – In jedem Verzeichnis solltest du zwei Zertifikate„osX.key“ und„osX.pem“ erhalten.

Zum Schluss musst du mit dem folgenden Befehl den Eigentümer des Verzeichnisses„certs“ auf„1000“ ändern. Dadurch können Docker-Container auf das Verzeichnis„certs“ zugreifen.

sudo chown -R 1000:1000 certs/

Nachdem du die TLS-Zertifikate erstellt hast, kannst du als Nächstes Hash-Passwörter generieren und OpenSearch-Benutzer einrichten.

Benutzer einrichten

In diesem Schritt erzeugst du einen Passwort-Hash, der von OpenSearch und OpenSearch Dashboards verwendet wird. Du erstellst zwei Passwort-Hashes für zwei verschiedene Benutzer und änderst dann die Konfigurationsdatei „internal_users.yml“ und die OpenSearch-Benutzer.

Führe den folgenden Docker-Befehl aus, um einen neuen Passwort-Hash zu erzeugen. Dadurch wird ein temporärer OpenSearch-Container gestartet und das Skript„hash.sh“ zur Erzeugung eines Passwort-Hashes ausgeführt.

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

Gib nun dein Passwort ein und du solltest das gehashte Passwort auf deinem Terminal erhalten. Kopiere das generierte Hash-Passwort und führe den Befehl erneut aus, um ein weiteres Hash-Passwort zu generieren.

Ausgabe – Das generierte Hash-Passwort für OpenSearch-Nutzer.

Als nächstes öffnest du die Datei„internal_users.yml“ mit dem folgenden nano-Editor-Befehl.

nano internal_users.yml

Füge die folgenden Zeilen in die Datei ein und achte darauf, dass du das Hash-Passwort durch dein generiertes Passwort ersetzt. Damit definierst du zwei Benutzer für deinen OpenSearch-Einsatz: den Benutzer„admin“ als Administrator für OpenSearch und den Benutzer„kibanaserver„, der für die Verbindung zu OpenSearch Dashboards verwendet wird.

---
# This is the internal user database
# The hash value is a bcrypt hash and can be generated with plugin/tools/hash.sh
_meta:
type: "internalusers"
config_version: 2

# Define your internal users here

admin:
hash: "$2y$12$y8UzXWoZKQc8GTgGsRz4g.CarjlC6sMPYN8XOD/NPQysRi2oq.Ws6"
reserved: true
backend_roles:
- "admin"
description: "Admin User"

kibanaserver:
hash: "$2y$12$AKpGe4tM5nIWYFoM56yRue22pQh0jFfx59MUgUKnBu8qnyGeAm2Ze"
reserved: true
description: "OpenSearch Dashboards user"

Speichere die Datei und beende den Editor, wenn du fertig bist.

Skript docker-compose.yml einrichten

In diesem Schritt erstellst du ein neues Docker-Compose-Skript für die Bereitstellung von OpenSearch und OpenSearch Dashboards. Du wirst mehrere OpenSearch-Container erstellen, um den OpenSearch-Cluster einzurichten, und du wirst einen OpenSearch-Dashboards-Container einrichten, der mit dem OpenSearch-Cluster verbunden wird.

Öffne die Datei„docker-compose.yml“ mit dem folgenden nano-Editor-Befehl.

nano docker-compose.yml

Füge die folgenden Zeilen in die Datei ein.

version: '3.7'
services:

os01:
restart: always
image: opensearchproject/opensearch:latest
environment:
OPENSEARCH_JAVA_OPTS: "-Xms1024m -Xmx1024m" # minimum and maximum Java heap size, recommend setting both to 50% of system RAM
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 # relative path
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" # along with the memlock settings below, disables 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 # required for Performance Analyzer

os02:
restart: always
image: opensearchproject/opensearch:latest
environment:
OPENSEARCH_JAVA_OPTS: "-Xms1024m -Xmx1024m" # minimum and maximum Java heap size, recommend setting both to 50% of system RAM
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 # relative path
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" # along with the memlock settings below, disables 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" # minimum and maximum Java heap size, recommend setting both to 50% of system RAM
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 # relative path
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" # along with the memlock settings below, disables 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"]' # must be a string with no spaces when specified as an environment variable
DISABLE_INSTALL_DEMO_CONFIG: "true"

volumes:
os-data1:
os-data2:
os-data3:

Speichere und beende die Datei„docker-compose.yml„, wenn du fertig bist.

Damit erstellst du 4 Container/Dienste für die OpenSearch-Bereitstellung. Im Folgenden findest du detaillierte Informationen zu jedem Container.

• 3 OpenSearch-Container os01, os02 und os03 – Sie werden für die Erstellung des OpenSearch-Clusters verwendet. Diese Container basieren auf dem Image„opensearchproject/opensearch:latest“ und den gleichen Konfigurationen„opensearch.yml“ und„internal_users.yml“.
• Der OpenSearch Dashboards Container „osdashboards“ basiert auf dem Image„opensearchproject/opensearch-dashboards:latest“ und ist mit den drei OpenSearch Hosts os01, os02 und os03 verbunden. Außerdem deaktivierst du die Demo-Konfiguration im OpenSearch Dashboards-Container.
• Alle Container OpenSearch und OpenSearch Dashboards werden über benutzerdefinierte TLS-Zertifikate gesichert, die im Verzeichnis„certs“ verfügbar sind.
• Der OpenSearch-Container wird die beiden Ports 9200 und 9600 und der OpenSearch Dashboards-Container den Port 5601 freigeben.

OpenSearch und OpenSearch Dashboards einrichten

In diesem Schritt erstellst du eine neue Konfiguration für OpenSearch „opensearch.yml“ und OpenSearch Dashboards „opensearch_dashbaords.yml“. Zum Schluss musst du sicherstellen, dass alle notwendigen Konfigurationen und Zertifikate im OpenSearch-Projektverzeichnis vorhanden sind.

Öffne die OpenSearch-Konfigurationsdatei„opensearch.yml“ mit dem folgenden nano-Editor-Befehl.

sudo nano opensearch.yml

Füge die folgenden Zeilen in die Datei ein. Achte darauf, dass du den Pfad der CA-Zertifikate und den DN für die Admin- und Node-Zertifikate änderst. Damit richtest du einen OpenSearch-Cluster mit dem Namen„os-cluster“ ein.

cluster.name: os-cluster
network.host: 0.0.0.0
bootstrap.memory_lock: "true" # along with the memlock settings below, disables 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

Speichere die Datei „opensearch.yml“ und beende den Editor, wenn du fertig bist.

Als Nächstes öffnest du die OpenSearch Dashboards-Konfigurationsdatei„opensearch_dashboards.yml“ mit dem unten stehenden nano-Editor-Befehl.

nano opensearch_dashboards.yml

Füge die folgenden Zeilen in die Datei ein. Achte darauf, dass du den Benutzernamen und das Passwort des OpenSearch Dashboards mit den Angaben des Benutzers„kibanaserver“ in der Datei „internal_users.yml“ änderst.

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]
# Use this setting if you are running opensearch-dashboards without https
opensearch_security.cookie.secure: false

# Encrypt traffic between the browser and 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"

# Encrypt traffic between OpenSearch-Dashboards and Opensearch
opensearch.ssl.certificateAuthorities: ["/usr/share/opensearch-dashboards/config/certificates/ca/ca.pem"]
opensearch.ssl.verificationMode: full

Speichere und beende die Datei, wenn du fertig bist.

Zum Schluss führst du den folgenden apt-Befehl aus, um das Tree-Paket zu installieren und die Liste der Dateien und Verzeichnisse deiner OpenSearch-Installation zu überprüfen.

sudo apt install tree
tree .

Du solltest eine Ausgabe wie diese erhalten.

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

Bereitstellung von OpenSearch Cluster und OpenSearch Dashboards

Bevor du beginnst, stelle sicher, dass du dich im OpenSearch-Projektverzeichnis„opensearch-project“ befindest. Führe dann den folgenden Befehl„docker compose“ aus, um die OpenSearch-Bereitstellung zu erstellen und zu starten.

docker compose up -d

Du solltest eine Ausgabe wie diese erhalten – Es wurden 3 OpenSearch Container os01, os02 und os03 erstellt und gestartet. Außerdem wurde der OpenSearch Dashboards Container„osdashboards“ erstellt und gestartet.

Überprüfe die Liste der laufenden Dienste/Container in deinem OpenSearch-Projekt mit dem folgenden Befehl.

docker compose ps

Wenn du siehst, dass der‚STATUS‚‚Up‚ ist, dann läuft der Container/Dienst. Im Abschnitt„PORTS“ solltest du sehen, welche Ports der Container für den Host-Rechner freigibt.

Wenn der OpenSearch-Cluster läuft, musst du nun die neue Benutzerkonfiguration anwenden, die du in der Datei„internal_users.yml“ erstellt hast. Dazu kannst du den folgenden„Docker„-Befehl ausführen. Achte darauf, dass du 30-60 Sekunden wartest, bevor du diesen Befehl ausführst, um sicherzustellen, dass der OpenSearch-Cluster läuft.

Der folgende Befehl führt das Bash-Skript„securityadmin.sh“ auf dem Container/Dienst„os01“ aus und wendet neue Benutzer auf deinem 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:

Als Nächstes führst du das folgende Kommando aus, um sicherzustellen, dass der Container läuft. Dann kannst du die Liste der offenen Ports auf dem Docker-Host mit dem folgenden ss-Befehl überprüfen.

docker compose ps
ss -tulpn

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

Abschließend kannst du überprüfen, ob du dich mit dem Benutzernamen und dem Passwort, die du in der Datei „internal_users.yml“ erstellt hast, am OpenSearch-Cluster authentifizieren kannst.

Authentifiziere dich als Admin-Benutzer beim OpenSearch-Cluster.

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

Ausgabe – Die Authentifizierung ist erfolgreich und du solltest die Details der OpenSearch-Software sehen, die du derzeit auf deinem Cluster verwendest.

Authentifiziere dich als kibanaserver-Benutzer beim OpenSearch-Cluster.

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

Ausgabe – Die Authentifizierung ist erfolgreich und du solltest die Details der OpenSearch-Software sehen, die du derzeit auf deinem Cluster verwendest.

Damit hast du jetzt den OpenSearch-Cluster und die OpenSearch-Dashboards über Docker und Docker Compose bereitgestellt. Im nächsten Schritt greifst du auf deine OpenSearch Dashboards-Bereitstellung zu und überprüfst die Verbindung zwischen OpenSearch Dashboards und OpenSearch-Cluster.

Außerdem kannst du im Falle eines Fehlers in deinem OpenSearch-Einsatz die Protokolle für jeden Container mit dem unten stehenden Befehl„docker compose“ überprüfen.

Grundlegende Verwendung von„docker compose“ zur Überprüfung von Logs.

docker compose logs
docker compose logs SERVICE

Prüfen von Protokollen für bestimmte Container/Dienste mit dem Befehl„docker compose„.

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

Zugriff auf OpenSearch Dashboards

Öffne deinen Webbrowser und rufe die IP-Adresse deines Servers auf, gefolgt von dem OpenSearch Dashboards Port„5601“ (d.h. : https://192.168.5.100:5601/). Du solltest die Anmeldeseite von OpenSearch Dashboards erhalten.

Gib den Benutzer „kibanaserver“ und das Passwort ein und klicke dann auf„Anmelden„.

Nach erfolgreicher Anmeldung solltest du die folgende Seite sehen. Klicke auf„Eigenständig erkunden“ und du solltest die OpenSearch Dashboard-Startseite sehen.

Damit hast du das OpenSearch Dashboard gestartet und die Authentifizierung ist aktiviert. Außerdem laufen die OpenSearch Dashboards über sichere HTTPS-Verbindungen mit SSL/TLS-Zertifikaten, die du erstellt hast.

Als Nächstes überprüfst du die Verbindung zwischen OpenSearch Dashboards und dem OpenSearch-Cluster über die OpenSearch-API.

Klicke im linken Menü auf den Bereich Verwaltung und klicke auf„Dev Tools„.

Gib nun die Abfrage„GET /“ in die Konsole ein und klicke auf die Schaltfläche „Play“. Wenn die Abfrage erfolgreich war, solltest du die Ausgabe auf der rechten Seite mit detaillierten Informationen über deinen OpenSearch-Server sehen. Außerdem kannst du oben rechts den HTTP-Code„200 – OK“ sehen, der bestätigt, dass die Abfrage ohne Fehler ausgeführt wurde.

Gib eine weitere Abfrage ein: „GET _cat/nodes?format=json&filter_path=ip,name„, um die OpenSearch-Knoten zu überprüfen, die auf dem OpenSearch-Cluster verfügbar sind. Du solltest drei verschiedene Knoten auf dem 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 hast du OpenSearch über Docker und Docker Compose auf einem Ubuntu 22.04 Server installiert. Du hast einen OpenSearch-Cluster mit 3 verschiedenen Containern auf Docker erstellt. Außerdem hast du OpenSearch mit TLS-Zertifikaten gesichert, Authentifizierung und Autorisierung aktiviert und Benutzer in OpenSearch konfiguriert. Außerdem hast du einen Ubuntu Linux Server für den Einsatz von OpenSearch konfiguriert und optimiert.

Du hast auch die OpenSearch Dashboards über Docker und Docker Compose installiert. Dann hast du den OpenSearch Dashboards Container mit dem OpenSearch Cluster verbunden.

Mit dieser Einrichtung kannst du nun mehr über OpenSearch erfahren, deine OpenSearch integrieren, eine zusätzliche Authentifizierung einrichten und vieles mehr. Mehr über OpenSearch erfährst du in der offiziellen Dokumentation von OpenSearch.