So installierst du Rocket.Chat Server auf Rocky Linux 8

Rocket.Chat ist ein Open-Source-Chat-Server, der in JavaScript mit dem Meteor.js-Framework entwickelt wurde. Mit ihm kannst du sicher und in Echtzeit über mehrere Geräte hinweg kommunizieren. Unternehmen und Organisationen können damit einen eigenen Chat-Server für die interne Kommunikation mit ihren Mitarbeitern aufbauen. Er lässt sich mit sozialen Kanälen, Chatbots, sozialen Medien und Produktivitäts-Apps integrieren. Es ermöglicht die Überwachung von DevOps-Workflows mit Integrationen über Bitbucket, Jira, GitLab, Confluence, Bamboo, etc. Sie ist auf mehreren Desktop- und Mobilplattformen verfügbar. Es gibt zwei Versionen von Rocket.Chat, eine kostenlose Community-Version und eine Enterprise-Version.

In diesem Tutorial werden wir die kostenlose Community-Edition von Rocket.Chat auf einem Rocky-Linux-Rechner installieren.

Voraussetzungen

  • Ein Server mit Rocky Linux und mindestens 1 GB RAM für einen Server für bis zu 200 Benutzer und bis zu 50 gleichzeitig aktive Benutzer. Wenn du mehr als 200 Nutzer/innen unterbringen willst, solltest du dich für einen Server mit mindestens 2 GB RAM entscheiden.
  • Einen Domainnamen, der auf den Server verweist. Für unser Tutorial werden wir die Domain rocketchat.example.com verwenden.
  • Ein Nicht-Sudo-Benutzer mit Root-Rechten.
  • SELinux ist deaktiviert.
  • Alles ist auf dem neuesten Stand.
    $ sudo dnf update
    
  • Installiere grundlegende Hilfspakete. Einige von ihnen sind vielleicht schon installiert.
    $ sudo dnf install wget curl nano unzip yum-utils -y
    

Schritt 1 – Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.

$ sudo firewall-cmd --state
running

Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.

$ sudo firewall-cmd --permanent --list-services

Es sollte die folgende Ausgabe angezeigt werden.

cockpit dhcpv6-client ssh

Moodle braucht HTTP- und HTTPS-Ports, um zu funktionieren. Öffne sie.

$ sudo firewall-cmd --add-service=http --permanent
$ sudo firewall-cmd --add-service=https --permanent

Lade die Firewall neu, um die Änderungen zu übernehmen.

$ sudo firewall-cmd --reload

Schritt 2 – Installiere Docker und Docker Compose

Rocky Linux wird mit einer älteren Version von Docker ausgeliefert. Um die neueste Version zu installieren, installierst du zuerst das offizielle Docker-Repository.

$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

Installiere die neueste Version von Docker.

$ sudo dnf install docker-ce docker-ce-cli containerd.io

Aktiviere den Docker-Daemon und starte ihn.

$ sudo systemctl enable docker --now

Überprüfe, ob er läuft.

 docker.service - Docker Application Container Engine
   Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; vendor preset: disabled)
   Active: active (running) since Sat 2022-08-20 22:35:19 UTC; 1s ago
     Docs: https://docs.docker.com
 Main PID: 82575 (dockerd)
    Tasks: 7
   Memory: 31.1M
   CGroup: /system.slice/docker.service
           ??82575 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
...

Standardmäßig benötigt Docker Root-Rechte. Wenn du vermeiden willst, dass du jedes Mal sudo verwendest, wenn du den Befehl docker ausführst, füge deinen Benutzernamen der Gruppe docker hinzu.

$ sudo usermod -aG docker $(whoami)

Um diese Änderung zu aktivieren, musst du dich vom Server abmelden und als derselbe Benutzer wieder anmelden oder den folgenden Befehl verwenden.

$ su - ${USER}

Bestätige, dass dein Benutzer der Docker-Gruppe hinzugefügt wurde.

