So installierst du die Projektmanagement-Software Redmine auf Rocky Linux 8

Redmine ist eine kostenlose und quelloffene Projektmanagementsoftware und ein Tool zur Fehlerverfolgung. Es wurde mit dem Ruby on Rails Framework geschrieben und kann in verschiedene Versionskontrollsysteme integriert werden. Es enthält einen Repository-Browser und einen Diff-Viewer. Es kann für die Verwaltung von Projekten, Wikis und Foren, Zeiterfassung und rollenbasierte Zugriffskontrolle verwendet werden. Es ist plattform- und datenbankübergreifend und unterstützt 49 Sprachen.

In diesem Lernprogramm lernst du, wie du Redmine auf einem Rocky Linux 8 basierten Server installierst.

Voraussetzungen

  • Ein Server, auf dem Rocky Linux läuft.
  • Ein Nicht-Sudo-Benutzer mit Root-Rechten.
  • Deaktiviere SELinux.
  • Alles ist auf dem neuesten Stand.
    $ sudo dnf update
    

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

Öffne Port 3000, über den wir Redmine überprüfen können.

$ sudo firewall-cmd --permanent --add-port=3000

Lasse HTTP- und HTTPS-Ports zu.

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

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

$ sudo firewall-cmd --reload

Schritt 2 – Apache Server installieren

Wir werden den Apache Webserver verwenden, um Redmine einzusetzen. Installiere Apache mit dem folgenden Befehl.

$ sudo dnf install httpd

Aktiviere und starte den Apache-Dienst.

$ sudo systemctl enable --now httpd.service

Erteile deinem aktuell angemeldeten Benutzer den Apache-Benutzer, damit er den nötigen Zugriff auf das Verzeichnis /var/www/redmine hat.

$ sudo usermod -aG $USER apache

Schritt 3 – Installiere und konfiguriere den MySQL-Server

Wir werden eine MySQL-Datenbank verwenden, um die Daten zu speichern. Das Appstream-Repository von Rocky Linux wird mit der neuesten Version von MySQL ausgeliefert.

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 redmine. Vergewissere dich, dass das Passwort den zuvor festgelegten Anforderungen entspricht.

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

Erstelle die Datenbank redmine.

mysql> CREATE DATABASE redmine CHARACTER SET utf8mb4;

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

mysql> GRANT ALL PRIVILEGES ON redmine.* TO 'redmine'@'localhost';

Beende die Shell.

mysql> exit

Schritt 4 – EPEL-Repository installieren

Einige der Pakete, die für Redmine benötigt werden, sind im EPEL-Repository verfügbar. Führe den folgenden Befehl aus, um das EPEL-Repository zu installieren.

$ sudo dnf install epel-release

Aktiviere das PowerTools-Repository.

$ sudo dnf config-manager --set-enabled powertools

Schritt 5 – Installiere Ruby und andere Voraussetzungen

Rocky Linux 8 wird mit vier verschiedenen Versionen von Ruby ausgeliefert – 2.5, 2.6, 2.7 und 3.0.

Hier findest du eine Liste aller verfügbaren Ruby-Module.

$ dnf module list ruby
Last metadata expiration check: 0:18:58 ago on Mon 03 Jan 2022 11:50:10 AM UTC.
Rocky Linux 8 - AppStream
Name            Stream             Profiles              Summary
ruby            2.5 [d]            common [d]            An interpreter of object-oriented scripting language
ruby            2.6                common [d]            An interpreter of object-oriented scripting language
ruby            2.7                common [d]            An interpreter of object-oriented scripting language
ruby            3.0                common [d]            An interpreter of object-oriented scripting language

Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled

Die neueste Version von Redmine ist mit jeder Version außer 3.0 kompatibel. Für unseren Lehrgang werden wir Ruby 2.7 installieren.

Setze andere Versionen zurück und aktiviere die 2.7er Version von Ruby.

$ sudo dnf module reset ruby
$ sudo dnf module enable ruby:2.7

Installiere Ruby.

$ sudo dnf install ruby ruby-devel

Überprüfe die Installation.

$ ruby -v
ruby 2.7.4p191 (2021-07-07 revision a21a3b7d23) [x86_64-linux]

Installiere alle übrigen Pakete, die für Redmine benötigt werden.

$ sudo dnf install rpm-build wget libxml2-devel make automake libtool ImageMagick ImageMagick-devel mariadb-devel httpd-devel openssl-devel libcurl-devel gcc gcc-c++

Schritt 6 – Installiere Redmine

