So installierst du Redmine auf Rocky Linux

Redmine ist ein freies und quelloffenes Projektmanagement- und Problemverfolgungsprogramm. Es handelt sich um eine webbasierte Anwendungssoftware, die hauptsächlich in Ruby on Rails geschrieben wurde. Sie ist plattformübergreifend und unterstützt mehrere Datenbanken und Sprachen.

Redmine ist flexibel und kann für verschiedene Arten von Organisationen und Projekten eingesetzt werden, von kleinen über mittlere bis hin zu großen Organisationen. Mit Redmine kannst du mehrere Projekte erstellen und verwalten, jedes mit eigenem Wiki, Foren, Problemverfolgung usw. Du kannst auch eigene Rollen erstellen, die auf die Bedürfnisse deiner Organisation zugeschnitten sind, und vieles mehr.

Redmine wird unter der GNU GPL v2 Lizenz veröffentlicht und kann auf jedem Betriebssystem installiert werden, z.B. Linux, Windows oder macOS. Es unterstützt verschiedene Datenbanken, darunter PostgreSQL, MySQL und SQLite (Standard).

Nachfolgend die wichtigsten Funktionen von Redmine:

• Unterstützung mehrerer Projekte
• Wiki und Foren pro Projekt
• Verwaltung von Dokumenten und Dateien
• Nachrichten und Feeds sowie E-Mail-Benachrichtigungen
• Zeiterfassung
• Unterstützt mehrere SCM (SVN, Git, CVS, Mercurial, Bazaar)
• Unterstützt rund 49 Sprachen
• Unterstützt LDAP-Authentifizierung
• etc

Voraussetzungen

In diesem Leitfaden erfährst du, wie du das Projektmanagement- und Problemverfolgungstool Redmine auf dem Rocky-Linux-System mit der PostgreSQL-Datenbank und dem Webserver Apache/httpd einsetzt.

Im Folgenden findest du die Umgebung für dieses Beispiel:

• Betriebssystem: Rocky Linux 8.4 (Green Obisidian)
• IP-Adresse: 192.168.1.10
• Root-Rechte
• Domänenname: redmine.example.com

Das Ziel, das du in diesem Leitfaden lernen wirst:

• Installieren von Ruby mit RVM (Ruby Version Manager)
• Einrichten der PostgreSQL-Datenbank
• Installieren von Passenger
• Einrichten eines virtuellen Apache/httpd-Hosts für Redmine (mit oder ohne SSL)
• Installation und Konfiguration von Redmine

Bevor du mit diesem Leitfaden beginnst, solltest du die PostgreSQL-Installation auf dem Rocky Linux-System abschließen.

So installierst du PostgreSQL auf Rocky Linux

Abhängigkeiten installieren

Als Erstes musst du die folgenden Abhängigkeiten installieren. Alle unten aufgeführten Pakete werden für die Redmine-Installation benötigt. Stelle sicher, dass du alle Befehle mit sudo oder root-Rechten ausführst.

1. Füge das EPEL (Extra Packages for Enterprise Linux) Repository zu deinem System hinzu.

sudo dnf install epel-release -y

2. Nachdem die EPEL-Installation abgeschlossen ist, installiere die Pakete mit dem unten stehenden DNF-Befehl.

sudo dnf install curl gpg gnupg2 gcc gcc-c++ make patch autoconf automake bison ImageMagick libffi-devel libtool patch redhat-rpm-config readline-devel postgresql-devel zlib-devel openssl-devel -y

3. Als Nächstes installierst du den Webserver apache/httpd auf deinem Rocky Linux-System, indem du den DNF-Befehl wie unten beschrieben ausführst.

sudo dnf install libcurl-devel httpd-devel httpd apr-devel apr-util-devel -y

Wenn die Installation der httpd-Pakete abgeschlossen ist, starte und aktiviere den httpd-Dienst.

sudo systemctl enable --now httpd

Überprüfe nun den httpd und stelle sicher, dass er aktiv ist und läuft.

sudo systemctl status httpd

Die Grundpakete für die Redmine-Installation sind installiert. Gehe zum nächsten Schritt über, um RVM und Ruby zu installieren.

Installation von RVM und Ruby

