So installierst du OpenSearch unter Debian 12

OpenSearch ist ein von Amazon entwickelter Open-Source-Fork von Elasticsearch und Kibana. Es ist eine verteilte und skalierbare Echtzeit-Suchmaschine, die sowohl eine Volltextsuche als auch Analysen ermöglicht. Sie wird für die Indizierung und Suche in großen Datenmengen verwendet. Sie wird in der Regel zusammen mit OpenSearch Dashboards (einer Abspaltung von Kibana) eingesetzt, einem leistungsstarken Dashboard zur Datenvisualisierung für OpenSearch. Mit OpenSearch Dashboards kannst du die OpenSearch-Logdaten untersuchen und Dashboards und Abfragen erstellen, um Einblicke in deine Anwendung zu erhalten.

Dieses Tutorial zeigt dir, wie du OpenSearch auf einem Debian 12 Server installierst. Außerdem erfährst du, wie du deine Installation mit benutzerdefinierten TLS-Zertifikaten absicherst und die Authentifizierung bei OpenSearch aktivierst.

Voraussetzungen

• Ein Server mit Debian 12 und mindestens 4 GB RAM.
• Ein Nicht-Root-Benutzer mit sudo-Rechten.
• Die Unkomplizierte Firewall (UFW) ist aktiviert und läuft.
• Ein Fully Qualified Domain Name (FQDN) wie opensearch.example.com, der auf deinen Server zeigt. Dies ist von Vorteil, wenn du OpenSearch Dashboards über SSL mit einem Proxyserver bereitstellen willst.
• Alles ist auf dem neuesten Stand.

  $ sudo apt update && sudo apt upgrade
  

• Ein paar wichtige Pakete werden benötigt, damit das Tutorial und das Craft CMS laufen. Einige davon werden sich bereits auf deinem Server befinden.

  $ sudo apt install curl wget nano software-properties-common dirmngr apt-transport-https ca-certificates lsb-release debian-archive-keyring gnupg2 ufw unzip -y
  

Schritt 1 – Firewall konfigurieren

Der erste Schritt vor der Installation der Pakete ist die Konfiguration der Firewall, um HTTP- und HTTPS-Verbindungen zuzulassen.

Überprüfe den Status der Firewall.

$ sudo ufw status

Du solltest etwas wie das Folgende sehen.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Erlaube HTTP- und HTTPs-Ports.

$ sudo ufw allow http
$ sudo ufw allow https

Überprüfe den Status zur Bestätigung noch einmal.

$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443/tcp                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443/tcp (v6)               ALLOW       Anywhere (v6)

Schritt 2 – System vorbereiten

Bevor wir OpenSearch installieren, müssen wir unser System vorbereiten und optimieren. Dazu gehören das Deaktivieren von Swap-Speicher, falls vorhanden, das Einstellen der Anzahl der Memory Maps für dein System und das Einrichten des System-Hostnamens.

Prüfe zunächst, ob du Swap-Speicher aktiviert hast.

$ free -m

Wenn du Swap aktiviert hast, solltest du eine ähnliche Ausgabe sehen.

               total        used        free      shared  buff/cache   available
Mem:            7945        1083        6492          34         636        6861
Swap:           4242           0        4242

Führe die folgenden Befehle aus, um den Swap-Speicher dauerhaft zu deaktivieren.

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

Überprüfe erneut den Swap-Speicher und es sollte folgendes angezeigt werden.

               total        used        free      shared  buff/cache   available
Mem:            7945        1113        6449          37         651        6831
Swap:              0           0           0

OpenSearch verwendet standardmäßig ein mapfs Verzeichnis, um seine Indizes zu speichern. Die Standardgrenzen des Betriebssystems für die Anzahl der nmap-Indizes sind zu niedrig, was zu Fehlern führen kann, wenn der Speicher voll ist.

Überprüfe den vorhandenen Wert für die Variable vm.max_map_count.

$ sysctl -n vm.max_map_count
65530

Um die Anzahl der von den einzelnen Prozessen verwendeten Memory Maps zu erhöhen, führe den folgenden Befehl aus.

$ sudo sysctl -w vm.max_map_count=262144

Das funktioniert nur, bis das System neu gestartet wird. Um diesen Wert dauerhaft zu machen, füge die Zeile vm.max_map_count=262144 in der Datei /etc/sysctl.conf mit folgendem Befehl ein.

$ echo "vm.max_map_count=262144" | sudo tee -a /etc/sysctl.conf

Du kannst die Änderung dauerhaft machen, indem du entweder das System neu startest oder den folgenden Befehl ausführst.

$ sudo sysctl -p

Der letzte Schritt ist das Einrichten des Hostnamens. Je nachdem, wo du deinen Server hostest, kannst du bei einigen Cloud-Anbietern deinen Hostnamen direkt über das Kontrollpanel festlegen. Es ist jedoch besser, dies über das Terminal zu tun.

Führe den folgenden Befehl aus, um den Hostnamen festzulegen.

$ sudo hostnamectl set-hostname opensearch

Füge den FQDN (Fully qualified domain name) in die Datei /etc/hosts ein. Hier ordnen wir den Hostnamen opensearch dem Domainnamen opensearch.example.com zu und verweisen ihn auf die IP-Adresse des Servers. Ersetze <serverIPaddress> in dem unten stehenden Befehl durch die IP-Adresse deines Servers.

$ echo "<serverIPaddress>  opensearch.example.com  opensearch" | sudo tee -a /etc/hosts

Überprüfe den Hostnamen und den FQDN mit den folgenden Befehlen.

$ hostname
opensearch
$ hostname -f
opensearch.example.com

Damit ist der Prozess der Optimierung unseres Systems für die Arbeit mit OpenSearch abgeschlossen.

Schritt 3 – Installiere OpenSearch

Importiere den OpenSearch GPG-Schlüssel, der zum Signieren des Installationspakets verwendet wird.

$  curl -o- https://artifacts.opensearch.org/publickeys/opensearch.pgp | sudo gpg --dearmor --batch --yes -o /usr/share/keyrings/opensearch-keyring

Erstelle die OpenSearch APT-Repository-Datei.

$ echo "deb [signed-by=/usr/share/keyrings/opensearch-keyring] https://artifacts.opensearch.org/releases/bundle/opensearch/2.x/apt stable main" | sudo tee /etc/apt/sources.list.d/opensearch-2.x.list

Aktualisiere die Repository-Liste des Systems.

$ sudo apt update

Überprüfe alle verfügbaren Versionen von OpenSearch.

