So installierst und verwendest du Apache Guacamole Remote Desktop unter Rocky Linux 8

Apache Guacamole ist ein kostenloses, quelloffenes, clientloses Remote-Desktop-Gateway. Es unterstützt Standardprotokolle wie SSH, RDP und VNC. Es benötigt keine Plugins und Clients von Drittanbietern, um zu funktionieren. Du kannst über ein webbasiertes Gateway auf deinen Rechner zugreifen. Es kann hinter einen Proxy-Server gestellt werden, so dass du von überall auf der Welt auf deine Server zugreifen kannst.

Guacamole setzt sich aus zwei Komponenten zusammen:

  • guacamole-server guacd ist der Proxy-Daemon, der auf dem Guacamole-Server läuft, Benutzerverbindungen annimmt und sie dann mit den entfernten Desktops verbindet.
  • guacamole-client enthält alle Java- und Javascript-Komponenten von Guacamole, aus denen die Webanwendung besteht, mit der sich die Nutzer mit ihren Desktops verbinden können.

In diesem Lernprogramm lernst du, wie du Apache Guacamole auf einem Rocky Linux 8 basierten Server installierst und benutzt. Außerdem lernst du, wie du damit eine Verbindung zu einem Remote-Desktop herstellen kannst. Wir werden Guacamole installieren, indem wir den Quellcode verwenden.

Voraussetzungen

  • Ein Server mit Rocky Linux 8 mit mindestens 2 GB RAM und 2 CPU-Kernen.
  • Ein Domainname für den Helpdesk, der auf den Server zeigt. Für unser Tutorial werden wir die Domain uvdesk.example.com verwenden.
  • Einen nicht-root-basierten Benutzer mit sudo-Rechten.
  • Stelle sicher, dass alles auf dem neuesten Stand ist.
    $ 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

Lasse HTTP- und HTTPS-Ports zu.

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

Überprüfe erneut den Status der Firewall.

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

Du solltest eine ähnliche Ausgabe sehen.

cockpit dhcpv6-client http https ssh

Lade die Firewall neu, um die Änderungen zu aktivieren.

$ sudo firewall-cmd --reload

Schritt 2 – Bibliotheken installieren

Bevor wir die Bibliotheken installieren, müssen wir das EPEL-Repository installieren und das PowerTools-Repository aktivieren.

$ sudo dnf install epel-release -y
$ sudo dnf config-manager --set-enabled powertools

Der erste Schritt ist die Installation der Bibliotheken, die für die Erstellung von Guacamole benötigt werden. Installiere die benötigten Bibliotheken.

$ sudo dnf install cairo-devel libjpeg-turbo-devel libjpeg-devel libpng-devel libtool libuuid-devel uuid-devel make cmake

Die oben genannten Abhängigkeiten sind Pflichtbibliotheken, d.h. ohne sie kann Guacamole nicht gebaut werden. Du kannst einige optionale Abhängigkeiten installieren, um die Unterstützung für verschiedene Protokolle und Funktionen hinzuzufügen.

Zuerst musst du jedoch das RPMFusion Free Repository aktivieren, da es das Paket ffmpeg-devel enthält.

$ sudo dnf install --nogpgcheck https://mirrors.rpmfusion.org/free/el/rpmfusion-free-release-8.noarch.rpm

Installiere die optionalen Abhängigkeiten.

$ sudo dnf install ffmpeg-devel freerdp-devel pango-devel libssh2-devel libtelnet-devel libvncserver-devel libwebsockets-devel pulseaudio-libs-devel openssl-devel compat-openssl10 libvorbis-devel libwebp-devel libgcrypt-devel

Schritt 3 – Apache Tomcat installieren

Für unser Tutorial werden wir Apache Tomcat 9 installieren, der Java 8 und höher benötigt, um zu funktionieren.

Java installieren

Wir werden OpenJDK 11 installieren, die Open-Source-Implementierung der Java-Plattform.

Führe den folgenden Befehl aus, um OpenJDK zu installieren.