Die neueste Version von Redmine erfordert die Ruby-Version 2.7 für die Installation. In diesem Schritt installierst du Ruby Version 2.7 auf dem Rocky Linux System mit dem RVM oder Ruby Version Manager.

Du installierst also zunächst den RVM und dann Ruby.

1. Importiere zunächst die GPG-Schlüssel des rvm-Entwicklers auf dein System.

curl -sSL https://rvm.io/mpapis.asc | gpg2 --import -
curl -sSL https://rvm.io/pkuczynski.asc | gpg2 --import -

2. Installiere nun die stabile Version von rvm und lade die rvm-Umgebung mit den folgenden Befehlen.

curl -L get.rvm.io | bash -s stable
source /etc/profile.d/rvm.sh

Danach lädst du den rvm-Quellcode erneut und installierst alle Systemvoraussetzungen für den rvm.

rvm reload
rvm requirements run

Wenn alle Prozesse abgeschlossen sind, kannst du Ruby installieren.

3. Führe den folgenden rvm-Befehl aus, um Ruby Version 2.7 auf dem Rocky Linux System zu installieren.

rvm install 2.7

Warte, bis die Installation abgeschlossen ist.

Prüfe nun die verfügbare Ruby-Version auf deinem System und die aktuelle Ruby-Version auf deinem System.

rvm list
ruby --version

Du wirst eine ähnliche Ausgabe wie unten sehen.

Es ist nur eine Version von Ruby auf deinem System installiert, nämlich ruby 2.7.2. Und diese wird derzeit auf deinem System verwendet.

Gehe nun zum nächsten Schritt über, um die PostgreSQL-Datenbank für die Redmine-Installation einzurichten.

Einrichten der PostgreSQL-Datenbank

Bevor du weitermachst, solltest du sicherstellen, dass du die PostgreSQL-Installation wie unten beschrieben abgeschlossen hast.

So installierst du PostgreSQL auf Rocky Linux

Danach erstellst du eine neue PostgreSQL-Datenbank und einen Benutzer für Redmine.

1. Melde dich mit folgendem Befehl in der PostgreSQL-Shell an.

sudo -u postgres psql

2. Erstelle mit der folgenden Abfrage einen neuen PostgreSQL-Benutzer„redmine“ und die Datenbank„redminedb„. Achte darauf, dass du das Passwort mit deinem sicheren Passwort änderst.

CREATE ROLE redmine LOGIN ENCRYPTED PASSWORD 'StrongPasswordRedmine' NOINHERIT VALID UNTIL 'infinity';
CREATE DATABASE redminedb WITH ENCODING='UTF8' OWNER=redmine;

Gib„\q“ ein und drücke„Enter„, um die PostgreSQL-Shell zu verlassen.

Jetzt bist du bereit, Redmine auf deinem System zu installieren.

Installieren und Konfigurieren von Redmine

In diesem Schritt installierst du Redmine in der Version 4.2.3, der zur Zeit aktuellsten Version. Die Redmine-Installation wird im Verzeichnis „/var/www/redmine“ verfügbar sein.

1. Ändere das aktuelle Arbeitsverzeichnis in„/var/www“ und lade den Redmine 4.2.3 Quellcode herunter.

cd /var/www/
wget https://www.redmine.org/releases/redmine-4.2.3.tar.gz

Entpacke nun den Redmine-Quellcode und benenne das Verzeichnis in „redmine“ um.

tar -xzvf redmine-4.2.3.tar.gz
mv redmine-*/ redmine

2. Als nächstes erstellst du eine neue Redmine-Datenbankkonfiguration.

Wechsle dein Arbeitsverzeichnis in das Verzeichnis„/var/www/redmine“.

export REDMINE=/var/www/redmine
cd $REDMINE

Erstelle eine neue Datenbankkonfiguration „config/database.yml“ mit dem nano-Editor.

nano config/database.yml

Kopiere die folgende Konfiguration und füge sie darin ein. Achte darauf, dass du den Datenbanknamen, den Benutzer und das Passwort mit deinen Daten änderst.

production:
  adapter: postgresql
  database: redminedb
  host: localhost
  username: redmine
  password: "StrongPasswordRedmine"
  encoding: utf8