$ groups
navjot wheel docker

Schritt 3 – Installiere Docker Compose

Docker Compose ist als Plugin verfügbar. Die neueste Version von Docker Compose findest du auf der Github-Releaseseite. Zum Zeitpunkt der Erstellung dieses Tutorials ist die neueste Version 2.10.0 verfügbar.

Erstelle das Verzeichnis für Docker-Plugins.

$ mkdir ~/.docker/cli-plugins -p

Lade das Docker compose Plugin in dieses Verzeichnis herunter.

$ curl -SL https://github.com/docker/compose/releases/download/v2.10.0/docker-compose-linux-x86_64 -o ~/.docker/cli-plugins/docker-compose

Setze die Berechtigungen, um das Plugin ausführbar zu machen.

$ chmod +x ~/.docker/cli-plugins/docker-compose

Überprüfe die Installation.

$ docker compose version

Du wirst die folgende Ausgabe erhalten.

Docker Compose version v2.10.0

Schritt 4 – RocketChat installieren

Erstelle ein Verzeichnis zum Speichern von Docker-Dateien.

$ mkdir ~/rocketchat

Wechsle in das Verzeichnis.

$ cd ~/rocketchat

Erstelle und öffne die Rocketchat Docker compose Datei zum Bearbeiten.

$ nano docker-compose.yml

Füge den folgenden Code in die Datei ein.

volumes:
  mongodb_data:
  rocketchat-uploads:

services:
  rocketchat:
    image: registry.rocket.chat/rocketchat/rocket.chat:5.0.4
    restart: on-failure
    volumes:
      - rocketchat-uploads:/app/uploads
    environment:
      MONGO_URL: mongodb://mongodb:27017/rocketchat?replicaSet=rs0
      MONGO_OPLOG_URL: mongodb://mongodb:27017/local?replicaSet=rs0
      ROOT_URL: https://rocketchat.example.com
      PORT: 3000
      DEPLOY_METHOD: docker
      Accounts_UseDNSDomainCheck: 'false'
      MAIL_URL: 'smtps://AmazonSESuser:[email protected]:587'
    depends_on:
      - mongodb
    expose:
      - 3000
    ports:
      - 3000:3000
    healthcheck:
      test: >
         /usr/local/bin/node -e '
         const http = require("http");
         const options = {
           host: "localhost",
           port: 3000,
           path: "/api/info",
           timeout: 2000
         };
         const healthCheck = http.request(options, (res) => {
           console.log(`HEALTHCHECK STATUS: $${res.statusCode}`);
           if (res.statusCode == 200) {
             process.exit(0);
           } else {
             process.exit(1);
           }
         });
         healthCheck.on("error", function (err) {
           console.error("ERROR");
           process.exit(1);
         });
         healthCheck.end();'
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 60s

  mongodb:
    image: bitnami/mongodb:4.4
    restart: on-failure
    volumes:
      - mongodb_data:/bitnami/mongodb
    environment:
      MONGODB_REPLICA_SET_MODE: primary
      MONGODB_REPLICA_SET_NAME: rs0
      MONGODB_PORT_NUMBER: 27017
      MONGODB_INITIAL_PRIMARY_HOST: mongodb
      MONGODB_INITIAL_PRIMARY_PORT_NUMBER: 27017
      MONGODB_ADVERTISED_HOSTNAME: mongodb
      MONGODB_ENABLE_JOURNAL: 'true'
      ALLOW_EMPTY_PASSWORD: 'yes'
    healthcheck:
      test: echo 'db.runCommand("ping").ok' | mongo mongodb:27017/test --quiet
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 60s

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

Starte den Docker-Container.

$ docker compose up -d

Überprüfe den Status der Container, um sicherzustellen, dass sie ordnungsgemäß laufen.