$ sudo dnf install java-11-openjdk-devel

Überprüfe die Installation.

$ java -version
openjdk 11.0.14 2022-01-18 LTS
OpenJDK Runtime Environment 18.9 (build 11.0.14+9-LTS)
OpenJDK 64-Bit Server VM 18.9 (build 11.0.14+9-LTS, mixed mode, sharing)

Tomcat-Benutzer anlegen

Als Nächstes legst du einen Benutzer für den Tomcat-Dienst an. Wir legen /opt/tomcat als Home-Verzeichnis fest.

$ sudo useradd -m -U -d /opt/tomcat -s /bin/false tomcat

Tomcat herunterladen

Die neueste Version von Tomcat v10 kannst du von der Download-Seite herunterladen. Zum Zeitpunkt der Erstellung dieses Tutorials ist v9.0.59 die neueste verfügbare Version. Überprüfe die neueste Version, bevor du Tomcat herunterlädst.

Verwende wget, um Tomcat herunterzuladen.

$ TVERSION=9.0.59
$ wget https://dlcdn.apache.org/tomcat/tomcat-9/v${TVERSION}/bin/apache-tomcat-${TVERSION}.tar.gz

Entpacke die Datei in das Verzeichnis /opt/tomcat.

$ sudo tar -xf apache-tomcat-${TVERSION}.tar.gz --strip-components=1 -C /opt/tomcat/

Ändere die Eigentümerschaft des Verzeichnisses auf den Tomcat-Benutzer.

$ sudo chown -R tomcat:tomcat /opt/tomcat

Erstelle eine Systemd Unit-Datei und starte Tomcat

Erstelle und öffne die Datei /etc/systemd/system/tomcat.service zur Bearbeitung.

$ sudo nano /etc/systemd/system/tomcat.service

Füge den folgenden Code ein.

[Unit]
Description=Apache Tomcat 9 Servlet container
Wants=network.target
After=network.target

[Service]
Type=forking
User=tomcat
Group=tomcat

Environment="JAVA_HOME=/usr/lib/jvm/jre"
Environment="JAVA_OPTS=-Djava.awt.headless=true"
Environment="CATALINA_BASE=/opt/tomcat"
Environment="CATALINA_HOME=/opt/tomcat"
Environment="CATALINA_PID=/opt/tomcat/temp/tomcat.pid"
Environment="CATALINA_OPTS=-Xms512M -Xmx1024M -server -XX:+UseParallelGC"

ExecStart=/opt/tomcat/bin/startup.sh
ExecStop=/opt/tomcat/bin/shutdown.sh
Restart=always

[Install]
WantedBy=multi-user.target

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

Starte den Service Daemon neu, um den Tomcat-Dienst zu aktivieren.

$ sudo systemctl daemon-reload

Aktiviere und starte den Tomcat-Dienst.

$ sudo systemctl enable tomcat --now

Überprüfe den Status des Dienstes.

$ sudo systemctl status tomcat
? tomcat.service - Apache Tomcat 9 Servlet container
   Loaded: loaded (/etc/systemd/system/tomcat.service; enabled; vendor preset: disabled)
   Active: active (running) since Wed 2022-03-09 09:48:38 UTC; 8s ago
  Process: 25308 ExecStart=/opt/tomcat/bin/startup.sh (code=exited, status=0/SUCCESS)
 Main PID: 25315 (java)
    Tasks: 29 (limit: 11412)
   Memory: 154.9M
   CGroup: /system.slice/tomcat.service
           ??25315 /usr/lib/jvm/jre/bin/java -Djava.util.logging.config.file=/opt/tomcat/conf/logging.properties ..

Mar 09 09:48:38 guacamole systemd[1]: Starting Apache Tomcat 9 Servlet container...
Mar 09 09:48:38 guacamole systemd[1]: Started Apache Tomcat 9 Servlet container.

Schritt 4 – Herunterladen und Erstellen von Guacamole