$ sudo apt list -a opensearch
Listing... Done
opensearch/stable 2.12.0 amd64
opensearch/stable 2.11.1 amd64
opensearch/stable 2.11.0 amd64
opensearch/stable 2.10.0 amd64
opensearch/stable 2.9.0 amd64
opensearch/stable 2.8.0 amd64
opensearch/stable 2.7.0 amd64
opensearch/stable 2.6.0 amd64
opensearch/stable 2.5.0 amd64

Bei der neuesten Version von OpenSearch v2.12.0 musst du vor der Installation das Admin-Demo-Passwort festlegen, sonst schlägt die Installation fehl.

Du kannst die neueste Version von OpenSearch mit dem folgenden Befehl installieren. Wir können das Admin-Demo-Passwort über die Umgebungsvariable im Installationsbefehl selbst festlegen. Wähle ein sicheres Passwort.

$ sudo env OPENSEARCH_INITIAL_ADMIN_PASSWORD=<custom-admin-password> apt install opensearch

Wenn du während der Installation die folgende Warnung siehst, kannst du sie getrost ignorieren.

......
chown: warning: '.' should be ':': ‘opensearch.opensearch’
chown: warning: '.' should be ':': ‘opensearch.opensearch’
chown: warning: '.' should be ':': ‘opensearch.opensearch’
chown: warning: '.' should be ':': ‘opensearch.opensearch’
chown: warning: '.' should be ':': ‘opensearch.opensearch’
......

Oder du kannst eine bestimmte Version installieren.

$ sudo apt install opensearch=2.11.1

Lade den Service Daemon neu.

$ sudo systemctl daemon-reload

Aktiviere den OpenSearch-Dienst.

$ sudo systemctl enable opensearch

Starte den OpenSearch-Dienst.

$ sudo systemctl start opensearch

Überprüfe den Status des OpenSearch-Dienstes.

$ sudo systemctl status opensearch

Du solltest die folgende Ausgabe erhalten.

? opensearch.service - OpenSearch
     Loaded: loaded (/lib/systemd/system/opensearch.service; enabled; preset: enabled)
     Active: active (running) since Sat 2024-03-02 06:37:01 UTC; 5s ago
       Docs: https://opensearch.org/
   Main PID: 31109 (java)
      Tasks: 75 (limit: 4652)
     Memory: 1.3G
        CPU: 1min 3.128s
     CGroup: /system.slice/opensearch.service
             ??31109 /usr/share/opensearch/jdk/bin/java -Xshare:auto -Dopensearch.networkaddress.cache.ttl=60 -Dopensearch.networkaddress.cache.negative.ttl=10 -XX:+AlwaysPreTouch -Xss1m -Djava.awt.headless=true...

Schritt 4 – Teste OpenSearch

Bevor wir weitermachen, sollten wir überprüfen, ob die Installation einwandfrei funktioniert. Führe den folgenden Befehl aus, um zu überprüfen, ob OpenSearch wie vorgesehen läuft.

$ curl -X GET https://localhost:9200 -u 'admin:<custom-admin-password>' --insecure

Du solltest eine ähnliche Ausgabe erhalten.

{
  "name" : "opensearch",
  "cluster_name" : "opensearch",
  "cluster_uuid" : "3oFvYn96St2MOpDP3Sf29g",
  "version" : {
    "distribution" : "opensearch",
    "number" : "2.12.0",
    "build_type" : "deb",
    "build_hash" : "2c355ce1a427e4a528778d4054436b5c4b756221",
    "build_date" : "2024-02-20T02:18:31.541484890Z",
    "build_snapshot" : false,
    "lucene_version" : "9.9.2",
    "minimum_wire_compatibility_version" : "7.10.0",
    "minimum_index_compatibility_version" : "7.0.0"
  },
  "tagline" : "The OpenSearch Project: https://opensearch.org/"
}

Frag den OpenSearch-Plugins-Endpunkt ab, um die Liste der verfügbaren Plugins zu sehen.

$ curl -X GET https://localhost:9200/_cat/plugins?v -u 'admin:<custom-admin-password>' --insecure

Du kannst dazu auch den folgenden Befehl verwenden.

$ /usr/share/opensearch/bin/opensearch-plugin list

Du solltest eine ähnliche Ausgabe erhalten.

name       component                            version
opensearch opensearch-alerting                  2.12.0.0
opensearch opensearch-anomaly-detection         2.12.0.0
opensearch opensearch-asynchronous-search       2.12.0.0
opensearch opensearch-cross-cluster-replication 2.12.0.0
opensearch opensearch-custom-codecs             2.12.0.0
opensearch opensearch-flow-framework            2.12.0.0
opensearch opensearch-geospatial                2.12.0.0
opensearch opensearch-index-management          2.12.0.0
opensearch opensearch-job-scheduler             2.12.0.0
opensearch opensearch-knn                       2.12.0.0
opensearch opensearch-ml                        2.12.0.0
opensearch opensearch-neural-search             2.12.0.0
opensearch opensearch-notifications             2.12.0.0
opensearch opensearch-notifications-core        2.12.0.0
opensearch opensearch-observability             2.12.0.0
opensearch opensearch-performance-analyzer      2.12.0.0
opensearch opensearch-reports-scheduler         2.12.0.0
opensearch opensearch-security                  2.12.0.0
opensearch opensearch-security-analytics        2.12.0.0
opensearch opensearch-skills                    2.12.0.0
opensearch opensearch-sql                       2.12.0.0

Du kannst zusätzliche Plugins mit dem folgenden Befehl installieren.

$ /usr/share/opensearch/bin/opensearch-plugin install <plugin-name>

Die Liste der verfügbaren OpenSearch-Plugins findest du auf der offiziellen Website des Unternehmens.

Schritt 5 – OpenSearch konfigurieren

Die Standardeinstellungen von OpenSearch sind nicht für eine Produktionsumgebung geeignet. Standardmäßig ist OpenSearch nicht an eine Netzwerkschnittstelle gebunden und von außen nicht zu erreichen. Außerdem werden Standardbenutzernamen und -kennwörter verwendet, die bei direkter Verwendung in einer Produktionsumgebung Sicherheitsprobleme verursachen können.

OpenSearch speichert seine Konfiguration in der Datei /etc/opensearch/opensearch.yml. Öffne sie zum Bearbeiten.

$ sudo nano /etc/opensearch/opensearch.yml

Finde die Zeile #network.host: 192.168.0.1 und hebe die Kommentierung auf, indem du die Raute (#) vor der Zeile entfernst und den Wert wie gezeigt änderst. Dadurch wird OpenSearch an alle verfügbaren Schnittstellen gebunden. Du kannst auch eine bestimmte IP eingeben, um sie an eine bestimmte Schnittstelle zu binden.

# Set the bind address to a specific IP (IPv4 or IPv6):
#
network.host: 0.0.0.0

Füge die folgenden Zeilen am Ende der Datei hinzu.

