Redmine Ticketsystem: Installation und Konfiguration für Linux Ubuntu 22.04

Redmine Ticketsystem: Installation und Einrichtung unter Linux Ubuntu 22.04

In dieser Anleitung installieren wir die freie Open-Source Software Redmine. Nach der Installation steht uns eine webbasierte Projektmanagement-Software mit sehr vielen Funktionen und Möglichkeiten zur Verfügung. So können wir mit Redmine ein Ticketsystem (Issue-Tracking-System) auf einen Server betreiben, Diskussionsforen erstellen, um den Austausch z.B. über ein bestimmtes Projekt zu vereinfachen, und sogar Wikis mit Dokumentenablagen können mit der kostenlosen Software Redmine realisiert werden.

Für die Installation von Redmine auf einem Linux Debian oder Ubuntu Hostsystem benötigen wir einen Webserver und eine Datenbank. Hinzukommen einige Abhängigkeiten, die wir in diesem Tutorial Schritt für Schritt installieren. Nach der Installation steht uns ein erstklassiges Ticketsystem zur Verfügung, um die Zusammenarbeit zwischen den First- und Second-Level Support und dem IT-Administratoren/Entwicklern zu vereinfachen. Je nach Konfiguration können Kunden auch selbstständig Tickets für Störungen, Bugs oder mit Fragen bezüglich eines Produktes anlegen.

Mithilfe der eingepflegten Benutzerberechtigungen können wir beliebig viele Benutzer mit verschiedenen Berechtigungen erstellen (Berechtigungssystem). Wer Darf ein Ticket anlegen? Wer darf ein Ticket bearbeiten? Und noch vieles mehr.

Redmine ist komplett kostenlos und unter den Bedingungen der GNU General Public License v2 (GPL) veröffentlicht. Die flexible Webanwendung wurde mit dem Ruby on Rails-Framework geschrieben und funktioniert Plattform- und Datenbankübergreifend.

Inhaltsverzeichnis: Ein Ticketsystem mit Redmine installieren (Tutorial)

Vorbereitungen für die Installation von Redmine auf Linux Ubuntu 22.04 (Schritt 1.)

Voraussetzungen für die Installation von Redmine nach dieser Anleitung

Die Installation von Redmine funktioniert mit dieser Anleitung auf Linux Ubuntu und auf Linux Debian basierten Servern auf ähnlicher Art und Weise. Wir konzentrieren uns bei der Installation jedoch vermehrt auf die zuletzt erschienene Distribution Ubuntu 22.04. Dabei spielt es keine Rolle, ob Redmine auf einer virtuellen Maschine oder auf einem physischen Hostsystem installiert wird.

Voraussetzungen für die Redmine-Installation:

  • Einen Server mit installiertem Linux Ubuntu 22.04
  • Ein Root-Zugang (Administrator)
  • Eine Verbindung mit dem Internet

Systemaktualisierung durchführen:

Bevor wir mit der Installation beginnen, stelle zunächst sicher, dass die Systempakete auf dem neusten Stand sind, indem du eine Aktualisierung manuell anstößt:

sudo apt update

Abhängigkeiten für Redmine installieren:

Mit diesem Befehl installieren wir alle Abhängigkeiten für die Installation und den Betrieb von Redmine. Führe den folgenden Befehl aus, um die Build-Tools auf deinem Server zu installieren:

apt install build-essential ruby-dev libxslt1-dev libmariadb-dev libxml2-dev zlib1g-dev imagemagick libmagickwand-dev curl gnupg2 bison libbison-dev libgdbm-dev libncurses-dev libncurses5-dev libreadline-dev libssl-dev libyaml-dev libsqlite3-dev sqlite3 -y

Redmine Installation: Einen Apache-Webserver für das Ticketsystem installieren (Schritt 2.)

Da Redmine eine webbasierte Software ist und über die IP-Adresse oder eingetragene Domain über den Browser aufgerufen wird, installieren wir den leistungsfähigen Apache-Webserver mit dem Passanger-Modul, den Lightweight-Webserver für Ruby:

sudo apt install apache2 libapache2-mod-passenger