CONTAINER ID   IMAGE                                               COMMAND                  CREATED         STATUS                   PORTS                                       NAMES
59cd748e684f   registry.rocket.chat/rocketchat/rocket.chat:5.0.4   "docker-entrypoint.s…"   2 minutes ago   Up 2 minutes (healthy)   0.0.0.0:3000->3000/tcp, :::3000->3000/tcp   rocketchat-rocketchat-1
1fdabedf8681   bitnami/mongodb:4.4                                 "/opt/bitnami/script…"   2 minutes ago   Up 2 minutes (healthy)   27017/tcp                                   rocketchat-mongodb-1

Du kannst auch den folgenden Befehl verwenden, um den Status zu überprüfen.

$ docker compose ps
NAME                      COMMAND                  SERVICE             STATUS              PORTS
rocketchat-mongodb-1      "/opt/bitnami/script…"   mongodb             running (healthy)   27017/tcp
rocketchat-rocketchat-1   "docker-entrypoint.s…"   rocketchat          running (healthy)   0.0.0.0:3000->3000/tcp, :::3000->3000/tcp

Zu diesem Zeitpunkt kannst du deine Installation überprüfen, indem du die URL http://rocketchat.example.com:3000 oder http://<serverIPaddress>:3000 im Browser aufrufst. Der nächste Schritt besteht darin, SSL zu konfigurieren und die Installation hinter einen Proxy-Server zu stellen.

Schritt 5 – SSL installieren

Um ein SSL-Zertifikat mit Let’s Encrypt zu installieren, müssen wir das Tool Certbot installieren.

Als erstes musst du das EPEL-Repository herunterladen und installieren.

$ sudo dnf install epel-release

Führe die folgenden Befehle aus, um Certbot zu installieren.

$ sudo dnf install certbot

Erstelle das SSL-Zertifikat.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d rocketchat.example.com

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

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

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

Erstelle ein Challenge-Web-Root-Verzeichnis für die automatische Erneuerung von Let’s Encrypt.

$ sudo mkdir -p /var/lib/letsencrypt

Erstelle einen Cron Job zur Erneuerung des SSL-Zertifikats. Er wird jeden Tag ausgeführt, um das Zertifikat zu überprüfen und bei Bedarf zu erneuern. Erstelle dazu zunächst die Datei /etc/cron.daily/certbot-renew und öffne sie zur Bearbeitung.

$ sudo nano /etc/cron.daily/certbot-renew

Füge den folgenden Code ein.

#!/bin/sh
certbot renew --cert-name rocketchat.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"

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

Ändere die Berechtigungen für die Aufgabendatei, um sie ausführbar zu machen.

$ sudo chmod +x /etc/cron.daily/certbot-renew

Schritt 6 – Nginx installieren und konfigurieren

Wir werden die neueste Version von Nginx installieren. Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zum Bearbeiten.

$ sudo nano /etc/yum.repos.d/nginx.repo

Füge die folgenden Zeilen in die Datei ein.

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

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

Installiere Nginx.

$ sudo dnf install nginx

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.22.0

Aktiviere und starte den Nginx-Dienst.

$ sudo systemctl enable nginx --now

Erstelle und öffne die Datei /etc/nginx/conf.d/rocket.conf zur Bearbeitung.

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

Füge den folgenden Code in die Datei ein.

# Redirect all non-encrypted to encrypted
    server {
        listen 80;
        listen [::]:80;
        server_name rocketchat.example.com;
        return 301 https://$host$request_uri;
    }

