SIEM

Nutzen Sie unser SIEM, um Informationen über die Sicherheitslage Ihres IT-Netzwerks zu sammeln und zu analysieren

Sichern Sie Ihre Daten mit unserem leistungsstarken SIEM: Kontaktieren Sie unsere Experten über [e-mail], um schnellstmöglich durchzustarten und erhalten Sie Unterstützung bei Ihrer Installation!

Aufbau

Vorbereitung

1. Für die Installation des SIEMs benötigen Sie folgende Komponenten

Komponente	Anforderung
1x SIEM Management Server	4CPU, 8GB RAM, 200GB Disk
1X SIEM Index Server	4CPU, 8GB RAM, 200GB Disk

Dieses Setup ist ausschließlich für einen Workload von 10 GB Pro Tag ausgelegt! Falls Sie höhere Anforderungen haben, lassen Sie sich gern von uns individuell beraten.

1. Weiterhin müssen folgende Firewall Regeln freigegeben werden:

• NGS APP Server -> SIEM Management Server - Port 443

• SIEM Index Server <- SIEM Management Server - Port 8983

1. Erstellen Sie auf allen VMs einen Swap, sollten Sie diesen bisher nicht haben.

sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
sudo cp /etc/fstab /etc/fstab.bak
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf
echo 'vm.vfs_cache_pressure=10' | sudo tee -a /etc/sysctl.conf

1. Erstellen Sie eine URL für Ihren SIEM Server z.B.: ngs-siem.ihre-domain.de. Für diese muss ein Zertifikat im PEM Format vorliegen. Nutzen Sie ein selbst signiertes Zertifikat beachten Sie bitte diese Anleitung.

Bitte verändern Sie nicht die unten bereitgestellten Docker Konfigurationen, da diese aufeinander abgestimmt sind.

Installation SIEM Management Server

Der SIEM Management Server empfängt die Logs über die API und sendet diese an den SIEM Index Server weiter, wo sie vearbeitet werden.

Hierfür werden folgende Komponenten installiert:

• nginx

• docker-ce

• docker-ce-cli

• containerd.io

• docker-buildx-plugin

• docker-compose-plugin

• Enginsight Loggernaut

Docker installieren

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
    "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
    "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

1. Erstellen Sie einen Ordner für Docker und navigieren Sie in diesen

sudo mkdir /opt/enginsight/enterprise -p
cd /opt/enginsight/enterprise

1. Passen Sie die docker-compose.yml an

sudo nano docker-compose.yml

Fügen und ergänzen Sie folgende Konfiguration

version: '3'
services:
  zoo:
    image: zookeeper:3.9
    container_name: zookeeper
    restart: always
    volumes:
      - /var/zookeeper_data:/data
      - /var/zookeeper_logs:/logs
      - /var/zookeeper_datalog:/datalog
    ports:
      - <IPvomSIEMManagementServer>:2181:2181
    environment:
      ZOO_AUTOPURGE_PURGEINTERVAL: 24
      ZOO_SERVERS: server.1=<IPvomSIEMManagementServer>:2888:3888;2181
      ZOO_4LW_COMMANDS_WHITELIST: mntr,conf,ruok

Die <IPvomSIEMManagementServer> entspricht der internen IP Adresse des SIEM-Management Servers. Diese muss sowohl von dem Management Server, als auch von den anderen SIEM Index Server(n) erreichbar sein.

1. Legen Sie die Verzeichnisse an, die in der docker-compose definiert sind:

sudo mkdir /var/zookeeper_data
sudo mkdir /var/zookeeper_datalog
sudo mkdir /var/zookeeper_logs

1. Starten Sie den Docker Container

sudo docker compose up -d

1. Prüfen Sie, ob Ihr Docker Container läuft

sudo docker ps

nginx installieren

1. Installieren Sie nginx

sudo apt install nginx -y

1. Erstellen Sie Benutzername und Passwort für die Authentifizierung am SIEM Management Server.

curl -sSL https://get.enginsight.com/siem/scripts/basicauth.sh | sudo -E bash -s 