Führe den folgenden Befehl aus, damit Apache bei einem Neu- und Systemstart direkt wieder ausgeführt wird:

sudo systemctl enable --now apache2

Ruby für Redmine installieren (Schritt 3.)

Redmine benötigt den Ruby Interpreter. Standesgemäß ist Ruby bereits auf Linux Ubuntu 22.04 out of the Box installiert. Um die aktuelle Version von Ruby zu überprüfen, kannst du den folgenden Befehl verwenden:

rubin-v

Die aktuelle Version von Redmine, die wir in diesem Tutorial installieren, trägt die Versionsnummer 5. Diese Version unterstützt Ruby 3.X. Sollte eine ältere Version von Ruby installiert sein oder Ruby überhaupt nicht vorhanden sein, kannst du Ruby mit dem folgenden Befehl installieren:

sudo apt install ruby-full

Ein Benutzerkonto für Redmine erstellen (Schritt 4.)

In diesem Abschnitt erstellen wir ein Benutzerkonto für Redmine. Dieses statten wir anschließend mit den notwendigen Benutzerrechten aus, indem wir das Systemkonto der Gruppe hinzufügen. Führe die folgenden Befehle der Reihe nach aus:

Benutzer anlegen:

useradd -r -m -d /opt/redmine -s /usr/bin/bash redmine

Benutzer des Apache-Webservers der Gruppe Redmine hinzufügen:

usermod -aG redmine www-data

Benutzer zur RVM-Gruppe hinzufügen:

usermod -aG rvm redmine

Eine Datenbank (MariaDB) für das Redmine-Ticketsystem installieren (Schritt 5.)

Jetzt installieren wir eine Datenbank für Redmine. Dafür eignet sich die Installation einer MariaDB unter Linux. Verwende den folgenden Befehl, um MariaDB auf deinem Server zu installieren:

sudo apt install mariadb-server

Starte die MariaDB mit dem folgenden Befehl und füge die Datenbank zum automatischen Systemstart deines Servers hinzu, damit MariaDB bei einem Systemneustart wieder selbstständig hochfährt:

sudo systemctl enable --now mariadb

Entferne die Default-Datenbank und deaktiviere die Remote-Login Funktion, falls nicht zwingend notwendig (sicherheitsrelevant). Das lässt sich per Shell-Skript mit diesem Befehl erledigen:

mysql_secure_installation

Datenbank erstellen und Datenbank-Benutzer anlegen (Schritt 6.)

Um eine Datenbank für das Redmine-Ticketsystem zu erstellen, müssen wir uns als Root-Benutzer an der MySQL-Datenbank anmelden:

mysql -u root -p

Datenbank mit dem Namen redminedb erstellen:

create database redminedb;

Datenbank-Benutzer anlegen und alle Rechte einräumen:

grant all on redminedb.* to redmine@localhost identified by 'Passwort';

Hinweis: Ändere den Benutzernamen nach Belieben und wähle ein sicheres Passwort für den Datenbank-Zugriff! Notiere dir den Benutzernamen und das Passwort. Diese Zugangsdaten werden im Schritt 8. für die Installation von Redmine benötigt.

Änderungen wirksam machen:

flush privileges;

Datenbank-Modus verlassen:

quit

Aktuelle Version von Redmine herunterladen und installieren (Schritt 7.)

Besuche die offizielle Webseite der Organisation und überprüfe, welche Versionsnummer zuletzt veröffentlicht worden ist. Zum Zeitpunkt dieser Installationsanleitung wurde Redmine 5.0.2 zum Download angeboten.

Release überprüfen: https://www.redmine.org/releases/

Notiere dir die momentan verfügbare Versionsnummer von Redmine

Erstelle eine Variable mit der aktuellen Versionsnummer: (ergänze den Wert mit der aktuellen Versionsnummer):

VER=5.0.2

Redmine herunterladen:

curl -s https://www.redmine.org/releases/redmine-$VER.tar.gz | sudo -u redmine tar xz -C /opt/redmine/ --strip-components=1

Redmine für Linux Ubuntu 22.04 konfigurieren (Schritt 8.)