Besuche die Downloadseite von Redmine und überprüfe die letzte verfügbare stabile Version. Zum Zeitpunkt der Erstellung dieses Tutorials ist die neueste Version 4.2.3 verfügbar.

Verwende wget, um Redmine herunterzuladen.

$ wget https://redmine.org/releases/redmine-4.2.3.tar.gz

Entpacke die Dateien und verschiebe sie in das Verzeichnis /var/www/redmine.

$ tar xfz redmine-4.2.3.tar.gz
$ sudo mv redmine-4.2.3 /var/www/redmine

Wechsle in das Verzeichnis /var/www/redmine.

$ cd /var/www/redmine

Erstelle Redmine-Konfigurationsdateien mit Hilfe der mitgelieferten Beispieldateien.

$ cp config/configuration.yml.example config/configuration.yml
$ cp config/database.yml.example config/database.yml
$ cp public/dispatch.fcgi.example public/dispatch.fcgi

Öffne die Datei database.yml zur Bearbeitung.

$ nano config/database.yml

Finde deine Datenbankeinstellungen unter dem folgenden Abschnitt und konfiguriere sie.

production:
  adapter: mysql2
  database: redmine
  host: localhost
  username: redmine
  password: "Your_password2"
  # Use "utf8" instead of "utfmb4" for MySQL prior to 5.7.7
  encoding: utf8mb4

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

Installiere Bundler für die Verwaltung von Ruby Gem-Abhängigkeiten.

$ gem install bundler

Richte die Umgebung für die Installation von Gem-Abhängigkeiten ein.

$ bundle config set --local without 'development test'

Installiere die Gem-Abhängigkeiten.

$ bundle install

Wenn du Probleme mit Gem-Versionen hast, kannst du sie mit dem folgenden Befehl wiederherstellen.

$ sudo gem pristine --all

Erstelle einen zufälligen geheimen Schlüssel, um zu verhindern, dass die Cookies zur Speicherung der Sitzungsdaten manipuliert werden.

$ bundle exec rake generate_secret_token

Erstelle die Datenbankstruktur.

$ RAILS_ENV=production bundle exec rake db:migrate

Füge die Daten in die MySQL-Datenbank ein.

$ RAILS_ENV=production REDMINE_LANG=en bundle exec rake redmine:load_default_data

Erstelle die notwendigen Verzeichnisse und lege die Dateiberechtigungen fest.

$ mkdir -p tmp/pdf
$ mkdir -p public/plugin_assets
$ chown -R $USER:$USER files log tmp public/plugin_assets
$ chmod -R 755 /var/www/remine/

Führe den folgenden Befehl aus, um eine Rails-Serverinstanz zu starten.

$ bundle exec rails server webrick -e production
=> Booting WEBrick
=> Rails 5.2.6 application starting in production on http://0.0.0.0:3000
=> Run `rails server -h` for more startup options
[2022-01-03 12:58:19] INFO  WEBrick 1.6.1
[2022-01-03 12:58:19] INFO  ruby 2.7.4 (2021-07-07) [x86_64-linux]
[2022-01-03 12:58:19] INFO  WEBrick::HTTPServer#start: pid=117224 port=3000

Öffne die URL http://<yourserverIP>:3000/login, um den Redmine-Anmeldebildschirm zu erhalten.

Redmine Login Screen

Gib die Standard-Anmeldedaten(admin/admin) ein, um dich anzumelden. Du wirst aufgefordert, das Passwort zu ändern.

Redmine Passwort ablaufen Bildschirm

Anschließend wirst du auf die Seite Mein Konto weitergeleitet.

Redmine Mein Konto

Redmine wurde erfolgreich installiert.

Als Nächstes drückst du STRG+C auf dem Terminal, um den Server zu beenden.

Schritt 7 – Phusion Passenger installieren

Phusion Passenger ist ein Ruby-Anwendungsserver, mit dem wir Redmine über einen Drittanbieter-Server bereitstellen können. In unserem Fall werden wir Apache verwenden.

Installiere Passenger.

$ gem install passenger

Installiere das Passenger-Modul für den Apache-Server.

$ passenger-install-apache2-module

Du wirst mit einer Willkommensnachricht begrüßt. Drücke Enter, um fortzufahren.

Welcome to the Phusion Passenger Apache 2 module installer, v6.0.12.

This installer will guide you through the entire installation process. It
shouldn't take more than 3 minutes in total.

Here's what you can expect from the installation process:

 1. The Apache 2 module will be installed for you.
 2. You'll learn how to configure Apache.
 3. You'll learn how to deploy a Ruby on Rails application.