Hierbei werden Benutzername und Passwort automatisch generiert. (BasicAuth)

Sie erhalten folgenden Output:

{
  "siem": {
    "basicAuth": {
      "username":"<IhrBenutzername>",
      "password":"<IhrPasswort>"
    },
    ...
  }
}

Speichern Sie den Code ab, da Sie diesen später für die Anpassung des App Servers benötigen.

1. Passen Sie die nginx Konfiguration an:

Hierfür öffnen Sie die Konfiguration:

sudo nano /etc/nginx/sites-available/default

und passen diese wie folgt an:

upstream backend {
   server <IpVonSiemIndexServer1>:8983;
   server <IpVonSiemIndexServer2>:8983;
}


# nur relevant bei LetsEncrypt  
server {
    listen 80;
 
    location ~ /.well-known {
        allow all;
    }
 
    location / {
        return 302 https://<IhreSiemUrl>/solr/;
    }
 
    root /var/www/<IhreSiemUrl>;
 
    server_name <IhreSiemUrl>;
}

server {
    listen 443 ssl http2;

    server_name <IhreSiemUrl>;
 
    ssl_protocols TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH";
    ssl_ecdh_curve secp384r1;
    ssl_session_cache shared:SSL:10m;
    ssl_session_tickets off;
    ssl_stapling on;
    ssl_stapling_verify on;
    resolver 8.8.8.8 8.8.4.4 valid=300s;
    resolver_timeout 5s;
    
    #$ mkdir /etc/nginx/ssl -p
    #$ openssl dhparam -out /etc/nginx/ssl/dhparam.pem 2048 
    
    ssl_dhparam /etc/nginx/ssl/dhparam.pem;
    ssl_certificate /etc/letsencrypt/live/<IhreSiemUrl>/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/<IhreSiemUrl>/privkey.pem;
 
    client_max_body_size 1024m;
 
    auth_basic "Restricted Content";
    auth_basic_user_file /etc/nginx/.htpasswd;
 
    location ~* "^/v1/" {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host              $host;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Real-IP         $remote_addr;
        proxy_set_header X-Forwarded-Proto "https";
        proxy_set_header X-Forwarded-Ssl   "on";
    }
 
    location / {
        proxy_pass http://backend;
        proxy_set_header Host              $host;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Real-IP         $remote_addr;
        proxy_set_header X-Forwarded-Proto "https";
        proxy_set_header X-Forwarded-Ssl   "on";
    }
}

1. Überprüfen Sie die nginx Konfiguration:

sudo nginx -t

1. Starten Sie den nginx neu, um die Konfiguration zu übernehmen:

sudo systemctl restart nginx

Installation SIEM Index Server

Docker installieren

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
    "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
    "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

1. Erstellen Sie einen Ordner für Docker und navigieren Sie in diesen:

sudo mkdir /opt/enginsight/enterprise -p
cd /opt/enginsight/enterprise

1. Passen Sie die docker-compose.yml an:

sudo nano docker-compose.yml

Fügen und ergänzen Sie folgende Konfiguration:

version: '3'
services:
 solr:
    restart: always
    image: solr:9.3
    ports:
      - "<IPvomSIEMIndexServer>:8983:8983"
    volumes:
      - /var/solr:/var/solr/data
    environment:
      - ZK_HOST=<IPvomSIEMManagementServer>:2181
      - SOLR_HOST=<IPvomSIEMIndexServer>
      - SOLR_OPTS=-XX:G1HeapRegionSize=32M -Dpkiauth.ttl=<Maximaldauer in Millisekunden (Standard=5000)>
      - SOLR_JAVA_MEM=-Xms1024M -Xmx2048M
    command: solr -f -cloud

<IPvomSIEMIndexServer> entspricht der IP, des SIEM Index Servers

<IPvomSIEMManagementServer> entspricht der IP des SIEM Management Servers

Bei SOLR_JAVA_MEM muss der RAM für den Container eingestellt werden. Die Empfehlung ist, mindestens immer 1/4 des gesamten RAMs zu vergeben.

1. Legen Sie Verzeichnisse an und vergeben Sie Rechte, um darauf zuzugreifen:

sudo mkdir /var/solr
sudo chown 8983:8983 -R /var/solr

Die Verwendung des Nutzers 8983 aus dem Docker-Container ist korrekt und bedeutsam. Führen Sie diesen Schritt zwingend durch, um die Installation erfolgreich durchführen zu können.

1. Starten Sie den Docker Container:

sudo docker compose up -d

1. Überprüfen Sie, ob der Port ausschließlich für die interne Adresse offen ist. Hier für können Sie dienet-toolsinstallieren (sudo apt install net-tools).

netstat -tulpen

Das Ergebnis sollte wie folgt aussehen:

Proto Recv-Q Send-Q Local Address           Foreign Address         State       User       Inode      PID/Program name       
tcp        0      <interneIP>:8983          0.0.0.0:*               LISTEN      0         

Achten Sie darauf, dass unter Host die richtige IP Adresse erscheint.

Sollten Sie einen zuzsätzlichen Indexserver installieren wollen, passen Sie bitte die Konfiguration, wie in Schritt 3 unter nginx installieren erklärt, an.

BETA - Installation SIEM KI

Um die Funktionalitäten in der SIEM KI verwenden zu können, bedarf es einiger Konfigurationen.

Hierbei handelt es sich um eine Betafunktionalität. Bitte beachten Sie, dass es bei Vorhersagen der Metriken und der daraus resultierenden Anomalie-Erkennung vereinzelt zu Fehlern kommen kann.

1. Betroffene Komponenten updaten.

- ui-m1 
- server-m2 
- loggernaut-m47 

Die aktuellen Versionen der einzelnen Komponenten finden Sie immer hier:

https://github.com/enginsight/enterprise/blob/master/docker-compose.yml

1. Experimentellen ML Modus im Loggernaut aktivieren.

Passen Sie dazu die Konfigurationsdatei unter

/opt/enginsight/loggernaut/config.json

an, indem sie folgende Zeile auf Root Ebene hinzufügen:

  "experimental": ["traicer"]

Starten Sie den Loggernaut danach neu um die Konfiguration zu übernehmen.

sudo systemctl restart ngs-loggernaut.service

1. Docker installieren.

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
    "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
    "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

1. Docker Compose anlegen.

Folgendes muss in der docker-compose.yml enthalten sein:

version: '3'
services:
  traicer:
    image: registry.enginsight.com/enginsight/traicer-m50:0.0.1
    restart: always
    volumes:
      - /var/traicer/data:/traicer/data
    environment:
      ADDRESS: 'wss://<SIEM-Management-Adresse>/v1/traicer'
      BASIC_AUTH_USER: '<SIEM-BasicAuth-User>'
      BASIC_AUTH_PASSWORD: '<SIEM-BasicAuth-Passwort>'

Sollte das Machine Learning auf der selben Machine wie der Loggernaut laufen und zu große CPU Last erzeugen, sodass der Loggernaut den Logdurchsatz nicht mehr händeln kann, empfehlen wir die CPU-Shares des Containers zu reduzieren, damit andere Prozesse eine höhere Priorität haben.

Hierfür ist diese Anpassung an der docker-compose.yml notwendig:

version: '3'
services:
  traicer:
    cpu_shares: 512

1. Anpassungen an Nginx Config vom Management Server für Websocket Support.

Passen Sie folgende Datei an: /etc/nginx/sites-available/default

map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}

...

server {
  ...
  
  proxy_http_version 1.1;

  ...

  location ~* "^/v1/" {
    ...
    
    proxy_set_header Upgrade           $http_upgrade;
    proxy_set_header Connection        $connection_upgrade;

    ...
  }
}

Überprüfen Sie die Config auf Fehler:

sudo nginx -t

Starten Sie nginx neu um die Config zu übernehmen:

sudo systemctl restart nginx

1. Stellen Sie sicher, dass Sie über root-Rechte verfügen. Sollte dies nicht der Fall sein, melden Sie sich als Superuser an.

su - root

1. Stellen Sie sicher, dass die aktuelle Version von Docker und Docker Compose installiert ist. Die aktuellen Versionsnummern finden Sie hier: Docker Engine, Docker Compose.