Speichere die Konfiguration und beende sie.

3. Nachdem du die Datenbank für Redmine konfiguriert hast, wirst du einige Ruby-Abhängigkeiten installieren. Du musst die folgenden Befehle im Redmine-Installationsverzeichnis„/var/www/redmine“ ausführen.

Installiere zunächst einen Bundler mit dem unten stehenden Befehl ruby gem.

gem install bundler

Führe nun den Befehl „bundle“ aus, um deine Redmine-Installation zu konfigurieren.

bundle config set --local path 'vendor/bundle'
bundle config set --local without 'development test'

Installiere nun die Ruby-Pakete für Redmine mit dem unten stehenden bundle-Befehl.

bundle install

Je nach Internetverbindung und Rechner/System kann der Befehl einige Zeit in Anspruch nehmen. Wenn du keine Fehlermeldungen erhältst, gehe zum nächsten Schritt über.

4. Nachdem die Installation aller Ruby-Abhängigkeiten abgeschlossen ist, generierst du das geheime Token und migrierst die Datenbank mit dem folgenden Befehl.

bundle exec rake generate_secret_token
RAILS_ENV=production bundle exec rake db:migrate

5. Danach änderst du den Eigentümer des Redmine-Installationsverzeichnisses auf den Benutzer„apache„.

sudo chown -R apache:apache $REDMINE

Wenn die Installation und Konfiguration von Redmine abgeschlossen ist, kannst du mit dem nächsten Schritt fortfahren und Passenger und den httpd-Webserver einrichten.

Installieren und Konfigurieren von Passenger

Passenger oder Phusion Passenger ist ein in Ruby geschriebener Webanwendungsserver. In der Produktionsumgebung wird er oft als Frontend für deine Rails-Anwendungen eingesetzt. In dieser Anleitung wird dein Redmine hinter dem Passenger- und httpd-Webserver laufen.

Passenger kann über das RubyGem Repository installiert werden. Außerdem kann er mit Apache/httpd und Nginx Webserver integriert werden, um Ruby-Anwendungen, einschließlich Rails, zu verwalten.

1. Um Passenger systemweit zu installieren, führe den folgenden gem-Befehl aus

gem install passenger

2. Nachdem die Installation von passenger abgeschlossen ist, führe den folgenden Befehl aus, um das passenger Apache-Modul zu installieren.

passenger-install-apache2-module

Das Installationsprogramm beschreibt alles, was du tun musst, und du solltest„Enter“ drücken, wenn du alle Punkte der Installation gelesen hast.

Wähle„Ruby“ als deine Anwendung und drücke„Enter„, um fortzufahren.

Jetzt fordert dich das Installationsprogramm auf, einige Konfigurationen für Apache/httpd vorzunehmen, wie du auf dem Screenshot unten sehen kannst.

Öffne eine neue Terminal-Shell, verbinde dich mit deinem Server und erstelle eine neue httpd-Konfiguration„/etc/httpd/conf.d/passenger.conf“ mit dem Editor nano.

nano /etc/httpd/conf.d/passenger.conf

Füge die Konfiguration ein, die auf deinem Bildschirm angezeigt wird. Unten siehst du die Konfiguration aus dem Screenshot oben.

   LoadModule passenger_module /usr/local/rvm/gems/ruby-2.7.2/gems/passenger-6.0.12/buildout/apache2/mod_passenger.so
   <IfModule mod_passenger.c>
     PassengerRoot /usr/local/rvm/gems/ruby-2.7.2/gems/passenger-6.0.12
     PassengerDefaultRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby
   </IfModule>

Speichere die Konfiguration und beende sie.

Starte anschließend den httpd-Dienst neu, um die neue Konfiguration anzuwenden.

sudo systemctl restart httpd

Gehe dann zurück in die vorherige Shell und drücke„Enter„, um fortzufahren.

Danach überprüft das Installationsprogramm die Installation des Apache-Moduls und stellt sicher, dass du keine Fehler erhältst.

Wenn du keine Fehler bekommst, siehst du eine ähnliche Ausgabe wie unten.

Die Installation von Passenger und dem Apache 2 Modul ist abgeschlossen. Jetzt kannst du den virtuellen httpd-Host für Redmine einrichten.