# Unless you have already configured a cluster, you should set
# discovery.type to single-node, or the bootstrap checks will
# fail when you try to start the service.
discovery.type: single-node

# If you previously disabled the Security plugin in opensearch.yml,
# be sure to re-enable it. Otherwise you can skip this setting.
plugins.security.disabled: false

Da wir auf einem einzelnen Server installieren, haben wir discovery.type auf single-node gesetzt. Wenn du plugins.security.disabled auf false setzt, wird das OpenSearch Sicherheits-Plugin aktiviert.

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Wir müssen auch die anfängliche und maximale JVM (Java Virtual Memory) Heap-Größe angeben. Diese Einstellung hängt von der RAM-Größe deines Servers ab. Da wir zum Beispiel einen Server mit 4 GB RAM verwenden, stellen wir die Heap-Größe auf 3 GB ein.

Erstelle und öffne die Datei heapsize.options im Verzeichnis /etc/opensearch/jvm.options.d zur Bearbeitung. Sie überschreibt den Standardwert, der in der Datei /etc/opensearch/jvm.options festgelegt wurde.

$ sudo nano /etc/opensearch/jvm.options.d/heapsize.options

Füge die folgenden Zeilen hinzu.

-Xms3g
-Xmx3g

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Starte den OpenSearch-Dienst neu, um die Änderungen zu übernehmen.

$ sudo systemctl restart opensearch

Du kannst die aktuelle Heap-Größe und den maximalen Speicher mit dem folgenden Befehl überprüfen.

$ curl -sS "https://localhost:9200/_cat/nodes?h=heap*&v" -u 'admin:<custom-admin-password>' --insecure

Du solltest die folgende Ausgabe erhalten.

heap.current heap.percent heap.max
     345.5mb           11      3gb

Schritt 6 – TLS für OpenSearch konfigurieren

Hier werden wir Zertifikate erzeugen, um OpenSearch zu sichern. TLS-Zertifikate bieten Sicherheit, indem sie es den Clients ermöglichen, die Identität von Hosts zu bestätigen und den Datenverkehr zwischen einem Client und dem Host zu verschlüsseln. Wir werden die folgenden Zertifikate erstellen

1. Root-CA-Zertifikate – Dies sind die primären Zertifikate, die alle anderen Zertifikate signieren werden.
2. Admin-Zertifikate – Diese Zertifikate werden verwendet, um erweiterte Rechte für die Durchführung von Verwaltungsaufgaben im Zusammenhang mit dem Sicherheits-Plugin zu erhalten.
3. Node-Zertifikate – Diese Zertifikate werden für die Kommunikation zwischen einem Node und dem Client verwendet.

Alle OpenSearch-Zertifikate werden im Verzeichnis /etc/opensearch gespeichert. Der erste Schritt besteht darin, die Standardzertifikate zu entfernen, die bei der Installation von OpenSearch festgelegt wurden.

Wechsle in das OpenSearch-Verzeichnis.

$ cd /etc/opensearch

Entferne die Standardzertifikate.

$ sudo rm -f *.pem

Öffne die OpenSearch-Konfigurationsdatei zum Bearbeiten.

$ sudo nano opensearch.yml

Kommentiere den folgenden Code am Ende der Datei aus, indem du vor jede Zeile im Abschnitt OpenSearch Security Demo Configuration eine Raute setzt, wie unten gezeigt.

######## Start OpenSearch Security Demo Configuration ########
# WARNING: revise all the lines below before you go into production
#plugins.security.ssl.transport.pemcert_filepath: esnode.pem
#plugins.security.ssl.transport.pemkey_filepath: esnode-key.pem
#plugins.security.ssl.transport.pemtrustedcas_filepath: root-ca.pem
#plugins.security.ssl.transport.enforce_hostname_verification: false
#plugins.security.ssl.http.enabled: true
#plugins.security.ssl.http.pemcert_filepath: esnode.pem
#plugins.security.ssl.http.pemkey_filepath: esnode-key.pem
#plugins.security.ssl.http.pemtrustedcas_filepath: root-ca.pem
#plugins.security.allow_unsafe_democertificates: true
#plugins.security.allow_default_init_securityindex: true
#plugins.security.authcz.admin_dn: ['CN=kirk,OU=client,O=client,L=test,C=de']
#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]
#plugins.security.system_indices.enabled: true
#plugins.security.system_indices.indices: [.plugins-ml-config, .plugins-ml-connector,
#  .plugins-ml-model-group, .plugins-ml-model, .plugins-ml-task, .plugins-ml-conversation-meta,
#  .plugins-ml-conversation-interactions, .plugins-ml-memory-meta, .plugins-ml-memory-message,
#  .opendistro-alerting-config, .opendistro-alerting-alert*, .opendistro-anomaly-results*,
#  .opendistro-anomaly-detector*, .opendistro-anomaly-checkpoints, .opendistro-anomaly-detection-state,
#  .opendistro-reports-*, .opensearch-notifications-*, .opensearch-notebooks, .opensearch-observability,
#  .ql-datasources, .opendistro-asynchronous-search-response*, .replication-metadata-store,
#  .opensearch-knn-models, .geospatial-ip2geo-data*, .plugins-flow-framework-config,
#  .plugins-flow-framework-templates, .plugins-flow-framework-state]
#node.max_local_storage_nodes: 3
######## End OpenSearch Security Demo Configuration ########

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Als Nächstes erstellst du ein Verzeichnis zum Speichern von Zertifikaten innerhalb des Verzeichnisses /etc/opensearch.

$ sudo mkdir /etc/opensearch/certs

Ändere die Berechtigung des Verzeichnisses auf den aktuell angemeldeten Benutzer, um die Verwendung von sudo beim Erstellen der Zertifikate zu vermeiden.

$ sudo chown $USER:$USER /etc/opensearch/certs -R

Wechsle in das Zertifikatsverzeichnis.

$ cd /etc/opensearch/certs

Root-Zertifikate generieren

Erstelle einen privaten Schlüssel für das Stammzertifikat.

$ openssl genrsa -out root-ca-key.pem 2048

Erstelle ein selbstsigniertes Root-CA-Zertifikat. Wir verwenden den Parameter -subj, um Informationen bereitzustellen, die in das Zertifikat eingebettet sind. Wenn du den Parameter -subj nicht verwendest, wirst du nach all diesen Informationen gefragt.

$ openssl req -new -x509 -sha256 -key root-ca-key.pem -subj "/C=CA/ST=ONTARIO/L=TORONTO/O=ORG/OU=UNIT/CN=ROOT" -out root-ca.pem -days 730

Du kannst die Informationen so ändern, dass sie zu deinem speziellen Host passen.

