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 einem 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 dem First- und Second-Level-Support und den 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.)
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 unserem 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 so weit 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 so weit 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
PhotoPrism: Eine Open-Source-Software für die Verwaltung von Fotos und Bilder (Inkl. Installation unter Linux Ubuntu 24.04)
Weiterlesen »
Hallo,
bei Aufruf des Befehl
sudo nano /opt/redmine/config/database.yml
will er ein Passwort für den Redmine user, daran scheitere ich aber
Habs das Redmine Ticketsystem auf unseren Firmenserver mit Rocky Linux nach deiner Anleitung installiert. Hat sehr gut funktioniert die Installation. Finde cool dass die Software noch Open-Source ist, es gibt heute zwar viele Alternativen für Ticketsysteme, aber unter Linux denke ich ist Redmine schon die beste Wahl, wenn man kein Geld ausgeben möchte. Danke für die Mühe lieber Alexander
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.