# HTTPS Server
    server {
        listen 443 ssl http2;
        listen [::]:443 ssl http2;
        server_name rocketchat.example.com;

        access_log /var/log/nginx/rocketchat_access.log main;
        error_log /var/log/nginx/rocketchat_error.log;

        ssl_certificate /etc/letsencrypt/live/rocketchat.example.com/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/rocketchat.example.com/privkey.pem;
        ssl_trusted_certificate /etc/letsencrypt/live/rocketchat.example.com/chain.pem;
        ssl_dhparam /etc/ssl/certs/dhparam.pem;
        ssl_protocols TLSv1.2 TLSv1.3;
        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_prefer_server_ciphers on;
        ssl_session_cache shared:SSL:20m;
        ssl_session_tickets off;
        ssl_session_timeout 180m;
        ssl_stapling on;
        ssl_stapling_verify on;

        location / {
            proxy_pass http://rocketchat.example.com:3000/;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "upgrade";
            proxy_set_header Host $http_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 https;
            proxy_set_header X-Nginx-Proxy true;
            proxy_redirect off;
        }
    }

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Mit der obigen Konfiguration kann Nginx als Proxy-Server fungieren und sich an den Port 3000 auf localhost binden.

Ö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.

Überprüfe die Syntax der Nginx-Konfigurationsdatei.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Starte den Nginx-Dienst neu, um die neue Konfiguration zu aktivieren.

$ sudo systemctl restart nginx

Schritt 7 – Aufrufen und Konfigurieren von RocketChat

Starte die URL https://rocketchat.example.com in deinem Browser und du wirst mit dem folgenden Einrichtungsbildschirm begrüßt.

Rocket Chat Setup Bildschirm

Gib deine Administratorendaten ein und klicke auf die Schaltfläche Weiter, um fortzufahren. Als Nächstes wirst du aufgefordert, deine Organisationsdaten einzugeben.

Rocket Chat Organisation einrichten

Gib die Daten deiner Organisation ein und klicke auf die Schaltfläche Weiter, um fortzufahren. Du wirst aufgefordert, deinen Chatserver bei Rocket Cloud zu registrieren, wenn du Zugang zu den Marktplatz-Apps und weiteren Funktionen haben möchtest.

Rocket Chat Cloud Registrierung

Fülle die Details aus und klicke auf Registrieren, wenn du daran interessiert bist. Andernfalls klickst du auf den Link Als eigenständige Anwendung fortfahren, um fortzufahren. Wenn du dich bei Cloud registriert hast, wird dir eine Bestätigungsmail geschickt.

Rocket Chat Verifizierungsbildschirm

Klicke auf den Link in der Bestätigungsmail, um deine Anmeldung zu bestätigen.

Rocket Chat Verifizierungsmail

Nach der Verifizierung wirst du zum Rocket Chat Dashboard weitergeleitet.

Rocket Chat Dashboard

SMTP-Einstellungen konfigurieren

Rufe die Verwaltungsseite auf, indem du auf dein Profilbild oben links auf der Seite klickst und dann auf den Link Verwaltung.

Rocket Chat Profil Menü

Klicke in der linken Seitenleiste auf den Link Einstellungen.

Rocket Chat Einstellungsmenü

Auf der Einstellungsseite gibst du E-Mail in das Suchfeld ein, um die Schaltfläche E-Mail aufzurufen.

Rocket Chat E-Mail Einstellungen Schaltfläche

Klicke auf die Schaltfläche Öffnen unter dem Abschnitt E-Mail, um die Seite mit den E-Mail-Einstellungen zu öffnen. Erweitere auf der nächsten Seite den SMTP-Abschnitt der Seite.

Rocket Chat SMTP-Einstellungen

Gib die SMTP-Details ein und klicke oben rechts auf die Schaltfläche Änderungen speichern, um die Schaltfläche Eine Testmail an meinen Benutzer senden zu aktivieren. Du wirst aufgefordert, dein Passwort einzugeben, um die SMTP-Einstellungen zu speichern.

Für unser Tutorial verwenden wir Amazon SES als Mailer mit 587 als Port. Deaktiviere die Schaltfläche oberhalb der Schaltfläche Pool. Die Schaltfläche hat die Funktion, TLS zu ignorieren, aber sie ist nicht richtig beschriftet.

Du solltest eine ähnliche Testmail erhalten haben, wenn alles richtig eingerichtet wurde.

Rocket Chat Test E-Mail

Anmeldung bei Rocket.Chat Cloud