Die Variablen im Parameter -subj haben folgende Bedeutung.

C = Name des Landes (2-Buchstaben-Code), ST = Name des Bundesstaates oder der Provinz (vollständiger Name), L = Name des Ortes (z. B. Stadt), O = Name der Organisation, OU = Name der Organisationseinheit (z. B. Sektion), CN = Common Name (z. B. Server-FQDN)

Dein Stammzertifikat ist jetzt aktiv.

Admin-Zertifikate generieren

Erstelle den privaten Schlüssel für das Admin-Zertifikat mit dem folgenden Befehl.

$ openssl genrsa -out admin-key-temp.pem 2048

Konvertiere den privaten Schlüssel mit einem PKCS#12-kompatiblen Algorithmus (3DES) in das PKCS#8-Format für die Verwendung in Java.

$ openssl pkcs8 -inform PEM -outform PEM -in admin-key-temp.pem -topk8 -nocrypt -v1 PBE-SHA1-3DES -out admin-key.pem

Erstelle die Admin CSR (Certificate Signing Request) aus dem privaten Schlüssel. Da dieses Zertifikat nicht an einen Host gebunden ist und für die Authentifizierung des erweiterten Zugangs verwendet wird, verwenden wir den Wert A für den Common Name (CN).

$ openssl req -new -key admin-key.pem -subj "/C=CA/ST=ONTARIO/L=TORONTO/O=ORG/OU=UNIT/CN=A" -out admin.csr

Signiere die Admin CSR mit dem Root-Zertifikat und dem privaten Schlüssel, die du gerade erstellt hast.

$ openssl x509 -req -in admin.csr -CA root-ca.pem -CAkey root-ca-key.pem -CAcreateserial -sha256 -out admin.pem -days 730
Certificate request self-signature ok
subject=C = CA, ST = ONTARIO, L = TORONTO, O = ORG, OU = UNIT, CN = A

Node-Zertifikate generieren

Erstelle einen privaten Schlüssel für das Knotenzertifikat.

$ openssl genrsa -out node1-key-temp.pem 2048

Konvertiere den privaten Schlüssel des Knotens in das PKCS#8-Format.

$ openssl pkcs8 -inform PEM -outform PEM -in node1-key-temp.pem -topk8 -nocrypt -v1 PBE-SHA1-3DES -out node1-key.pem

Erstelle eine neue CSR für das Node-Zertifikat mit dem privaten Schlüssel. Achte darauf, dass du den Wert der Variable CN mit dem Hostnamen deines Knotens änderst. Dieses Zertifikat ist an deine Hosts gebunden und sollte mit dem Hostnamen oder der IP-Adresse des Knotens übereinstimmen.

$ openssl req -new -key node1-key.pem -subj "/C=CA/ST=ONTARIO/L=TORONTO/O=ORG/OU=UNIT/CN=opensearch.example.com" -out node1.csr

Erstelle eine SAN-Erweiterungsdatei (Subject Alternative Name), die den Knoten-Hostnamen oder FQDN oder die IP-Adresse enthält.

$ sh -c 'echo subjectAltName=DNS:opensearch.example.com > node1.ext'

Signiere den CSR des Knotenzertifikats mit dem Stammzertifikat und dem privaten Schlüssel, die du gerade erstellt hast.

$ openssl x509 -req -in node1.csr -CA root-ca.pem -CAkey root-ca-key.pem -CAcreateserial -sha256 -out node1.pem -days 730 -extfile node1.ext
Certificate request self-signature ok
subject=C = CA, ST = ONTARIO, L = TORONTO, O = ORG, OU = UNIT, CN = opensearch.example.com

Vorbereiten von Zertifikaten für die Installation

Entferne alle temporären Zertifikate, CSR und die SAN-Erweiterungsdatei.

$ rm -f *temp.pem *csr *ext

Als Nächstes werden wir das Root-CA-Zertifikat auf dem Server installieren. Konvertiere dazu das Root-CA-Zertifikat in das Format .crt.

$ openssl x509 -outform der -in root-ca.pem -out root-ca.crt

Kopiere die Datei root-ca.crt in das Verzeichnis /usr/local/share/ca-certificates/.

$ sudo cp root-ca.crt /usr/local/share/ca-certificates/

Füge das Root-CA-Zertifikat mit folgendem Befehl zu deinem Debian-Server hinzu.

$ sudo update-ca-certificates

Du solltest die folgende Ausgabe sehen ( 1 added), die bestätigt, dass das Root-CA-Zertifikat deinem System hinzugefügt wurde.

Updating certificates in /etc/ssl/certs...
rehash: warning: skipping ca-certificates.crt,it does not contain exactly one certificate or CRL
rehash: warning: skipping root-ca.pem,it does not contain exactly one certificate or CRL
1 added, 0 removed; done.
Running hooks in /etc/ca-certificates/update.d...
done.

Ändere die Eigentümerschaft des Verzeichnisses wieder auf den Benutzer opensearch.

$ sudo chown opensearch:opensearch /etc/opensearch/certs -R

Ändere die Berechtigung für das Verzeichnis auf 0700.

$ sudo chmod 0700 /etc/opensearch/certs

Ändere die Berechtigung für die Zertifikate auf 0600.

$ sudo chmod 0600 /etc/opensearch/certs/{admin-key,admin,node1-key,node1,root-ca-key,root-ca}.pem
$ sudo chmod 0600 /etc/opensearch/certs/root-ca.crt

Schritt 7 – Installiere TLS für OpenSearch

Jetzt, da alle Zertifikate erstellt und eingerichtet sind, ist es an der Zeit, die Zertifikate zu installieren und zu deiner OpenSearch-Installation hinzuzufügen.

Der erste Schritt besteht darin, ein Bash-Skript zu erstellen, das alle erstellten Zertifikate und TLS-Sicherheits-Plugin-Einstellungen zur OpenSearch-Konfigurationsdatei (/etc/opensearch/opensearch.yml) hinzufügt.

Erstelle eine Datei namens add-opensearch-tls.sh und öffne sie zum Bearbeiten.

$ cd ~
$ nano add-opensearch-tls.sh

Füge den folgenden Code in die Datei ein.

#! /bin/bash

# Before running this script, make sure to replace the CN in the 
# node's distinguished name with a real DNS A record.