Du kannst die neueste stabile Version von Guacamole von der Website herunterladen. Zum Zeitpunkt der Erstellung dieses Tutorials war die letzte verfügbare Version 1.4.0. Lade den Quellcode von Guacamole herunter.

$ GVERSION=1.4.0
$ wget https://downloads.apache.org/guacamole/${GVERSION}/source/guacamole-server-${GVERSION}.tar.gz

Entpacke das Archiv und wechsle in das neu erstellte Verzeichnis.

$ tar -xzf guacamole-server-${GVERSION}.tar.gz
$ cd guacamole-server-${GVERSION}/

Führe den Befehl configure aus, um festzustellen, welche Bibliotheken verfügbar sind, und um Komponenten zum Bauen auszuwählen.

$ ./configure --with-systemd-dir=/etc/systemd/system/

In das Verzeichnis /etc/systemd/system/ wird während des Build-Prozesses das Startup-Skript installiert, um Guacamole so zu konfigurieren, dass es beim Booten automatisch startet.

Bei erfolgreichem Abschluss erhältst du die folgende Ausgabe.

checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
...

------------------------------------------------
guacamole-server version 1.4.0
------------------------------------------------

   Library status:

     freerdp2 ............ yes
     pango ............... yes
     libavcodec .......... yes
     libavformat.......... yes
     libavutil ........... yes
     libssh2 ............. yes
     libssl .............. yes
     libswscale .......... yes
     libtelnet ........... yes
     libVNCServer ........ yes
     libvorbis ........... yes
     libpulse ............ yes
     libwebsockets ....... yes
     libwebp ............. yes
     wsock32 ............. no

   Protocol support:

      Kubernetes .... yes
      RDP ........... yes
      SSH ........... yes
      Telnet ........ yes
      VNC ........... yes

   Services / tools:

      guacd ...... yes
      guacenc .... yes
      guaclog .... yes

   FreeRDP plugins: /usr/lib64/freerdp2
   Init scripts: no
   Systemd units: /etc/systemd/system/

Type "make" to compile guacamole-server.

Wenn du einige Bibliotheken nicht installiert hast, siehst du in der Ausgabe no statt yes. Wenn jedoch eine wichtige Bibliothek fehlt, schlägt der Befehl fehl. Um zu prüfen, ob weitere configure-Optionen vorhanden sind, führe den Befehl ./configure --help aus.

Kompiliere und installiere den Guacamole-Server mit den folgenden Befehlen.

$ make && sudo make install

Führe den folgenden Befehl aus, um den Cache des Systems mit den installierten Bibliotheken zu aktualisieren.

$ sudo ldconfig

Lade den Service Daemon neu.

$ sudo systemctl daemon-reload

Aktiviere und starte den Guacamole-Dienst.

$ sudo systemctl enable guacd --now

Überprüfe den Status des Dienstes.

$ sudo systemctl status guacd
? guacd.service - Guacamole Server
   Loaded: loaded (/etc/systemd/system/guacd.service; enabled; vendor preset: disabled)
   Active: active (running) since Thu 2022-03-10 09:13:41 UTC; 7s ago
     Docs: man:guacd(8)
 Main PID: 85349 (guacd)
    Tasks: 1 (limit: 11181)
   Memory: 10.8M
   CGroup: /system.slice/guacd.service
           ??85349 /usr/local/sbin/guacd -f

Mar 10 09:13:41 guacamole systemd[1]: Started Guacamole Server.
Mar 10 09:13:41 guacamole guacd[85349]: Guacamole proxy daemon (guacd) version 1.4.0 started
Mar 10 09:13:41 guacamole guacd[85349]: guacd[85349]: INFO:        Guacamole proxy daemon (guacd) version 1.4.0 started
Mar 10 09:13:41 guacamole guacd[85349]: guacd[85349]: INFO:        Listening on host ::1, port 4822
Mar 10 09:13:41 guacamole guacd[85349]: Listening on host ::1, port 4822

Schritt 5 – Guacamole Client installieren

Nachdem du den Server installiert hast, ist der nächste Schritt die Installation des Clients.

