So installierst du das Projektmanagement-Tool Redmine auf Ubuntu 22.04

Redmine ist ein kostenloses 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, und jedes Projekt hat sein eigenes Wiki, seine eigenen Foren, seine eigene Problemverfolgung usw. Außerdem kannst du eigene Rollen erstellen, die auf die Bedürfnisse deines Unternehmens zugeschnitten sind, und vieles mehr.

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

In dieser Anleitung installierst du Redmine mit Apache2 Webserver und MySQL Server auf einem Ubuntu 22.04 Server. Außerdem wirst du die Redmine-Installation mit SSL-Zertifikaten absichern.

Voraussetzungen

Für dieses Tutorial brauchst du folgende Voraussetzungen:

• Einen Ubuntu 22.04-Server – Dieses Beispiel verwendet einen Ubuntu-Server mit dem Hostnamen redmine-server.
• Einen Nicht-Root-Benutzer mit sudo Root-Rechten – Du kannst aber auch den Root-Benutzer verwenden.
• Ein Domainname, der auf die IP-Adresse deines Servers zeigt – Für die Produktion musst du sicherstellen, dass dein Domainname auf die IP-Adresse deines Servers zeigt.

Wenn du alles eingerichtet hast, kannst du mit dem ersten Schritt der Redmine-Installation fortfahren.

Installieren der Abhängigkeiten

Redmine ist ein Open-Source-Projektmanagement- und Problemverfolgungstool, das hauptsächlich in Ruby und Ruby on Rails (RoR) geschrieben wurde. Um Redmine zu installieren, musst du zuerst Ruby installieren. Danach kannst du andere Abhängigkeiten wie den Webserver Apache2 und die Datenbank mit MySQL Server installieren.

In diesem Beispiel wirst du Redmine mit dem Apache2-Webserver und dem MySQL-Server betreiben.

Bevor du mit der Installation der Pakete beginnst, führe den unten stehenden apt-Befehl aus, um deinen Ubuntu-Paketindex zu aktualisieren und aufzufrischen.

sudo apt update

Nachdem das Repository aktualisiert wurde, installierst du einige der folgenden Paketabhängigkeiten mit dem unten stehenden apt-Befehl.

Mit diesem Befehl installierst du den Apache2-Webserver, gefolgt vom linapache2-mod-passenger, der verwendet wird, um die RoR-Anwendung so einzurichten, dass sie unter Apache2 läuft. Außerdem installierst du Ruby-Pakete.

sudo apt install apache2 ruby ruby-dev build-essential libapache2-mod-passenger libmysqlclient-dev

Wenn du aufgefordert wirst, die Installation zu bestätigen, gib y ein und drücke ENTER, um fortzufahren.

Nachdem Apache2 und Ruby installiert sind, führe den folgenden Befehl aus, um den MySQL-Server zu installieren. Redmine unterstützt mehrere RDBMS wie PostgreSQL, MySQL/MariaDB und SQLite. In diesem Beispiel verwendest du den MySQL-Server.

sudo apt install mysql-server

Gib y ein, wenn du aufgefordert wirst, die Installation zu bestätigen, und drücke dann ENTER, um fortzufahren.

Für die Redmine-Installation musst du auch einen Bundler auf deinem Ubuntu-Server installieren. bundler ist eine Befehlszeile, die zur Verwaltung von Ruby Gems-Paketen verwendet wird.

Führe den folgenden Befehl aus, um einen Bundler auf deinem System zu installieren.

sudo gem install bundler

Sobald der Bundler installiert ist, siehst du eine Ausgabe wie die folgende:

Überprüfe abschließend die Apache2- und MySQL-Dienste mit dem folgenden systemctl-Befehl. Damit stellst du sicher, dass sowohl der Apache2 als auch der MariaDB-Dienst laufen und aktiviert sind.

Überprüfe den Apache2-Dienst.

sudo systemctl is-enabled apache2
sudo systemctl status apache2

Unten siehst du, dass der Apache2-Dienst aktiviert ist und beim Systemstart automatisch ausgeführt wird. Und der aktuelle Status des Dienstes ist running.\

Überprüfe den MySQL-Dienst.

sudo systemctl is-enabled mysql
sudo systemctl status mysql