echo "plugins.security.ssl.transport.pemcert_filepath: /etc/opensearch/certs/node1.pem" | sudo tee -a /etc/opensearch/opensearch.yml
echo "plugins.security.ssl.transport.pemkey_filepath: /etc/opensearch/certs/node1-key.pem" | sudo tee -a /etc/opensearch/opensearch.yml
echo "plugins.security.ssl.transport.pemtrustedcas_filepath: /etc/opensearch/certs/root-ca.pem" | sudo tee -a /etc/opensearch/opensearch.yml
echo "plugins.security.ssl.http.enabled: true" | sudo tee -a /etc/opensearch/opensearch.yml
echo "plugins.security.ssl.http.pemcert_filepath: /etc/opensearch/certs/node1.pem" | sudo tee -a /etc/opensearch/opensearch.yml
echo "plugins.security.ssl.http.pemkey_filepath: /etc/opensearch/certs/node1-key.pem" | sudo tee -a /etc/opensearch/opensearch.yml
echo "plugins.security.ssl.http.pemtrustedcas_filepath: /etc/opensearch/certs/root-ca.pem" | sudo tee -a /etc/opensearch/opensearch.yml
echo "plugins.security.allow_default_init_securityindex: true" | sudo tee -a /etc/opensearch/opensearch.yml
echo "plugins.security.authcz.admin_dn:" | sudo tee -a /etc/opensearch/opensearch.yml
echo "  - 'CN=A,OU=UNIT,O=ORG,L=TORONTO,ST=ONTARIO,C=CA'" | sudo tee -a /etc/opensearch/opensearch.yml
echo "plugins.security.nodes_dn:" | sudo tee -a /etc/opensearch/opensearch.yml
echo "  - 'CN=opensearch.example.com,OU=UNIT,O=ORG,L=TORONTO,ST=ONTARIO,C=CA'" | sudo tee -a /etc/opensearch/opensearch.yml
echo "plugins.security.audit.type: internal_opensearch" | sudo tee -a /etc/opensearch/opensearch.yml
echo "plugins.security.enable_snapshot_restore_privilege: true" | sudo tee -a /etc/opensearch/opensearch.yml
echo "plugins.security.check_snapshot_restore_write_privileges: true" | sudo tee -a /etc/opensearch/opensearch.yml
echo "plugins.security.restapi.roles_enabled: [\"all_access\", \"security_rest_api_access\"]" | sudo tee -a /etc/opensearch/opensearch.yml

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Mache die Datei ausführbar.

$ chmod +x add-opensearch-tls.sh

Führe das Skript aus.

$ ./add-opensearch-tls.sh

Du solltest die folgende Ausgabe erhalten.

plugins.security.ssl.transport.pemcert_filepath: /etc/opensearch/certs/node1.pem
plugins.security.ssl.transport.pemkey_filepath: /etc/opensearch/certs/node1-key.pem
plugins.security.ssl.transport.pemtrustedcas_filepath: /etc/opensearch/certs/root-ca.pem
plugins.security.ssl.http.enabled: true
plugins.security.ssl.http.pemcert_filepath: /etc/opensearch/certs/node1.pem
plugins.security.ssl.http.pemkey_filepath: /etc/opensearch/certs/node1-key.pem
plugins.security.ssl.http.pemtrustedcas_filepath: /etc/opensearch/certs/root-ca.pem
plugins.security.allow_default_init_securityindex: true
plugins.security.authcz.admin_dn:
  - 'CN=A,OU=UNIT,O=ORG,L=TORONTO,ST=ONTARIO,C=CA'
plugins.security.nodes_dn:
  - 'CN=opensearch.example.com,OU=UNIT,O=ORG,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"]

Öffne die Datei /etc/opensearch/opensearch.yml, um zu überprüfen, ob deine Einstellungen übernommen wurden.

$ sudo nano /etc/opensearch/opensearch.yml

Scrolle zum Ende der Datei und du solltest Folgendes sehen.

# If you previously disabled the Security plugin in opensearch.yml,
# be sure to re-enable it. Otherwise you can skip this setting.
plugins.security.disabled: false
....
plugins.security.ssl.transport.pemcert_filepath: /etc/opensearch/certs/node1.pem
plugins.security.ssl.transport.pemkey_filepath: /etc/opensearch/certs/node1-key.pem
plugins.security.ssl.transport.pemtrustedcas_filepath: /etc/opensearch/certs/root-ca.pem
plugins.security.ssl.http.enabled: true
plugins.security.ssl.http.pemcert_filepath: /etc/opensearch/certs/node1.pem
plugins.security.ssl.http.pemkey_filepath: /etc/opensearch/certs/node1-key.pem
plugins.security.ssl.http.pemtrustedcas_filepath: /etc/opensearch/certs/root-ca.pem
plugins.security.allow_default_init_securityindex: true
plugins.security.authcz.admin_dn:
  - 'CN=A,OU=UNIT,O=ORG,L=TORONTO,ST=ONTARIO,C=CA'
plugins.security.nodes_dn:
  - 'CN=opensearch.example.com,OU=UNIT,O=ORG,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"]

Wenn du zufrieden bist, speichere die Datei mit der Tastenkombination Strg + X.

Schritt 8 – OpenSearch-Benutzer anlegen

In diesem Schritt entfernen wir alle Demo-Benutzer mit Ausnahme des admin Benutzers und ersetzen das Standardpasswort admin durch ein Skript.

Wechsle in das Verzeichnis der OpenSearch-Sicherheitsplugins und Tools.

$ cd /usr/share/opensearch/plugins/opensearch-security/tools

Führe das Skript hash.sh aus, um ein neues Passwort zu generieren.

$ ./hash

Das Skript schlägt fehl und du erhältst die folgende Fehlermeldung, weil der Pfad zur ausführbaren Java-Datei (JDK) nicht definiert wurde.

**************************************************************************
** This tool will be deprecated in the next major release of OpenSearch **
** https://github.com/opensearch-project/security/issues/1755           **
**************************************************************************
WARNING: nor OPENSEARCH_JAVA_HOME nor JAVA_HOME is set, will use 
./hash.sh: line 35: java: command not found

Führe den Befehl erneut aus, indem du die Umgebungsvariable OPENSEARCH_JAVA_HOME mit dem Ort des JDK deklarierst.

$ OPENSEARCH_JAVA_HOME=/usr/share/opensearch/jdk ./hash.sh

Du wirst eine ähnliche Ausgabe erhalten.

**************************************************************************
** This tool will be deprecated in the next major release of OpenSearch **
** https://github.com/opensearch-project/security/issues/1755           **
**************************************************************************
[Password:]
$2y$12$4NL0LqEnN4FXaUdQQC.gOupeCQT2IuMo9gN0b5d3nxdMVbLX088f2

Es wird der Passwort-Hash generiert, den wir später brauchen werden.

Öffne die OpenSearch-Benutzerkonfigurationsdatei internal_users.yml im Verzeichnis /etc/opensearch/opensearch-security/ und bearbeite sie.

$ sudo nano /etc/opensearch/opensearch-security/internal_users.yml