Erstelle das Konfigurationsverzeichnis für Guacamole.

$ sudo mkdir /etc/guacamole

Anders als der Guacamole-Server ist der Guacamole-Client als Quellcode und als Binärdatei erhältlich. Für unser Tutorial werden wir die Binärdatei herunterladen. Du kannst den Client aber auch aus dem Quellcode erstellen.

Lade die Guacamole-Client-Binärdatei von der Website herunter.

$ sudo wget https://downloads.apache.org/guacamole/${GVERSION}/binary/guacamole-${GVERSION}.war -O /etc/guacamole/guacamole.war

Mit dem obigen Befehl wird die Guacamole-Binärdatei heruntergeladen und in das Verzeichnis /etc/guacamole kopiert.

Damit der Client funktioniert, muss er aus dem Tomcat-Verzeichnis $CATALINA_HOME/webapps/ bereitgestellt werden. In Schritt 3 haben wir /opt/tomcat als $CATALINA_HOME festgelegt.

Führe den folgenden Befehl aus, um einen symbolischen Link von /etc/guacamole/guacamole.war zum Tomcat-Verzeichnis für Webapps zu erstellen.

$ sudo ln -s /etc/guacamole/guacamole.war /opt/tomcat/webapps/

Ändere die Berechtigung der App auf tomcat Benutzer.

$ sudo chown -R tomcat:tomcat /opt/tomcat/webapps

Erstelle die Konfigurationsdatei der Webanwendung unter /etc/guacamole/guacd.conf.

$ sudo nano /etc/guacamole/guacd.conf

Füge den folgenden Code in die Datei ein. Ersetze your_server_IP durch die öffentliche IP-Adresse deines Servers.

#
# guacd configuration file
#

[daemon]

#pid_file = /var/run/guacd.pid
log_level = info

[server]

bind_host = your_server_IP
bind_port = 4822

#
# The following parameters are valid only if
# guacd was built with SSL support.
#

# [ssl]

# server_certificate = /etc/ssl/certs/guacd.crt
# server_key = /etc/ssl/private/guacd.key

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

Starte den Guacamole-Server und Tomcat neu, um die Änderungen zu übernehmen.

$ sudo systemctl restart tomcat guacd

Schritt 6 – MySQL installieren und konfigurieren

Apache Guacamole bietet verschiedene Arten von Authentifizierungsmethoden an. Für Testzwecke ist eine einfache Passwort-Authentifizierung ausreichend. Aber für Produktionsumgebungen müssen wir eine stärkere und bessere Authentifizierungsmethode implementieren. Hier werden wir eine datenbankbasierte Authentifizierung mit MySQL implementieren.

Installiere MySQL.

$ sudo dnf install mysql-server

Aktiviere und starte den MySQL-Dienst.

$ sudo systemctl enable mysqld --now

Sichere die MySQL-Installation.

$ sudo mysql_secure_installation

Im ersten Schritt wirst du gefragt, ob du das Validate Password Plugin einrichten möchtest, mit dem du die Stärke deines MySQL-Passworts testen kannst. Wähle Y, um fortzufahren. Im nächsten Schritt wirst du aufgefordert, die Stufe der Passwortüberprüfung zu wählen. Wähle 2. Das ist die stärkste Stufe und verlangt, dass dein Passwort mindestens acht Zeichen lang ist und eine Mischung aus Groß- und Kleinbuchstaben, Zahlen und Sonderzeichen enthält.

Securing the MySQL server deployment.

Connecting to MySQL using a blank password.

VALIDATE PASSWORD COMPONENT can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD component?

Press y|Y for Yes, any other key for No: Y

There are three levels of password validation policy:

LOW    Length >= 8
MEDIUM Length >= 8, numeric, mixed case, and special characters
STRONG Length >= 8, numeric, mixed case, special characters and dictionary                  file

Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG: 2