Du erhältst eine ähnliche Ausgabe wie die folgende – Der MySQL-Dienst ist aktiviert und wird beim Systemstart automatisch ausgeführt. Und der aktuelle Status des MySQL-Dienstes lautet „running“.

MySQL-Server konfigurieren

Nachdem Apache2 und der MySQL-Server installiert sind, richtest du das MySQL-Root-Passwort ein und sicherst die Installation mit mysql_secure_installation. Dann erstellst du eine neue MySQL-Datenbank und einen neuen Benutzer für Redmine.

Melde dich mit dem unten stehenden mysql-Befehl bei MySQL an.

sudo mysql

Ändere nun das MySQL-Root-Passwort mit der folgenden Abfrage. Achte darauf, dass du das Passwort mit deinem Passwort änderst. Gib dann quit ein, um die MySQL-Shell zu verlassen.

ALTER USER root@localhost IDENTIFIED WITH mysql_native_password BY 'password';
quit

Als Nächstes führst du den folgenden Befehl aus, um den MySQL-Servereinsatz zu sichern.

sudo mysql_secure_installation

Wenn du nach dem MySQL-Root-Passwort gefragt wirst, gibst du dein richtiges Passwort ein.

Dann wirst du nach weiteren MySQL-Konfigurationen gefragt, z. B. nach dem Deaktivieren des Remote-Logins für den Root-Benutzer, dem Entfernen des anonymen Benutzers, dem Entfernen des Standard-Datenbanktests und dem erneuten Laden aller Tabellenberechtigungen. Für alle diese MySQL-Server-Einstellungen musst du Y eingeben, um die Konfiguration zu bestätigen.

Nachdem du den MySQL-Einsatz gesichert hast, ist es an der Zeit, eine neue Datenbank und einen neuen Benutzer für Redmine einzurichten.

Melde dich mit dem unten stehenden mysql-Befehl in der MySQL-Shell an. Du wirst nach dem MySQL-Root-Passwort gefragt. Gib das richtige Passwort für deinen MySQL-Root-Benutzer ein und drücke dann ENTER.

sudo mysql -u root -p

Führe nun die folgenden Abfragen aus, um eine neue MySQL-Datenbank und einen neuen Benutzer für Redmine zu erstellen. In diesem Beispiel erstellst du eine neue Datenbank und den Benutzer redmine mit dem Passwort„secretPassword„. Du kannst das Datenbankpasswort durch dein Passwort ersetzen.

CREATE DATABASE redmine CHARACTER SET utf8mb4;
CREATE USER 'redmine'@'localhost' IDENTIFIED BY 'secretPassword';
GRANT ALL PRIVILEGES ON redmine.* TO 'redmine'@'localhost';
FLUSH PRIVILEGES;

Als nächstes führst du die folgenden Abfragen aus, um die Rechte des MySQL-Benutzers redmine zu überprüfen. Vergewissere dich, dass der MySQL-Benutzer redmine Zugriffsrechte auf die Datenbank redmine hat.

SHOW GRANTS FOR redmine@localhost;
quit

Unten siehst du den MySQL-Benutzer redmine@localhost mit Zugriffsrechten auf die Datenbank redmine.

Gib zum Schluss quit ein, um dich von der MySQL-Shell abzumelden.

Wenn alle Abhängigkeiten installiert sind und die MySQL-Datenbank und der Benutzer erstellt sind, kannst du das Projektmanagement-Tool Redmine auf deinem Ubuntu-Server installieren.

Redmine installieren

In diesem Schritt installierst du die neueste Version von Redmine. Zum Zeitpunkt der Erstellung dieses Artikels ist die neueste Version von Redmine v5.0.2.

Du lädst den Redmine-Quellcode herunter, konfigurierst die Datenbank, installierst die Ruby-Abhängigkeiten per Build, richtest das geheime Redmine-Token ein und migrierst die Datenbank.

In diesem Beispiel wirst du Redmine im Verzeichnis /opt/redmine installieren.

Wechsle in das Verzeichnis /opt.

cd /opt/

Lade nun den Redmine-Quellcode mit dem unten stehenden wget-Befehl herunter. Nach dem Download findest du die Datei redmine-5.0.2.tar.gz in deinem /opt-Verzeichnis.

wget https://www.redmine.org/releases/redmine-5.0.2.tar.gz