Kommentiere alle Demo-Benutzer aus, indem du wie gezeigt einen Hash vorangibst.

---
# 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

## Demo users

#admin:
#  hash: "$2y$12$Twy84uxOX0SQ1QMQ68og8O/i1MvqWItt/phZX3DiJMjpBoT9u9KX6"
#  reserved: true
#  backend_roles:
#  - "admin"
#  description: "Demo admin user"

#anomalyadmin:

Füge den Admin-Benutzer mit dem Hash hinzu, den du oben erzeugt hast.

---
# 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$4NL0LqEnN4FXaUdQQC.gOupeCQT2IuMo9gN0b5d3nxdMVbLX088f2"
  reserved: true
  backend_roles:
  - "admin"
  description: "Admin user"

## Demo users

#admin:

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Jetzt, da die TLS-Zertifikate installiert und die Demo-Benutzer entfernt oder mit neuen Passwörtern versehen sind, ist es an der Zeit, die Konfigurationsänderungen anzuwenden. Um die Änderungen anzuwenden, rufen wir das Skript securityadmin.sh im Verzeichnis /usr/share/opensearch/plugins/opensearch-security/tools auf. Das Skript setzt voraus, dass der OpenSearch-Dienst ausgeführt wird.

Starte den OpenSearch-Dienst neu.

$ sudo systemctl restart opensearch

Wechsle in das Verzeichnis /usr/share/opensearch/plugins/opensearch-security/tools.

$ cd /usr/share/opensearch/plugins/opensearch-security/tools

Führe das Skript mit dem folgenden Kommando aus.

$ sudo OPENSEARCH_JAVA_HOME=/usr/share/opensearch/jdk ./securityadmin.sh -h opensearch.nspeaks.com -p 9200 -cd /etc/opensearch/opensearch-security/ -cacert /etc/opensearch/certs/root-ca.pem -cert /etc/opensearch/certs/admin.pem -key /etc/opensearch/certs/admin-key.pem -icl -nhnv

Das Sicherheits-Plugin speichert seine Konfiguration – einschließlich Benutzer, Berechtigungen, Rollen und Backend-Einstellungen – in einem Systemindex auf dem OpenSearch-Cluster. Wenn du diese Einstellungen im Cluster speicherst, kannst du sie ändern, ohne den Cluster neu zu starten, und musst die Konfigurationsdatei nicht auf jedem Knoten bearbeiten. Dies wird durch die Ausführung des Skripts securityadmin.sh erreicht.

• Die Option -cd gibt an, wo sich die Konfigurationsdateien des Sicherheits-Plugins befinden.
• Mit der Option -icl (--ignore-clustername) wird das Sicherheits-Plugin angewiesen, die Konfiguration unabhängig vom Clusternamen hochzuladen. Du kannst auch den Clusternamen angeben, anstatt die Option -cn (--clustername) zu verwenden.
• Da die Zertifikate selbst signiert sind, verwenden wir die Option -nhnv (--disable-host-name-verification).
• Die Optionen --cacert, --cert und --key legen den Speicherort des Stammzertifikats, des Admin-Zertifikats und des privaten Schlüssels für das Admin-Zertifikat fest. Wenn der private Schlüssel ein Passwort hat, kannst du es mit der Option -keypass festlegen.

Mehr über die Konfiguration des Sicherheits-Plugins erfährst du in der OpenSearch-Dokumentation.

Mit dem obigen Befehl solltest du eine ähnliche Ausgabe wie unten gezeigt erhalten haben.

**************************************************************************
** This tool will be deprecated in the next major release of OpenSearch **
** https://github.com/opensearch-project/security/issues/1755           **
**************************************************************************
Security Admin v7
Will connect to opensearch:9200 ... done
Connected as "CN=A,OU=UNIT,O=ORG,L=TORONTO,ST=ONTARIO,C=CA"
OpenSearch Version: 2.12.0
Contacting opensearch cluster 'opensearch' and wait for YELLOW clusterstate ...
Clustername: opensearch
Clusterstate: GREEN
Number of nodes: 1
Number of data nodes: 1
.opendistro_security index already exists, so we do not need to create one.
Populate config from /etc/opensearch/opensearch-security/
Will update '/config' with /etc/opensearch/opensearch-security/config.yml 
   SUCC: Configuration for 'config' created or updated
Will update '/roles' with /etc/opensearch/opensearch-security/roles.yml 
   SUCC: Configuration for 'roles' created or updated
Will update '/rolesmapping' with /etc/opensearch/opensearch-security/roles_mapping.yml 
   SUCC: Configuration for 'rolesmapping' created or updated
Will update '/internalusers' with /etc/opensearch/opensearch-security/internal_users.yml 
   SUCC: Configuration for 'internalusers' created or updated
Will update '/actiongroups' with /etc/opensearch/opensearch-security/action_groups.yml 
   SUCC: Configuration for 'actiongroups' created or updated
Will update '/tenants' with /etc/opensearch/opensearch-security/tenants.yml 
   SUCC: Configuration for 'tenants' created or updated
Will update '/nodesdn' with /etc/opensearch/opensearch-security/nodes_dn.yml 
   SUCC: Configuration for 'nodesdn' created or updated
Will update '/whitelist' with /etc/opensearch/opensearch-security/whitelist.yml 
   SUCC: Configuration for 'whitelist' created or updated
Will update '/audit' with /etc/opensearch/opensearch-security/audit.yml 
   SUCC: Configuration for 'audit' created or updated
Will update '/allowlist' with /etc/opensearch/opensearch-security/allowlist.yml 
   SUCC: Configuration for 'allowlist' created or updated
SUCC: Expected 10 config types for node {"updated_config_types":["allowlist","tenants","rolesmapping","nodesdn","audit","roles","whitelist","internalusers","actiongroups","config"],"updated_config_size":10,"message":null} is 10 (["allowlist","tenants","rolesmapping","nodesdn","audit","roles","whitelist","internalusers","actiongroups","config"]) due to: null
Done with success

Überprüfe die neuen Anmeldedaten mit dem folgenden Befehl.

Im vorherigen Test haben wir Anfragen an localhost gerichtet. Jetzt, da die TLS-Zertifikate eingerichtet sind und die neuen Zertifikate auf den tatsächlichen DNS-Eintrag des Hosts verweisen, werden die Anfragen an localhost die CN-Prüfung nicht bestehen und das Zertifikat wird als ungültig betrachtet. Füge daher deinen aktuellen DNS-Eintrag in den unten stehenden Befehl ein, um ihn zu überprüfen.

$ curl https://your.host.address:9200 -u admin:yournewpassword -k

Du solltest die folgende Antwort sehen.