Don't worry if anything goes wrong. This installer will advise you on how to
solve any problems.

Press Enter to continue, or Ctrl-C to abort.


--------------------------------------------

Als nächstes wirst du nach der Sprache gefragt. Ruby ist standardmäßig ausgewählt, also drücke einfach Enter, um fortzufahren.

Which languages are you interested in?

Use <space> to select.
If the menu doesn't display correctly, press '!'

 ? ?  Ruby
   ?  Python
   ?  Node.js
   ?  Meteor

--------------------------------------------

Möglicherweise erhältst du eine Warnung bezüglich der Dateiberechtigungen. Wenn du unserem Tutorial gefolgt bist, drückst du einfach Enter, um fortzufahren.

Warning: some directories may be inaccessible by the web server!

The web server typically runs under a separate user account for security
reasons. That user must be able to access the Phusion Passenger(R) files.
However, it appears that some directories have too strict permissions. This
may prevent the web server user from accessing Phusion Passenger(R) files.

It is recommended that you relax permissions as follows:

  sudo chmod o+x "/home/navjot"

Press Ctrl-C to return to the shell. (Recommended)
After relaxing permissions, re-run this installer.
  -OR-
Press Enter to continue anyway.

Der gesamte Vorgang wird etwa 10-15 Minuten dauern, bis er abgeschlossen ist. Wenn du eine Fehlermeldung wie die folgende bekommst, liegt das höchstwahrscheinlich an zu wenig RAM. Du solltest entweder den Arbeitsspeicher deines Servers erhöhen oder Swap Space installieren.

c++: fatal error: Killed signal terminated program cc1plus
compilation terminated.
rake aborted!

Sobald der Vorgang abgeschlossen ist, bekommst du die folgende Meldung.

--------------------------------------------
Almost there!

Please edit your Apache configuration file, and add these lines:

   LoadModule passenger_module /home/navjot/.gem/ruby/gems/passenger-6.0.12/buildout/apache2/mod_passenger.so
   <IfModule mod_passenger.c>
     PassengerRoot /home/navjot/.gem/ruby/gems/passenger-6.0.12
     PassengerDefaultRuby /usr/bin/ruby
   </IfModule>

After you restart Apache, you are ready to deploy any number of web
applications on Apache, with a minimum amount of configuration!

Press ENTER when you are done editing.

Drücke noch nicht die Eingabetaste. Öffne eine neue Sitzung auf deinem Server als aktueller Benutzer und führe die folgenden Konfigurationen durch.

Apache Server konfigurieren

Erstelle eine Apache-Modulkonfigurationsdatei für Phusion Passenger.

$ sudo nano /etc/httpd/conf.modules.d/00-passenger.conf

Füge den Code ein, den du am Ende der Passenger-Installation erhalten hast.

 LoadModule passenger_module /home/navjot/.gem/ruby/gems/passenger-6.0.12/buildout/apache2/mod_passenger.so
   <IfModule mod_passenger.c>
     PassengerRoot /home/username/.gem/ruby/gems/passenger-6.0.12
     PassengerDefaultRuby /usr/bin/ruby
   </IfModule>

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

Erstelle eine weitere Apache-Konfigurationsdatei für die Redmine-Site.

$ sudo nano /etc/httpd/conf.d/redmine.conf

Füge den folgenden Code in diese Datei ein.

Listen 3000
<IfModule mod_passenger.c>
  PassengerRoot /home/username/.gem/ruby/gems/passenger-6.0.12
  PassengerDefaultRuby /usr/bin/ruby
</IfModule>
<VirtualHost *:3000>
    ServerName redmine.example.com
    DocumentRoot "/var/www/redmine/public" 

    CustomLog logs/redmine_access.log combined
    ErrorLog logs/redmine_error_log
    LogLevel warn

    <Directory "/var/www/redmine/public">
        Options Indexes ExecCGI FollowSymLinks
        Require all granted
        AllowOverride all
    </Directory>
</VirtualHost>

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

Öffne die Haupt-Apache-Konfigurationsdatei /etc/httpd/conf/httpd.conf zum Bearbeiten.

$ sudo nano /etc/httpd/conf/httpd.conf