Als Nächstes führst du den folgenden Befehl aus, um den Redmine-Quellcode redmine-5.0.2.tar.gz zu entpacken und einen neuen symbolischen Link für das Redmine-Verzeichnis nach /opt/redmine zu erstellen.

tar -xvzf redmine-5.0.2.tar.gz
sudo ln -s redmine-5.0.2 redmine

Das Hauptinstallationsverzeichnis von Redmine wird /opt/redmine sein.

Wechsle in das Verzeichnis /opt/redmine.

cd /opt/redmine/

Kopiere die Standard-Datenbankkonfiguration „config/database.yml.example“ nach „config/database.yml“. Öffne dann die Datenbankkonfigurationsdatei „config/database.yml“ mit dem nano-Editor.

cp config/database.yml.example config/database.yml
nano config/database.yml

Im Abschnitt „production“ änderst du die Angaben zur MySQL-Datenbank und zum Benutzer. Achte darauf, dass du den richtigen Datenbankbenutzer und das richtige Passwort für Redmine verwendest.

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

Speichere die Datei und schließe den Editor, wenn du fertig bist.

Als nächstes führst du den folgenden Bundler-Befehl aus, um die Ruby-Abhängigkeiten für die Redmine-Anwendung zu installieren.

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

Du wirst eine ähnliche Ausgabe wie die folgende sehen:

Sobald die Redmine-Abhängigkeiten installiert sind, führe den folgenden Befehl aus, um das geheime Redmine-Token zu erzeugen und die Datenbank zu migrieren.

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

Im folgenden Screenshot kannst du sehen, wie das geheime Redmine-Token generiert wird und wie die Redmine-Datenbank migriert wird.

Zum Schluss lädst du die Standardeinstellungen für deine Redmine-Installation mit dem folgenden Befehl. Wenn du aufgefordert wirst, die Sprache auszuwählen, gib en für Englisch ein.

RAILS_ENV=production bundle exec rake redmine:load_default_data

Wenn die Standarddaten von Redmine geladen sind, siehst du die Meldung„Standardkonfigurationsdaten geladen„.

Jetzt, da Redmine installiert ist, richtest du als Nächstes einen virtuellen Apache2-Host für Redmine ein.

Virtuellen Host für Redmine einrichten

In diesem Schritt erstellst du eine neue Konfiguration des virtuellen Apache2-Hosts für Redmine. Vergewissere dich also, dass der Domainname auf deine Server-IP-Adresse zeigt und SSL-Zertifikate generiert wurden.

Führe den folgenden Befehl aus, um die Apache-Module ssl und rewrite zu aktivieren.

sudo a2enmod ssl rewrite

Du wirst die folgende Ausgabe sehen:

Erstelle nun mit dem nano-Editor eine neue Apache2-Konfiguration für den virtuellen Host„/etc/apache2/sites-available/redmine.conf„.

sudo nano /etc/apache2/sites-available/redmine.conf

Füge die folgende Konfiguration in die Datei ein. Achte darauf, dass du den Domainnamen und den Pfad der SSL-Zertifikate mit deiner Konfiguration abänderst.

<VirtualHost *:80>
ServerName redmine.hwdomain.io
ServerAdmin admin@redmine.hwdomain.io

# Redirect Requests to SSL
Redirect permanent "/" "https://redmine.hwdomain.io/"

</VirtualHost>

<IfModule mod_ssl.c>

<VirtualHost *:443>

ServerName redmine.hwdomain.io
RailsEnv production
DocumentRoot /opt/redmine/public

ErrorLog ${APACHE_LOG_DIR}/redmine.hwdomain.io.error.log
CustomLog ${APACHE_LOG_DIR}/redmine.hwdomain.io.access.log combined

SSLEngine on
SSLCertificateFile /etc/letsencrypt/live/redmine.hwdomain.io/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/redmine.hwdomain.io/privkey.pem

<Directory "/opt/redmine/public">
Allow from all
Require all granted
</Directory>

</VirtualHost>

</IfModule>

Speichere die Datei und beende den Editor.

Als Nächstes führst du den folgenden Befehl aus, um die virtuelle Hostdatei„redmine.conf“ zu aktivieren. Überprüfe dann deine Apache2-Konfiguration, um sicherzustellen, dass du die richtige Konfiguration hast.