Im nächsten Schritt wirst du aufgefordert, ein Root-Passwort zu wählen. Wähle ein sicheres Passwort, das die Anforderungen des Plugins zur Passwortvalidierung erfüllt. Im nächsten Schritt wirst du gefragt, ob du mit dem gewählten Passwort fortfahren möchtest. Drücke y, um fortzufahren.

Please set the password for root here.

New password:

Re-enter new password:

Estimated strength of the password: 100
Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : Y

Drücke Y und dann ENTER für alle folgenden Aufforderungen, um anonyme Benutzer und die Testdatenbank zu entfernen, Root-Logins zu deaktivieren und die neu festgelegten Regeln zu laden.

...
Remove anonymous users? (Press y|Y for Yes, any other key for No) : Y
Success.
...
Disallow root login remotely? (Press y|Y for Yes, any other key for No) : Y
Success.
...
Remove test database and access to it? (Press y|Y for Yes, any other key for No) : Y
 - Dropping test database...
Success.
 - Removing privileges on test database...
Success.
Reloading the privilege tables will ensure that all changes
made so far will take effect immediately.
...
Reload privilege tables now? (Press y|Y for Yes, any other key for No) : Y
Success.
All done!

Gib die MySQL-Shell ein. Gib dein Root-Passwort ein, um fortzufahren.

$ mysql -u root -p

Erstelle den Benutzer guacamole_user. Vergewissere dich, dass das Passwort den zuvor festgelegten Anforderungen entspricht.

mysql> CREATE USER 'guacamole_user'@'localhost' IDENTIFIED BY 'Your_password2';

Erstelle die Datenbank guacamole_db.

mysql> CREATE DATABASE guacamole_db;

Erteile dem Benutzer die Rechte für die Datenbank guacamole_db.

mysql> GRANT SELECT,INSERT,UPDATE,DELETE ON guacamole_db.* TO 'guacamole_user'@'localhost';

Beende die Shell.

mysql> exit

Schritt 7 – Apache Guacamole konfigurieren

Das Konfigurationsverzeichnis von Guacamole wird durch die Variable GUACAMOLE_HOME definiert. Alle Konfigurationsdateien, Erweiterungen usw. befinden sich in diesem Verzeichnis. In der Datei /etc/guacamole/guacamole.properties werden alle Konfigurationen und Einstellungen für Guacamole und seine Erweiterungen gespeichert.

Erweiterungen und Bibliotheken benötigen zusätzliche Verzeichnisse. Erstelle sie.

$ sudo mkdir /etc/guacamole/{extensions,lib}

Lege die Variable Guacamole home fest und speichere sie in der Konfigurationsdatei /etc/default/tomcat.

$ echo "GUACAMOLE_HOME=/etc/guacamole" | sudo tee -a /etc/default/tomcat

Konfiguriere die Datenbankauthentifizierung von Apache Guacamole

Im vorherigen Schritt haben wir bereits die Datenbank für Guacamole eingerichtet. Um die Konfiguration abzuschließen, müssen wir das Guacamole JDBC Authenticator Plugin und die MySQL Java Connector Bibliothek herunterladen.

Lade das Guacamole JDBC-Plugin von der Website herunter.

$ cd ~
$ wget https://downloads.apache.org/guacamole/${GVERSION}/binary/guacamole-auth-jdbc-${GVERSION}.tar.gz

Entpacke das Plugin in das Verzeichnis /etc/guacamole/extensions.

$ tar -xf guacamole-auth-jdbc-${GVERSION}.tar.gz
$ sudo mv guacamole-auth-jdbc-${GVERSION}/mysql/guacamole-auth-jdbc-mysql-${GVERSION}.jar /etc/guacamole/extensions/

Im nächsten Schritt musst du das SQL-Schema in die MySQL-Datenbank importieren. Wechsle in das entpackte Plugin-Verzeichnis.

$ cd guacamole-auth-jdbc-${GVERSION}/mysql/schema

Importiere die Schemadateien in MySQL.

$ cat *.sql | mysql -u root -p guacamole_db