Suche die Variable ServerName und entferne die Raute (#) davor und setze ihren Wert wie folgt.

ServerName localhost

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

Überprüfe deine Apache-Konfiguration.

$ httpd -t
Syntax OK

Gehe zurück und drücke die Eingabetaste, um die Installation von Passenger fortzusetzen. Es werden einige Prüfungen durchgeführt und du solltest die folgende Meldung sehen, wenn die Prüfung erfolgreich abgeschlossen ist.

Deploying a web application

To learn how to deploy a web app on Passenger, please follow the deployment
guide:

  https://www.phusionpassenger.com/library/deploy/apache/deploy/

Enjoy Phusion Passenger, a product of Phusion® (www.phusion.nl) :-)
https://www.phusionpassenger.com

Passenger® is a registered trademark of Phusion Holding B.V.

Starte deinen Apache-Server neu.

$ sudo systemctl restart httpd

Deine Website sollte nun unter http://redmine.example.com:3000 erreichbar sein.

Dies ist nicht der perfekte Weg, um auf Redmine zuzugreifen. Sie wird immer noch über das unsichere HTTP-Protokoll bedient und verwendet eine Portnummer. Um dies zu verbessern, werden wir Nginx installieren, das als Reverse Proxy fungiert und Redmine über das HTTPS-Protokoll bereitstellt. Bevor wir mit der Installation und Konfiguration von Nginx beginnen, müssen wir das SSL-Zertifikat einrichten.

Schritt 8 – SSL installieren

Um ein SSL-Zertifikat mit Let’s Encrypt zu installieren, müssen wir das Tool Certbot installieren. Führe die folgenden Befehle aus, um Certbot zu installieren.

$ sudo dnf install certbot

Beende den Apache-Server.

$ sudo systemctl stop httpd

Erstelle das SSL-Zertifikat.

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

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

Starte den Apache-Server.

$ sudo systemctl start httpd

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 redmine.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl restart 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 – Nginx als Reverse-Proxy installieren und konfigurieren

Rocky Linux 8 wird mit vier verschiedenen Versionen von Nginx ausgeliefert – 1.14, 1.16, 1.18 und 1.20.

Liste alle verfügbaren Nginx-Module auf.

$ dnf module list nginx
Last metadata expiration check: 20:23:20 ago on Mon 03 Jan 2022 12:38:07 PM UTC.
Rocky Linux 8 - AppStream
Name                      Stream                       Profiles                      Summary
nginx                     1.14 [d]                     common [d]                    nginx webserver
nginx                     1.16                         common [d]                    nginx webserver
nginx                     1.18                         common [d]                    nginx webserver
nginx                     1.20                         common [d]                    nginx webserver

Extra Packages for Enterprise Linux Modular 8 - x86_64
Name                      Stream                       Profiles                      Summary
nginx                     mainline                     common                        nginx webserver
nginx                     1.20                         common [d]                    nginx webserver

Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled

Setze die anderen Versionen zurück und aktiviere die 1.20 Version von Nginx.

$ sudo dnf module reset nginx
$ sudo dnf module enable nginx:1.20

Installiere Nginx. Wir deaktivieren vorübergehend das RepositoryEpel, da wir Nginx aus dem Appstream holen wollen.

$ sudo dnf install nginx --disablerepo=epel-modular

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.20.0

Um Konflikte mit Nginx zu vermeiden, müssen wir den Standard-Port ändern, auf dem Apache lauscht.

Apache Listening Port ändern

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

$ sudo nano /etc/httpd/conf/httpd.conf

Ändere den Port wie folgt von 80 auf 8080.

Listen 8080

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

Starte Apache neu.

$ sudo systemctl restart httpd

Nginx konfigurieren

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

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

Füge den folgenden Code in die Datei ein.

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

server {
    listen 443 ssl http2;

    server_name redmine.example.com;

    ssl_certificate     /etc/letsencrypt/live/redmine.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/redmine.example.com/privkey.pem;
	ssl_trusted_certificate /etc/letsencrypt/live/redmine.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;

    access_log /var/log/nginx/redmine.example.com.access.log main;
    error_log  /var/log/nginx/redmine.example.com.error.log;
	
	location / {
        proxy_pass          http://localhost:3000;
        proxy_redirect      off;
        proxy_buffering     off;
        proxy_set_header    Host $host;
        proxy_set_header    X-Real-IP $remote_addr;
        proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Speichere die Datei, indem du 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

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

$ sudo systemctl start nginx

Deine Redmine-Anwendung sollte nun unter https://redmine.example.com erreichbar sein.

Fazit

Dies ist der Abschluss unseres Tutorials, in dem du gelernt hast, wie du Redmine Project Manager auf einem Rocky Linux 8 basierten Server installierst. Du hast auch gelernt, wie du die Redmine-Anwendung über Nginx mit dem HTTPS-Protokoll bereitstellst. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.

Das könnte dich auch interessieren …