Nachdem erfolgreichen Download und dem entpacken in das /opt/redmine Verzeichnis können wir uns der Konfiguration widmen.

Wechsel auf den Redmine-Benutzer mit diesem Befehl:

su - redmine

Erstelle Kopien der Beispieldateien mit den folgenden Befehlen:

cp /opt/redmine/config/configuration.yml.example configuration.yml

cp /opt/redmine/public/dispatch.fcgi.example dispatch.fcgi

cp /opt/redmine/config/database.yml.example database.yml

Datenbank-Login für Redmine Konfigurieren:

Verwende den Nano-Editor und füge die DB-Zugangsdaten, die im Schritt 6 notiert werden sollten, in die dafür vorgesehenen Bereiche ein (siehe Beispiel):

sudo nano /opt/redmine/config/database.yml

Beispielkonfiguration:

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

Speichere die Änderungen ab (STRG + S) und verlasse den Nano-Editor wieder (STRG + X).

Um mit der Redmine Installation und Konfiguration fortzufahren, wechseln wir wieder auf unseren Benutzerkonto mit Privilegien. Verwende dafür einfach den Logout-Befehl:

exit

Bundler-Umgebung für Ruby-Projekte installieren und Secret-Token generieren (Schritt 9.)

Da Redmine ein auf Ruby basierendes Projekt ist, installieren wir mit Bundler einen Manager zum Verwalten von sogenannten Gem-Abhängigkeiten für Ruby. Navigiere in das Redmine Installationsverzeichnis und fahre mit der Installation mit den folgenden Befehlen fort:

In das Redmine-Verzeichnis navigieren:

cd /opt/redmine

Bundler installieren:

sudo gem install bundler

Auf den Redmine-Benutzer wechseln:

su - redmine

Config erstellen:

bundle config set --local path 'vendor/bundle'

bundle install

Bundle Aktualisieren:

bundle update

Aktualisierte Gems installieren:

gem install io-wait strscan

Wir müssen noch einen Secret-Token generieren. Dieser wird dazu benötigt, damit Cookies und andere Sitzungsdaten nicht zwischengespeichert und manipuliert werden können.

Secret-Token generieren:

bundle exec rake generate_secret_token

Führe anschließend die zwei folgenden Befehle aus, um die Datenbank zu migrieren und eine Rails-Datenbankstruktur zu erstellen:

RAILS_ENV=production bundle exec rake db:migrate

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

Hinweis: Ruby-Warnungen, die während der Ausführung auftreten, können ignoriert werden.

Überprüfe, ob die folgenden Verzeichnisse im Redmine-Verzeichnis vorhanden sind:

Verzeichnisse:

  • tmp und tmp/pdf
  • public und public/plugin_assets
  • log
  • files
cd /opt/redmine/

ls

Sollten die genannten Verzeichnisse nicht existieren, können diese mit dem mkdir-Befehl nachträglich erstellt werden. Stelle dabei jedoch sicher, dass diese dem Redmine-Benutzer gehören:

for i in tmp tmp/pdf public/plugin_assets; do [ -d $i ] || mkdir -p $i; done
chown -R redmine:redmine files log tmp public/plugin_assets

chmod -R 755 /opt/redmine

Redmine auf Ubuntu 22.04 installieren: Firewall-Einstellungen vornehmen (Schritt 10.)

Die Installation von Redmine auf Linux Ubuntu 22.04 neigt sich dem Ende entgegen. Standardgemäß verwendet Redmine den TCP-Port 3000. Dieser muss für einen Zugriff noch in der Ubuntu-Firewall freigegeben werden. Dafür müssen wir wieder auf den privilegierten Benutzer wechseln und den Port nach außen hin für einen Zugriff freigeben:

Redmine-Benutzer ausloggen:

exit

Port 3000 in der Ubuntu-Firewall für den Zugriff auf Redmine freigeben:

sudo ufw allow 3000/tcp

Mit WEBrick kann der Zugriff nun überprüft werden. Wechsel wieder auf den Redmine-Benutzer und überprüfe die Korrektheit des Anwendungs-Ports:

su - redmine