docker version

docker-compose -v

Installieren Sie Docker nicht über Snap oder bei der Installation des Betriebssystems, sondern installieren Sie Docker ausschließlich aus den Paketquellen der offiziellen Anleitung.

1. Loggen Sie sich bei Docker ein.

docker login registry.enginsight.com

Die Zugangsdaten erhalten Sie von uns.

Wenn es bei der Authentifizierung zu Problemen kommt, überprüfen Sie, ob ein aktueller gpg2 Key vorliegt und generieren Sie ihn gegebenenfalls automatisch:

apt install gnupg2

gpg2 --gen-key

1. Starten Sie den Container mit den eben durchgeführten Anpassungen.

sudo docker compose up -d

Anpassung APP Server

Passen Sie die Konfiguration des Enginsight APP Servers und den Zugriff an, um mit Ihrem SIEM Management Server zu kommunizieren.

1. Wechseln Sie in die Konfigurationsdatei:

sudo nano /opt/enginsight/enterprise/conf/services/config.json

1. fügen Sie in die Konfiguration folgenden Abschnitt ein

"siem": {
  "basicAuth": {
    "username": "",
    "password": ""
  },
  "url": "",
  "numShards": 2,
  "replicationFactor": 1,
  "management": {
    "organisation": "IhreOrganisation"
  }
},

Füllen Sie "basicAuth" mit Ihren Credentials aus, die Sie im Proxy hinterlegt haben.

Bei der URL tragen Sie die URL des SIEMs Servers ein oder dessen IP Adresse.

numShards sind für das parallele Abarbeiten der Anfragen zuständig. Hier sollten mindestens 2 angegeben werden. Bei größeren Instanzen sollte die hälfte der Kerne hinterlegt werden. Bei einem Server mit 8 Kernen, entsprechend 4. Der replicationFactor ist für die Replication verantwortlich. Die Daten werden auf mehreren Servern verteilt. Der Vorteil ist, dass die anderen Index Server bei einem Ausfall eingreifen können. Jedoch steigt der Verbauch des Speichers. Sie können, wenn gewünscht, die Anzahl Ihrer Index Server für die Replikation eintragen. Alternativ lassen Sie das auf 1.

Die organisation entspricht der Organsisations ID, welche die Verwaltung der SIEM Cluster übernimmt. Wählen Sie dafür eine Organisation (wir empfehlen Ihre "Hauptorga").

Fügen Sie in der Konfiguration unter "api" noch

"url": "",

hinzu. Sodass Ihre Konfiguration wie folgt aussieht:

"siem": {
  "basicAuth": {
    "username": "<IhrUsername>",
    "password": "<IhrPasswort>"
  },
  "url": "<IhreSIEMURl>",
  "numShards": 2,
  "replicationFactor": 1,
  "management": {
    "organisation": "IhreOrganisation"
  }
},
"api": {
  "url": "<IhreAPIURL>",
  ...

1. Wechseln Sie ins Enginsight Verzeichnis und starten Sie die setup.sh

cd /opt/enginsight/enterprise
sudo ./setup.sh

1. Regulieren Sie den Speicherbedarf der Docker Logs, in dem Sie diese wie folgt auf 100 Mb beschränken:

nano /etc/docker/daemon.json

Folgendes einfügen:

{  
  "log-driver": "json-file",  
  "log-opts": {
    "max-size": "100m",
    "max-file": "30"  
  }
}

Docker Dienst neustarten:

systemctl restart docker

1. Stellen Sie einen Access Key für den SIEM Management Server aus.

Loggernaut installieren

Der Loggernaut dient dazu die Logs entgegen zu nehmen und zu verarbeiten

1. Loggen Sie sich auf Ihrem SIEM Management Server ein

2. Installieren Sie den Loggernaut wie folgt:

curl -sSL https://get.enginsight.com/loggernaut/latest/setup.sh | sudo -E bash -s \
    api=https://<apiurl> \
    accessKeyId=<accessKeyId> \
    accessKeySecret=<accessKeySecret> \
    indices=http://<SiemIndexServer>:8983 \
    username=<IhrUsername> \
    password=<IhrPasswort>

Der Login mittels Username und Passwort erfolgt über Basic Authentification.

1. Wechseln Sie in die Enginsight Instanz und klicken Sie in den Reiter "SIEM". Die Oberfläche baut eine Verbindung zu den Servern auf, das kann einige Sekunden dauern.

Mögliche Probleme:

Sollte Ihnen die Plattform anzeigen, dass sie keine Verbindung herstellen konnte, prüfen Sie bitte folgende Punkte:

1. Kann der APP Server den SIEM Management Server erreichen? Testen Sie dies mittels curl. Hierbei muss Status Code 200 zurückkommen

curl -v -u "<username>:<password>" <IhreSIEMDomain>/v1/collections

1. Kann der SIEM Server den APP Server erreichen?

2. Wurden alle Firewall Freigaben aus dem Punkt Vorbereitung gesetzt?

Selbstsignierte Zertifikate:

Sollten Sie für Ihre SIEM URL ein selbstsigniertes Zertifiakt oder eine Windows PKI nutzen, müssen Sie das root Zertifikat zunächst auf dem SIEM Management sowie auf dem App Server trusten. Weiterhin benötigt es eine Anpassung in der docker-compose.yml des App Servers.

1. Zertifiakt trusten:

Kopieren Sie ihr root Zertifiakt auf dem SIEM Management nach /usr/local/share/ca-certificates/ und updaten Sie den CA Store

sudo cp foo.crt /usr/local/share/ca-certificates/foo.crt

sudo update-ca-certificates

ca.crt bitte durch den Namen Ihres Root Zertifiakts ersetzen.

1. Wiederholen Sie dies für den App Server

2. docker-compose.yml anpassen auf dem App Server:

Navigieren Sie in den Ordner /opt/enginsight/enterprise auf dem App Server und öffnen Sie die Datei mittels:

sudo nano docker-compose.yml

Ergänzen Sie unter enviroment und volumes folgendes:

environment:
  - NODE_EXTRA_CA_CERTS=/etc/ssl/cert.pem
    volumes:
      - "./conf/services/config.json.production:/etc/enginsight/server-m2/config.json"
      - "/etc/nginx/cert.pem:/etc/ssl/cert.pem"

Der Pfad /etc/nginx/cert.pem:/etc/ssl/cert.pem teilt sich wie folgt auf:

Links: Pfad der Chain auf dem Server Rechts: Pfad im Docker Container

Fügen Sie die ersten Logs hinzu:

Sie werden zu Beginn feststellen, dass das SIEM sich bereits mit Logs füllt. Diese kommen standardmäßig aus dem IDS, IPS, FIM, etc. Die Quellen können Sie unter SIEM -> Data Lake -> ngs.source einsehen.

Logs vom Agent

Um die Logs, wie Syslog (Linux), EventLog (Windows) und Unified Logs (MacOs) zu erhalten, müssen Sie dies zunächst im Policy Manager erlauben. Navigieren Sie hierfür zu Hosts -> Policy Manager und erstellen Sie eine neue Policy namens SIEM.

Bestimmen Sie mittels Tags, welcher Host Logs schicken darf und aktivieren Sie unter Erweiterte Einstellungen "Auswertung von Systemlogs erlauben".

Navigieren Sie nun zurück in den Reiter SIEM. Unter Integrierte Kollektoren finden Sie die einzelnen Betriebssysteme. Hier können Sie oben rechts einen neuen Kollektor hinzufügen.

Vergeben Sie einen Namen für das jeweilige Betriebssystem was geloggt werden soll. Aktivieren Sie das Logging und ordnen Sie es einem Tag zu. Im Anschluss können Sie die Kanäle auswählen, über die die Logs gesammelt werden sollen.

Anbindung von Geräten, ohne Agent (z.B. Firewall)

Sie können an das SIEM auch Geräte anbinden, welche keinen Agent installiert haben. Hierfür definieren Sie einen Agent, welcher die Logs einsammeln soll. Navigieren Sie dafür in das SIEM -> Event Relais.

Wählen Sie einen Namen, mit der Sie eindeutig Ihren Kollektor identifizieren können. Aktivieren Sie erneut das Logging und definieren Sie unter Host einen Client oder Server, welcher die Logs von dem Gerät (z.B.) Firewall entgegen nehmen soll. Wählen Sie zudem das Format aus und entscheiden Sie, über welchen Port und welchem Protokoll die Daten gesendet werden sollen.

Es ist möglich mehrere Kollektoren zu konfigurieren. Das ist vor allem bei mehreren Netzen sinnvoll, um keine neuen Firewall Regeln konfigurieren zu müssen, da pro Netz ein Kollektor genutzt werden kann.

Installation von Machine Learning

1. Updaten Sie die betroffene Komponenten Aktualisieren Sie die folgenden Komponenten auf die genannten Versionen:

   • ui-m1: <aktuelle Version>

   • server-m2: <aktuelle Version>

   • loggernaut-m47: <2.7.0>

Stellen Sie sicher, dass alle oben genannten Komponenten auf den neuesten Stand gebracht werden, bevor Sie mit den weiteren Schritten fortfahren.

1. Experimentellen ML-Modus im Loggernaut aktivieren Öffnen Sie die Konfigurationsdatei unter /opt/enginsight/loggernaut/config.json und fügen Sie die experimentellen Einstellungen hinzu:

   {
     ...
     "experimental": ["profiler-siem"]
   }

   Starten Sie anschließend den Loggernaut-Dienst neu:

   systemctl restart ngs-loggernaut

2. Machine Learning Modul installieren

   1. Docker installieren Führen Sie die folgenden Befehle aus, um Docker zu installieren:

      sudo apt-get update
      sudo apt-get install ca-certificates curl gnupg
      sudo install -m 0755 -d /etc/apt/keyrings
      curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
      sudo chmod a+r /etc/apt/keyrings/docker.gpg
      echo \
          "deb [arch=\"$(dpkg --print-architecture)\" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
          \"$(. /etc/os-release && echo \"$VERSION_CODENAME\")\" stable" | \
      sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
      sudo apt-get update
      sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

   2. Docker Compose anlegen Erstellen Sie eine docker-compose.yml-Datei mit folgendem Inhalt:

      version: '3'
      services:
        apollo:
          image: <Registry Adresse>
          restart: always
          volumes:
            - /var/profiler-siem/data:/apollo/data
          environment:
            ADDRESS: 'wss://<SIEM-Management-Adresse>/v1/profiler-siem'
            BASIC_AUTH_USER: '<SIEM-BasicAuth-User>'
            BASIC_AUTH_PASSWORD: '<SIEM-BasicAuth-Passwort>'

      Optionaler Schritt: Wenn das Machine Learning-Modul auf demselben Server wie der Loggernaut läuft und eine hohe CPU-Auslastung verursacht, können Sie die CPU-Shares des Containers verringern, um die Priorität anderer Prozesse zu erhöhen. Passen Sie dazu die docker-compose.yml wie folgt an:

      version: '3'
      services:
        profiler-siem:
          cpu_shares: 512

3. Anpassungen an der Nginx-Konfiguration des Management-Servers für WebSocket-Support Bearbeiten Sie die Datei /etc/nginx/sites-available/default und fügen Sie die folgenden Zeilen hinzu, um den WebSocket-Support zu aktivieren:

   map $http_upgrade $connection_upgrade {
       default upgrade;
       ''      close;
   }
   
   server {
     proxy_http_version 1.1;
   
     location ~* "^/v1/" {
       proxy_set_header Upgrade           $http_upgrade;
       proxy_set_header Connection        $connection_upgrade;
     }
   }

   Speichern Sie die Datei und laden Sie Nginx neu, um die Änderungen zu übernehmen:

   systemctl reload nginx

4. Container starten

   Starten Sie den Docker-Container mit dem folgenden Befehl:

   docker compose up -d

Damit ist das Machine-Learning-Modul erfolgreich installiert und konfiguriert.