{
  "name" : "opensearch",
  "cluster_name" : "opensearch",
  "cluster_uuid" : "3oFvYn96St2MOpDP3Sf29g",
  "version" : {
    "distribution" : "opensearch",
    "number" : "2.12.0",
    "build_type" : "deb",
    "build_hash" : "2c355ce1a427e4a528778d4054436b5c4b756221",
    "build_date" : "2024-02-20T02:18:31.541484890Z",
    "build_snapshot" : false,
    "lucene_version" : "9.9.2",
    "minimum_wire_compatibility_version" : "7.10.0",
    "minimum_index_compatibility_version" : "7.0.0"
  },
  "tagline" : "The OpenSearch Project: https://opensearch.org/"
}

Schritt 9 – OpenSearch Dashboards installieren

Da wir OpenSearch bereits installiert haben, können wir den Schritt des Importierens des OpenSearch GPG-Schlüssels überspringen.

Um OpenSearch Dashboards zu installieren, führe den folgenden Befehl aus, um ein APT-Repository dafür zu erstellen.

$ echo "deb [signed-by=/usr/share/keyrings/opensearch-keyring] https://artifacts.opensearch.org/releases/bundle/opensearch-dashboards/2.x/apt stable main" | sudo tee /etc/apt/sources.list.d/opensearch-dashboards-2.x.list

Aktualisiere die Liste der System-Repositorys.

$ sudo apt update

Liste alle verfügbaren Versionen von OpenSearch Dashboards auf.

$ sudo apt list -a opensearch-dashboards

Du solltest eine ähnliche Ausgabe sehen.

Listing... Done
opensearch-dashboards/stable 2.12.0 amd64
opensearch-dashboards/stable 2.11.1 amd64
opensearch-dashboards/stable 2.11.0 amd64
opensearch-dashboards/stable 2.10.0 amd64
opensearch-dashboards/stable 2.9.0 amd64
opensearch-dashboards/stable 2.8.0 amd64
opensearch-dashboards/stable 2.7.0 amd64
opensearch-dashboards/stable 2.6.0 amd64
opensearch-dashboards/stable 2.5.0 amd64

Installiere die neueste Version von OpenSearch Dashboard.

$ sudo apt install opensearch-dashboards

Oder installiere eine bestimmte Version von OpenSearch Dashboard.

$ sudo apt install opensearch-dashboards=2.12.0

Die Version von OpenSearch Dashboards und OpenSearch sollte die gleiche sein, sonst kann es zu Problemen kommen.

Lade den Service Daemon neu.

$ sudo systemctl daemon-reload

Aktiviere den OpenSearch Dashboards-Dienst.

$ sudo systemctl enable opensearch-dashboards

Starte den OpenSearch Dashboards-Dienst.

$ sudo systemctl start opensearch-dashboards

Überprüfe den Status des OpenSearch Dashboards-Dienstes.

$ sudo systemctl status opensearch-dashboards

Du solltest die folgende Ausgabe sehen.

? opensearch-dashboards.service - "OpenSearch Dashboards"
     Loaded: loaded (/lib/systemd/system/opensearch-dashboards.service; enabled; preset: enabled)
     Active: active (running) since Sat 2024-03-02 16:01:25 UTC; 4s ago
   Main PID: 7098 (node)
      Tasks: 11 (limit: 9484)
     Memory: 175.4M
        CPU: 5.389s
     CGroup: /system.slice/opensearch-dashboards.service
             ??7098 /usr/share/opensearch-dashboards/node/bin/node /usr/share/opensearch-dashboards/src/cli/dist

Mar 02 16:01:25 opensearch systemd[1]: Started opensearch-dashboards.service - "OpenSearch Dashboards".

Schritt 10 – OpenSearch Dashboards konfigurieren

OpenSearch Dashboards speichert seine Konfiguration in der Datei /etc/opensearch-dashboards/opensearch_dashboards.yml. Öffne sie zum Bearbeiten.

$ sudo nano /etc/opensearch-dashboards/opensearch_dashboards.yml

Suche die Zeile # server.host: "localhost" und entferne die Kommentare, indem du die Raute vor der Zeile entfernst und den Wert wie gezeigt änderst.

# Specifies the address to which the OpenSearch Dashboards server will bind. IP addresses and host names are both valid values.
# The default is 'localhost', which usually means remote machines will not be able to connect.
# To allow connections from remote users, set this parameter to a non-loopback address.
server.host: 0.0.0.0

Wenn du den Wert von server.host in 0.0.0.0 änderst, wird OpenSearch Dashboard an eine externe IP-Adresse gebunden, so dass es über das World Wide Web erreichbar ist. Wenn du die Dashboards über SSL mit einem Reverse Proxy bereitstellen willst, dann lass diesen Wert unverändert.

Scrolle nach unten, um den folgenden Abschnitt zu finden.