Lade den MySQL Java Connector herunter. Hol dir die plattformunabhängige Archivdatei. Zum Zeitpunkt der Erstellung dieses Tutorials ist die letzte verfügbare Version 8.0.28.

$ cd ~
$ wget https://dev.mysql.com/get/Downloads/Connector-J/mysql-connector-java-8.0.28.tar.gz

Entpacke das Archiv und kopiere seinen Inhalt in das Verzeichnis /etc/guacamole/lib.

$ tar -xf mysql-connector-java-8.0.28.tar.gz
$ sudo mv mysql-connector-java-8.0.28/mysql-connector-java-8.0.28.jar /etc/guacamole/lib/

Konfiguriere die Guacamole-Eigenschaftendatei

Erstelle die Datei /etc/guacamole/guacamole.properties und öffne sie zur Bearbeitung.

$ sudo nano /etc/guacamole/guacamole.properties

Füge den folgenden Code in die Datei ein. Ersetze your_server_ip durch die öffentliche IP-Adresse deines Servers.

guacd-hostname: your_server_ip
guacd-port:     4822

# MySQL properties
mysql-hostname: localhost
mysql-database: guacamole_db
mysql-username: guacamole_user
mysql-password: Your_password2

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

Verknüpfe das Guacamole-Konfigurationsverzeichnis mit dem Tomcat-Servlet-Verzeichnis.

$ sudo ln -s /etc/guacamole /opt/tomcat/.guacamole

Starte Tomcat neu, um die Datenbankauthentifizierung zu aktivieren. Du brauchst guacd nicht neu zu starten, da es völlig unabhängig von der Webanwendung ist und nichts mit der guacamole.properties oder der Datenbankauthentifizierung zu tun hat.

$ sudo systemctl restart tomcat

Schritt 8 – SSL installieren

Um ein SSL-Zertifikat mit Let’s Encrypt zu installieren, müssen wir das Tool Certbot installieren. Certbot benötigt für die Installation das EPEL-Repository, aber wir können direkt mit der Installation fortfahren, da wir es bereits zuvor installiert haben.

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 guacamole.example.com

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

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

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

Erstelle ein Challenge-Webroot-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 guacamole.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 9 – Installiere und konfiguriere Nginx als Reverse Proxy

Tomcat für die Reverse-Proxy-Verbindung konfigurieren

Bevor wir Nginx installieren, müssen wir Tomcat so konfigurieren, dass er die vom Nginx-Reverse-Proxy bereitgestellte Remote-IP-Adresse durchlässt.

Öffne die Datei /opt/tomcat/conf/server.xml zum Bearbeiten.

$ sudo nano /opt/tomcat/conf/server.xml

Finde die folgende Zeile in der Datei.

<Host name="localhost"  appBase="webapps" 
            unpackWARs="true" autoDeploy="true">

Ändere die Zeile, indem du zusätzlichen Code unterhalb der Zeile einfügst, so dass sie wie folgt aussieht.

<Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">

        <Valve className="org.apache.catalina.valves.RemoteIpValve"
               internalProxies="127.0.0.1"
               remoteIpHeader="x-forwarded-for"
               remoteIpProxiesHeader="x-forwarded-by"
               protocolHeader="x-forwarded-proto" />

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

Nginx installieren

Rocky Linux 8.5 wird mit der neuesten stabilen Version von Nginx ausgeliefert. Installiere sie mit dem folgenden Befehl.

$ sudo dnf module install nginx:1.20

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.20.1

Aktiviere den Nginx-Dienst.

$ sudo systemctl enable nginx

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

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

Füge den folgenden Code in die Datei ein.