bundle exec rails server -u webrick -e production

Die Installation von Redmine ist nun soweit fortgeschritten, dass wir im nächsten Schritt nur noch einige Anpassungen am Webserver vornehmen müssen. Wechsel dafür wieder auf den privilegierten Benutzer:

exit

Den Apache-Webserver für Redmine konfigurieren (Schritt. 11)

Damit das soeben installierte Redmine-Ticketsystem über die IP-Adresse und den Hostnamen vom Server erreichbar ist, konfigurieren wir in diesem Abschnitt die Virtualhost-Konfigurationsdatei für unseren Apache-Webserver.

Erstelle eine Virtualhost-Konfigurationsdatei und füge den folgenden Inhalt in die Datei ein:

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

Kopieren und Einfügen:

Listen 3000
<VirtualHost *:3000>
ServerName redmine.veuhoff.net
RailsEnv production
DocumentRoot /opt/redmine/public

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

ErrorLog ${APACHE_LOG_DIR}/redmine_error.log
CustomLog ${APACHE_LOG_DIR}/redmine_access.log combined
</VirtualHost>

Hinweis: Ändere den Servernamen auf die Domain, über die der Redmine-Server erreichbar sein soll und übernehme nicht diesen Beispielwert.

Speichere die Änderungen ab (STRG + S) und verlasse den Nano-Editor wieder (STRG + X).

Mit dem folgenden Befehl kann die Syntax auf Fehler überprüft werden:

apachectl configtest

Erhältst du die Ausgabe „Syntax OK“. Dann scheint soweit alles funktioniert zu haben. Abschließend benötigen wir noch das Passanger-Modul, welches wir mit diesem Befehl aktivieren:

a2enmod passenger

Die Redmine-Webanwendung kann mit diesem Befehl aktiviert werden:

sudo a2ensite redmine

Entferne noch die Beispielseite:

a2dissite 000-default.conf

Apache-Dienst neustarten, damit alle Änderungen wirksam werden:

sudo systemctl restart apache2

Überprüfe, ob Redmine auf den TCP-Port 3000 lauscht:

sudo lsof -i :3000
Redmine wurde erfolgreich installiert: IP-Adresse über den Browser aufrufen

Herzlichen Glückwunsch. Die Installation von Redmine auf Linux Ubuntu 22.04 ist abgeschlossen. Über den Browser kannst du jetzt auf die Weboberfläche zugreifen und dein Ticketsystem nach eigenen Vorstellungen einrichten.

Öffne die Redmine-Webanwendung über den Browser mit der Eingabe der IP-Adresse oder den Domainnamen gefolgt vom Port (siehe Beispiel):

http://192.168.178.150:3000

Das Admin-Login für den ersten Zugriff auf das Redmine-Dashboard (default Login):

Benutzername: admin

Passwort: admin

Hat dir dieser Beitrag weitergeholfen?

Über dein Follow auf den sozialen Medien würde ich mich sehr freuen. So erfährst du als erstes von neuen Beiträgen auf meinem Blog und unterstützt mich bei meinem Wachstum. Falls du an einem Schritt dieser Anleitung nicht weiterkommst, verwende die Kommentarfunktion und ich werde dir sobald wie möglich mit Rat und Tat zur Seite stehen. Vielen Dank für deinen Besuch.

Redmine Installation Tutorial für Linux-Administratoren

1 Kommentar on “Redmine Ticketsystem: Installation und Konfiguration für Linux Ubuntu 22.04

  1. ausgezeichnete Anleitung, vielen Dank. Hat mir auch für MX-Linux 21.2 sehr geholfen. Aber wenn man Ruby selbst aus den Quellen compiliert hat (weil man die neueste Ruby-Version möchte), sollte man für die entsprechenden Gems keinesfalls den Paketmanager benutzen, sondern z.B. gem install passenger. Sonst hat man am Ende zwei Ruby-Versionen (bei mir 2.5 und 3.1.2). Das funktioniert dann mit Webrick, aber nicht mit Apache. Aber klar, wer am Paketmanager vorbei was installiert muss mit solchen Problemen rechnen.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.