sudo a2ensite redmine.conf
sudo apachectl configtest

Du erhältst die Meldung„Syntax OK„, wenn die Apache2-Konfiguration korrekt ist.

Starten Sie den Apache2-Dienst mit dem Befehl systemctl neu, um die neue virtuelle Hostdatei zu übernehmen.

sudo systemctl restart apache2

Jetzt ist Redmine installiert und der virtuelle Host ist konfiguriert. Du solltest nun über deinen Domainnamen auf deine Redmine-Installation zugreifen können.

UFW-Firewall einrichten

In der Produktion sollst du die Firewall einschalten. Für das Ubuntu-System kannst du die Standard-Firewall UFE (Uncomplicated Firewall) verwenden.

Jetzt fügst du UFW-Regeln hinzu, die die standardmäßigen HTTP- und HTTPS-Dienste öffnen, damit Redmine von außerhalb des Netzwerks erreichbar ist.

Führe den folgenden ufw-Befehl aus, um das Standard-Anwendungsprofil„OpenSSH“ zur UFW hinzuzufügen. Starte und aktiviere dann die UFW-Firewall.

sudo ufw allow "OpenSSH"
sudo ufw enable

Wenn du zur Bestätigung aufgefordert wirst, gib y ein, um den UFW-Firewall-Dienst zu starten und zu aktivieren.

Führe anschließend den folgenden Befehl aus, um das Anwendungsprofil„Apache Full“ zur Firewall hinzuzufügen. Überprüfe dann den UFW-Status mit dem folgenden Befehl.

sudo ufw allow "Apache Full"
sudo ufw status

Du solltest sehen, dass der UFW-Firewall-Status aktiv ist und die derzeit aktivierten Anwendungsprofile OpenSSH und„Apache Full“ sind. Dadurch werden der standardmäßige SSH-Port 22 und die HTTP- und HTTPS-Dienste Port 80 und 443 geöffnet.

Redmine-Installation

Öffne den Webbrowser und rufe den Domainnamen deiner Redmine-Installation auf (z.B.: https://redmine.hwdomain.io/).

Du siehst nun die Standard-Homepage von Redmine Project Management and Issue Tracking Tool. Klicke auf„Anmelden“, um dich in das Redmine-Administrations-Dashboard einzuloggen.

Gib den standardmäßigen Redmine-Administrationsbenutzer und das Passwort „admin – admin“ ein.

Nachdem du dich eingeloggt hast, wirst du aufgefordert, das Standardpasswort für Redmine zu ändern. Gib das neue Passwort für deine Redmine-Installation ein und klicke auf„Übernehmen„.

Bearbeite abschließend die Details deines Redmine-Administrator-Benutzers und klicke auf„Speichern„, um die Konfigurationen zu übernehmen. Du hast nun die Basis von Redmine konfiguriert.

Um ein neues Projekt hinzuzufügen, klicke auf das Menü„Projekte„. Du solltest nun in der Lage sein, Projekte in deinem Redmine zu erstellen, zu bearbeiten oder zu löschen.

Wenn du nun Konfigurationen zu Redmine hinzufügen möchtest, klicke auf das Menü„Verwaltung„. Damit kannst du weitere Benutzer hinzufügen, Gruppen einrichten, Rollen definieren, die Authentifizierung über eine Drittanbieteranwendung wie LDAP aktivieren und vieles mehr.

Fazit

In diesem Lernprogramm hast du Redmine, das Tool für Projektmanagement und Fehlerverfolgung, auf dem Ubuntu 22.04 Server installiert und konfiguriert. Du hast auch die MariaDB-Datenbank und den Nginx-Webserver für Redmine konfiguriert. Darüber hinaus hast du die Redmine-Installation mit SSL-Zertifikaten abgesichert.

Jetzt hast du Redmine auf deinem System installiert. Du kannst deine Redmine-Installation erweitern, indem du einige zusätzliche Konfigurationen hinzufügst, z. B. die Integration von Redmine in deine bestehende Infrastruktur, wie das Hinzufügen von LDAP-Authentifizierungen und die Integration mit SCM wie SVN, Git und Mercurial. Du kannst auch Rollen für deine Organisation oder dein Unternehmen hinzufügen.