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.comverwenden. - 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:AmazonSESKey@email-smtp.us-west-2.amazonaws.com: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 name@example.com -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.
Gib deine Administratorendaten ein und klicke auf die Schaltfläche Weiter, um fortzufahren. Als Nächstes wirst du aufgefordert, deine Organisationsdaten einzugeben.
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.
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.
Klicke auf den Link in der Bestätigungsmail, um deine Anmeldung zu bestätigen.
Nach der Verifizierung wirst du zum Rocket Chat Dashboard weitergeleitet.
SMTP-Einstellungen konfigurieren
Rufe die Verwaltungsseite auf, indem du auf dein Profilbild oben links auf der Seite klickst und dann auf den Link Verwaltung.
Klicke in der linken Seitenleiste auf den Link Einstellungen.
Auf der Einstellungsseite gibst du E-Mail in das Suchfeld ein, um die Schaltfläche E-Mail aufzurufen.
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.
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.
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.
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.
Klicke auf den Link Anmeldung senden, um fortzufahren. Du erhältst eine E-Mail mit dem Anmeldelink.
Klicke auf den Anmeldelink, um den Vorgang abzuschließen. Du wirst aufgefordert, deinen Server zu autorisieren, sich mit dem Cloud-Konto anzumelden.
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 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.
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.
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.
Drücke die Eingabetaste, um das GIF an den Nachrichtenbildschirm zu senden.
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.