httpd für Redmine konfigurieren

In diesem Schritt erstellst du eine neue Konfiguration des virtuellen httpd-Hosts für deine Redmine-Installation.

1. Erstelle eine neue virtuelle Host-Konfiguration„/etc/httpd/conf.d/redmine.conf“ mit dem Editor nano.

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

Kopiere die folgende Konfiguration und füge sie ein. Achte darauf, dass du den Domainnamen durch deine Domain ersetzt.

PassengerRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby
<VirtualHost *:80>
ServerName redmine.example.io
DocumentRoot "/var/www/redmine/public"

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 Konfiguration und beende sie.

Für die HTTPS-Konfiguration von Redmine kopierst du die folgende Konfiguration und fügst sie ein. Achte darauf, dass du den Domänennamen und den SSL-Pfad mit deinen Angaben abänderst. Vergiss außerdem nicht, das Apache mod_ssl Modul zu aktivieren, damit HTTPS auf deinem System funktioniert.

PassengerRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby
<VirtualHost *:80>

ServerName redmine.example.io
Redirect permanent / https://redmine.example.io/

</VirtualHost>

<VirtualHost *:443>
ServerName redmine.example.io

Protocols h2 http/1.1

<If "%{HTTP_HOST} == 'www.redmine.example.io'">
Redirect permanent / https://redmine.example.io/
</If>

DocumentRoot "/var/www/redmine/public"

ErrorLog /var/log/httpd/redmine.example.io-error.log
CustomLog /var/log/httpd/redmine.example.io-access.log combined

SSLEngine On
SSLCertificateFile /etc/letsencrypt/live/redmine.example.io/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/redmine.example.io/privkey.pem

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

</VirtualHost>

2. Als Nächstes überprüfst du die httpd-Konfiguration und stellst sicher, dass kein Fehler vorliegt. Starte dann den httpd-Dienst neu, um die neue Konfiguration des virtuellen Hosts anzuwenden.

apachectl configtest
sudo systemctl restart httpd

Jetzt kannst du auf deine Redmine-Installation zugreifen.

Überprüfe die Redmine-Installation

Öffne deinen Webbrowser und gib den Domainnamen deiner Redmine-Installation mit dem Pfad „/login“ in die Adresszeile ein.

https://redmine.example.io/login

1. Gib auf der Redmine-Anmeldeseite den Standardbenutzer„admin“ und das Passwort„admin“ ein und klicke dann auf die Schaltfläche„Anmelden„.

2. Jetzt musst du das Standard-Passwort „admin“ zurücksetzen.

Gib das alte Passwort„admin“ und das neue sichere Passwort ein und klicke dann auf„Übernehmen„.

3. Dann siehst du deine Kontodaten.

Bearbeite alle Informationen mit deinen Angaben oder lass sie einfach so, wie sie sind, und klicke dann auf„Speichern„.

4. Dann siehst du die Redmine-Verwaltungsseite wie unten abgebildet.

Bei der ersten Installation musst du die Standardsprache für deine Redmine-Installation laden.

Wähle deine Sprache und klicke auf die Schaltfläche„Standardkonfiguration laden„.

5. Klicke im linken Menü auf„Benutzer„, um alle registrierten Benutzer in Redmine zu sehen.

6. Wechsle nun zum Menü„Informationen„, um alle Details deiner Redmine-Installation zu sehen.

Unten siehst du eine ähnliche Ausgabe.

Wie du sehen kannst, ist die Redmine-Installation abgeschlossen. Du hast gerade Redmine Version 4.2.3 stable mit Ruby 2.7 und der PostgreSQL-Datenbank in der Produktionsumgebung installiert.

Fazit

Herzlichen Glückwunsch! Du hast gelernt, wie du Redmine mit der PostgreSQL-Datenbank und dem Apache/httpd-Webserver auf dem Rocky Linux-System installierst. Außerdem hast du gelernt, wie du Phusion Passenger installierst und es in den Apache Webserver integrierst.

Im nächsten Schritt kannst du weitere Plugins zu deiner Redmine-Installation hinzufügen und einen SMTP-Server einrichten usw.