opensearch.hosts: [https://localhost:9200]
opensearch.ssl.verificationMode: none
opensearch.username: kibanaserver
opensearch.password: kibanaserver
opensearch.requestHeadersWhitelist: [authorization, securitytenant]

Ändere die Werte wie für unsere OpenSearch-Installation konfiguriert.

opensearch.hosts: [https://opensearch:9200]
opensearch.ssl.verificationMode: none
opensearch.username: admin
opensearch.password: <custom-admin-password>
opensearch.requestHeadersWhitelist: [authorization, securitytenant]

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Starte den OpenDashboards-Dienst neu.

$  sudo systemctl restart opensearch-dashboards

Öffne Port 5601 in der UFW-Firewall.

$ sudo ufw allow 5601

Öffne die URL http://<yourserverIP>:5601 oder http://opensearch.example.com:5601, um die OpenSearch Dashboards Website zu starten.

Wenn du mit dem Zugriff auf OpenSearch Dashboards über HTTP und mit einer Portnummer in der URL zufrieden bist, kannst du hier aufhören. Es ist jedoch besser, die Dashboards über SSL bereitzustellen. Dazu werden wir Nginx als Reverse Proxy installieren und SSL darüber bereitstellen.

Schritt 11 – Nginx installieren

Debian 12 wird mit einer älteren Version von Nginx ausgeliefert. Du musst das offizielle Nginx-Repository herunterladen, um die neueste Version zu installieren.

Importiere den Signierschlüssel von Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
    | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Füge das Repository für die Mainline-Version von Nginx hinzu.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] \
http://nginx.org/packages/mainline/debian `lsb_release -cs` nginx" \
    | sudo tee /etc/apt/sources.list.d/nginx.list

Aktualisiere die System-Repositories.

$ sudo apt update

Installiere Nginx.

$ sudo apt install nginx

Überprüfe die Installation. Auf Debian-Systemen funktioniert der folgende Befehl nur mit sudo.

$ sudo nginx -v
nginx version: nginx/1.25.4

Starte den Nginx-Server.

$ sudo systemctl start nginx

Überprüfe den Status des Dienstes.

$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
     Loaded: loaded (/lib/systemd/system/nginx.service; enabled; preset: enabled)
     Active: active (running) since Sat 2024-03-02 12:53:57 UTC; 4s ago
       Docs: https://nginx.org/en/docs/
    Process: 3976 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 3977 (nginx)
      Tasks: 3 (limit: 9484)
     Memory: 2.7M
        CPU: 9ms
     CGroup: /system.slice/nginx.service
             ??3977 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??3978 "nginx: worker process"
             ??3979 "nginx: worker process"

Mar 02 12:53:57 opensearch systemd[1]: Starting nginx.service - nginx - high performance web server...
Mar 02 12:53:57 opensearch systemd[1]: Started nginx.service - nginx - high performance web server.

Schritt 12 – SSL installieren

Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Debian installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Bei Debian 12 ist Snapd noch nicht installiert. Installiere das Snapd-Paket.

$ sudo apt install snapd

Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core && sudo snap refresh core

Installiere Certbot.

$ sudo snap install --classic certbot

Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Überprüfe, ob Certbot richtig funktioniert.

$ certbot --version
certbot 2.9.0

Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d craftcms.example.com

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/craftcms.example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Überprüfe den Certbot-Erneuerungszeitplanungsdienst.

$ sudo systemctl list-timers

Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.

NEXT                        LEFT           LAST                        PASSED    UNIT                         ACTIVATES                   ---------------------------------------------------------------------------------------------------------------------------------------  
Sat 2024-03-02 16:25:00 UTC 3h 27min left  -                           -         snap.certbot.renew.timer     snap.certbot.renew.service
Sat 2024-03-02 23:00:51 UTC 10h left       Sat 2024-03-02 06:29:02 UTC 6h ago    apt-daily.timer              apt-daily.service
Sun 2024-03-03 00:00:00 UTC 11h left       -                           -         dpkg-db-backup.timer         dpkg-db-backup.service
.....

Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.

Schritt 13 – Nginx konfigurieren

Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.

$ sudo nano /etc/nginx/nginx.conf

Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.

server_names_hash_bucket_size 64;

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Erstelle und öffne die Datei /etc/nginx/conf.d/opensearch.conf zum Bearbeiten.

$ sudo nano /etc/nginx/conf.d/opensearch.conf

Füge den folgenden Code in die Datei ein. Ersetze opensearch.example.com durch deinen Domainnamen.

server {

    listen 443 ssl;
    listen [::]:443 ssl;

    http2 on;
    http3 on;
    quic_retry on;

    server_name opensearch.example.com;

    access_log  /var/log/nginx/opensearch.access.log;
    error_log   /var/log/nginx/opensearch.error.log;

    ssl_certificate      /etc/letsencrypt/live/opensearch.example.com/fullchain.pem;
    ssl_certificate_key  /etc/letsencrypt/live/opensearch.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/opensearch.example.com/chain.pem;

    ssl_session_timeout  5m;
    ssl_session_cache shared:MozSSL:10m;
    ssl_session_tickets off;
    ssl_early_data on;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
    ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_dhparam /etc/ssl/certs/dhparam.pem;

    location / {
        proxy_pass http://localhost:5601;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
# enforce HTTPS
server {
    listen 80;
    listen [::]:80;
    server_name  opensearch.example.com;
    return 301   https://$host$request_uri;
}

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Überprüfe deine Nginx-Konfiguration.

$ sudo nginx -t

Starte den Nginx-Server neu.

$ sudo systemctl restart nginx

Besuche https://opensearch.example.com in deinem Browser, um OpenSearch Dashboards zu starten.

Schritt 14 – Zugriff und Nutzung von OpenSearch Dashboards

Wenn du Nginx verwendet hast, greifst du über die URL https://opensearch.example.com auf die Dashboards zu oder verwendest http://opensearch.example.com:5601. Du solltest die Anmeldeseite erhalten.

Gib admin und das benutzerdefinierte Admin-Passwort ein, das du in Schritt 4 für OpenSearch konfiguriert hast, und klicke auf die Schaltfläche Anmelden, um fortzufahren.

Klicke auf die Schaltfläche Daten hinzufügen, um direkt mit dem Hinzufügen von Daten zu beginnen, oder klicke auf den Link Auf eigene Faust erkunden, wenn du zuerst browsen möchtest. Wir werden zuerst browsen und es sollte ein Popup erscheinen, das dich über den Dark Mode von OpenSearch Dashboards informiert.

Klicke auf die Schaltfläche “ Verlassen“, um fortzufahren. Als nächstes wirst du aufgefordert, einen Mieter auszuwählen.

Tenants in OpenSearch Dashboards sind Bereiche zum Speichern von Indexmustern, Visualisierungen, Dashboards und anderen OpenSearch Dashboards-Objekten. Jeder Nutzer kann mehrere Tenants für verschiedene Zwecke erstellen. Tenants sind nützlich, um deine Arbeit sicher mit anderen Nutzern von OpenSearch Dashboards zu teilen. OpenSearch gibt dir die Möglichkeit, zwischen drei Optionen zu wählen.

• Global – Dieser Tenant wird von allen OpenSearch Dashboards-Nutzern gemeinsam genutzt.
• Privat – Dieser Tenant ist exklusiv für jeden Nutzer und kann nicht geteilt werden.
• Benutzerdefiniert – Administratoren können benutzerdefinierte Tenants erstellen und sie bestimmten Rollen zuweisen. Einmal erstellt, kannst du diese Tenants verwenden, um einer bestimmten Gruppe von Nutzern Räume zur Verfügung zu stellen.

Für den Moment bleiben wir bei der Standardoption eines privaten Tenants. Klicke auf die Schaltfläche Bestätigen, um fortzufahren. Du wirst mit der folgenden Seite begrüßt.

Als Nächstes werden wir die Verbindung zwischen OpenSearch und den OpenSearch Dashboards überprüfen.

Klicke oben rechts auf die Schaltfläche Dev Tools und dir wird ein kleines Popup über die Konsolen-UI für die OpenSearch Dashboards angezeigt.

Klicke auf die Schaltfläche Verlassen, gib die Abfrage GET / in die Konsole auf der linken Seite ein und klicke auf die kleine Schaltfläche Abspielen in der Mitte. Du solltest die folgende Ausgabe auf der rechten Seite sehen.

Dies bestätigt, dass OpenSearch Dashboards Daten von OpenSearch empfängt und dass beide gut funktionieren. Von nun an kannst du mit dem Hinzufügen von Daten beginnen.

Fazit

Damit ist die Anleitung zur Installation von OpenSearch auf einem Debian 12 Server abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.