server {
    listen       443 ssl http2;
    listen       [::]:443 ssl http2;
    server_name  guacamole.example.com;

    access_log  /var/log/nginx/guacamole.access.log;
    error_log   /var/log/nginx/guacamole.error.log;
    
    # SSL
    ssl_certificate      /etc/letsencrypt/live/guacamole.example.com/fullchain.pem;
    ssl_certificate_key  /etc/letsencrypt/live/guacamole.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/guacamole.example.com/chain.pem;
    ssl_session_timeout  5m;
    ssl_session_cache shared:MozSSL:10m;
    ssl_session_tickets off;
    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;
    resolver 8.8.8.8;

    location / {
      proxy_pass http://127.0.0.1:8080/guacamole/;
      proxy_buffering off;
      proxy_http_version 1.1;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection $http_connection;
      client_max_body_size 1g;
      access_log off;
  }
}
# enforce HTTPS
server {
    listen       80;
    listen       [::]:80;
    server_name  guacamole.example.com;
    return 301   https://$host$request_uri;
}

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

Öffne die Datei /etc/nginx/nginx.conf und bearbeite sie.

$ 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

Ändere die SELinux-Berechtigung, damit Nginx Netzwerkverbindungen herstellen kann.

$ sudo setsebool -P httpd_can_network_connect 1

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

$ sudo systemctl start nginx

Starte den Tomcat-Server neu, um die Konfigurationsänderung zu übernehmen.

$ sudo systemctl restart tomcat

Schritt 10 – Zugriff auf Guacamole

Öffne die URL https://guacamole.example.com in deinem Browser und du wirst mit dem folgenden Bildschirm begrüßt.

Guacamole Admin Bildschirm

Gib guacadmin als Benutzernamen und guacadmin als Passwort ein und klicke auf Anmelden, um fortzufahren.

Einen neuen Admin-Benutzer erstellen

Aus Sicherheitsgründen solltest du einen neuen Benutzer anlegen und den bestehenden Benutzer löschen. Dazu klickst du oben rechts auf guacadmin und wählst im Dropdown-Menü das Menü Einstellungen.

Guacamole Web App Einstellungen

Wechsle zur Registerkarte Benutzer und klicke auf die Schaltfläche Neuer Benutzer, um loszulegen.

Guacamole Neuer Benutzer

Gib deine Daten ein und setze ein Häkchen bei allen Berechtigungen.

Klicke auf Speichern, wenn du fertig bist. Melde den Benutzer guacadmin ab und melde dich mit dem neu angelegten Benutzer wieder an.

Wähle den Benutzer guacadmin aus, den du bearbeiten möchtest, und klicke unten auf die Schaltfläche Löschen, um den Benutzer zu löschen.

Schritt 11 – Wie man Guacamole benutzt

In unserem Tutorial zeigen wir dir, wie du dich über das SSH-Protokoll mit einem Server verbinden kannst.

Gehe in das Menü Einstellungen von Guacamole und wähle Verbindungen. Unter dem Bildschirm Verbindungen klickst du auf die Schaltfläche Neue Verbindung.

Guacamole Neue Verbindung

Wähle einen Namen für die Verbindung und wähle SSH als Protokoll aus dem Dropdown-Menü.

Guacamole SSH Verbindungstyp

Im Bereich Parameter gibst du die IP-Adresse deines Servers als Hostname, 22 als Port (oder, wenn du einen eigenen SSH-Port hast, diesen) und deinen Benutzernamen ein. Wenn du eine passwortbasierte Authentifizierung verwendest, gib das Passwort des Benutzers ein oder füge den privaten Schlüssel ein. Gib die Passphrase für den privaten Schlüssel ein, wenn du ihn verwendest.

Guacamole SSH Parameter

Wenn du zusätzliche Einstellungen vornehmen möchtest, tue dies. Klicke auf Speichern, um das Hinzufügen der Verbindung abzuschließen.

Gehe zurück zum Dashboard und klicke auf den Namen der Verbindung unter Alle Verbindungen, um zum SSH-Terminal zu gelangen.

Guacamole SSH Terminal

Fazit

Damit ist unsere Anleitung zur Installation und Verwendung von Apache Guacamole zur Erstellung einer SSH-Verbindung auf einem Rocky Linux 8 basierten Server abgeschlossen. Wenn du Fragen hast, kannst du sie unten in den Kommentaren stellen.

Das könnte dich auch interessieren …