Um die Funktionen der Rocket.Chat Cloud nutzen zu können, musst du dich einloggen. Besuche das Menü Verwaltung >> Verbindungsdienste und du wirst mit der folgenden Seite begrüßt.

Rocket Chat Konnektivitätsdienste

Klicke auf die Schaltfläche Anmelden bei Rocket.Chat Cloud, um den Vorgang zu starten. Du wirst zur Anmeldeseite weitergeleitet, auf der du die E-Mail-Adresse eingeben musst, mit der du dich bei der Einrichtung registriert hast.

Rocket.Chat Cloud Anmeldung

Klicke auf den Link Anmeldung senden, um fortzufahren. Du erhältst eine E-Mail mit dem Anmeldelink.

Rocket.Chat Login Link

Klicke auf den Anmeldelink, um den Vorgang abzuschließen. Du wirst aufgefordert, deinen Server zu autorisieren, sich mit dem Cloud-Konto anzumelden.

Rocket.Chat Cloud-Autorisierung

Klicke auf die Schaltfläche Autorisieren, um fortzufahren und zur Seite Connectivity Services zurückzukehren. Du bist jetzt in der Cloud angemeldet.

Rocket Chat Cloud erfolgreich angemeldet

Rocket.Chat Cloud Apps installieren und nutzen

Du kannst jetzt Cloud-Apps über die Seite Verwaltung >> Apps installieren. Wir installieren die GIPHY-App auf unserem Server. Klicke auf die Schaltfläche Get, um mit der Installation fortzufahren.

Rocket Chat Apps Installation

Um die App zu konfigurieren, klickst du auf der Seite Apps auf den Namen der App und rufst die Detailseite der Anwendung auf. Von dort aus kannst du die Einstellungen konfigurieren und die App nutzen.

Rocket Chat Giphy App Einstellungen

Fülle die Einstellungen aus und klicke auf die Schaltfläche Änderungen speichern, um die Einrichtung der Anwendung abzuschließen.

Gehe zurück zum Rocket Chat Dashboard und besuche das Message Board. Um die GIPHY-App zu nutzen, gib /giphy <search term> ein und du wirst eine Menge GIFs zu deiner Frage sehen.

Rocket Chat GIPHY Suche

Drücke die Eingabetaste, um das GIF an den Nachrichtenbildschirm zu senden.

Rocket Chat Nachricht GIF

Schritt 8 – Rocket Chat sichern und wiederherstellen

Für die Sicherung von Rocket Chat musst du die MongoDB-Datenbank sichern.

Halte den Docker-Container an.

$ docker compose down

Führe den folgenden Befehl aus, um das Label des MongoDB-Docker-Images auszulesen.

$ docker ps -a

Für unser Tutorial lautet das Label des MongoDB-Images rocketchat_mongo_1. Führe den folgenden Befehl aus, um die Datenbank in eine Datei zu exportieren.

$ docker exec rocketchat_mongo_1 sh -c 'mongodump --archive' > db.dump

Um die Datenbank wiederherzustellen, verwende den folgenden Befehl.

$ docker exec -i <database_name> sh -c 'mongorestore --archive' < db.dump

Schritt 9 – Upgrade von Rocket Chat

Für das Upgrade von Rocket Chat musst du einige Befehle befolgen. Die Daten werden durch den Upgrade-Prozess nicht beeinflusst. Ziehe die neueste Version des Rocket Chat-Images.

$ docker pull registry.rocket.chat/rocketchat/rocket.chat:latest

Stoppe den bestehenden Bucket.

$ docker compose stop rocketchat

Entferne den bestehenden Container.

$ docker compose rm rocketchat

Starten Sie Rocket Chat, indem Sie einen neuen Container erstellen.

$ docker compose up -d rocketchat

Fazit

Damit ist unsere Anleitung zur Installation des Rocket.Chat-Servers auf einem Rocky Linux 8 Rechner abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.

Das könnte dich auch interessieren …