Redmine auf CentOS 8 mit Nginx installieren

Redmine ist ein freies, webbasiertes Projektmanagement- und Fehlermanagement-Tool. Diese Anleitung führt Schritt für Schritt durch Installation, Konfiguration von MariaDB, Ruby/Passenger, Erstellung eines systemd-Dienstes und Einrichtung von Nginx als Reverse Proxy auf CentOS 8. Am Ende läuft Redmine unter einer Domain auf Port 80, während die Anwendung intern auf Port 3000 betrieben wird.

Worum es hier geht

• Ziel: Redmine 4.x auf CentOS 8 betreiben und über Nginx bereitstellen.
• Zielgruppe: Systemadministratoren und DevOps-Ingenieure mit Basis-Kenntnissen in Linux.

Wichtige Begriffe in einer Zeile

• Redmine: Open-Source-Projektmanagement- und Issue-Tracker.
• MariaDB: MySQL-kompatible relationale Datenbank.
• Passenger / WEBrick: Ruby-Anwendungsserver (Passenger empfohlen für Produktion).

Voraussetzungen

• Ein Server mit CentOS 8.
• Root-Zugang oder ein Benutzer mit sudo-Rechten.
• Grundlegendes Wissen zu systemd, firewalld und Nginx.

Wichtig

Prüfen Sie vorab verfügbare Paketversionen und Repositories auf Ihrem System. CentOS 8 hat verschiedene EOL- und Repository-Szenarien; passen Sie die Anleitung an Ihre Umgebung an.

Benötigte Abhängigkeiten installieren

Installieren Sie die Build-Tools und Bibliotheken:

dnf group install "Development Tools"
dnf install zlib-devel curl-devel openssl-devel -y

Sobald die Pakete installiert sind, fahren Sie mit der Datenbankinstallation fort.

MariaDB installieren und konfigurieren

Redmine benötigt eine relationale Datenbank. In diesem Beispiel verwenden wir MariaDB.

dnf install mariadb-server mariadb-devel -y

Starten und aktivieren Sie MariaDB:

systemctl start mariadb
systemctl enable mariadb

Datenbank und Benutzer anlegen:

mysql

Im MariaDB-Shell:

MariaDB [(none)]> CREATE DATABASE redmine CHARACTER SET utf8mb4;
MariaDB [(none)]> GRANT ALL PRIVILEGES ON redmine.* TO 'redmine'@'localhost' IDENTIFIED BY 'password';
MariaDB [(none)]> FLUSH PRIVILEGES;
MariaDB [(none)]> EXIT;

Hinweis

• Ersetzen Sie ‘password’ durch ein sicheres Passwort. Verwenden Sie ein Passwort-Management-Tool.
• utf8mb4 stellt sicher, dass Emojis und 4-Byte-Zeichen korrekt gespeichert werden.

Ruby und Passenger installieren

Fügen Sie das EPEL-Repository hinzu und aktivieren Sie es:

dnf install epel-release -y
dnf config-manager --enable epel -y

Installieren Sie Passenger und Ruby:

dnf install mod_passenger passenger passenger-devel ruby ruby-devel -y

Wichtig

Für Produktionsumgebungen ist Phusion Passenger in Verbindung mit Nginx oder Apache die stabilere Wahl. WEBrick ist primär für Entwicklung und Tests geeignet.

Redmine herunterladen und installieren

Erstellen Sie einen dedizierten Systembenutzer für Redmine:

useradd -m -U -r -d /opt/redmine redmine

Als Redmine-Benutzer einloggen und die aktuelle Redmine-Version herunterladen:

su - redmine
wget --no-check-certificate https://www.redmine.org/releases/redmine-4.2.1.zip
unzip redmine-4.2.1.zip
mv redmine-4.2.1 redmine
cd redmine
cp config/database.yml.example config/database.yml

Datenbankkonfiguration anpassen:

nano config/database.yml

Ändern Sie den Abschnitt für production entsprechend:

production:
  adapter: mysql2
  database: redmine
  host: localhost
  username: redmine
  password: "password"
  encoding: utf8mb4

Speichern und schließen Sie die Datei.

Bundler installieren und Abhängigkeiten beziehen:

gem install bundler --no-rdoc --no-ri
bundle install --without development test postgresql sqlite --path vendor/bundle

Geheimtoken erzeugen und Datenbank migrieren:

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

Anwendung temporär starten (Entwicklung/Test):

bundle exec rails server webrick -e production

Sie sehen eine Ausgabe ähnlich dieser:

/usr/bin/ruby: warning: shebang line ending with \r may cause problems
=> Booting WEBrick
=> Rails 5.2.5 application starting in production on http://0.0.0.0:3000
=> Run `rails server -h` for more startup options
[2021-06-24 00:40:15] INFO  WEBrick 1.4.2
[2021-06-24 00:40:15] INFO  ruby 2.5.5 (2019-03-15) [x86_64-linux]
[2021-06-24 00:40:15] INFO  WEBrick::HTTPServer#start: pid=43076 port=3000

Drücken Sie STRG + C, um WEBrick zu stoppen. Dann mit exit die redmine-Sitzung verlassen.

exit

Wichtig

WEBrick ist für Tests geeignet. Für Produktionsbetrieb konfigurieren Sie Passenger (empfohlen) oder Puma und betreiben die App hinter Nginx oder Apache.

systemd-Dienst für Redmine anlegen

Erstellen Sie eine systemd-Unit, damit Redmine als Dienst läuft:

nano /usr/lib/systemd/system/redmine.service

Inhalt der Datei:

[Unit]
Description=Redmine server
After=syslog.target
After=network.target

[Service]
Type=simple
User=redmine
Group=redmine
ExecStart=/bin/ruby /opt/redmine/redmine/bin/rails server webrick -e production

# Give a reasonable amount of time for the server to start up/shut down
TimeoutSec=300

[Install]
WantedBy=multi-user.target

Dienst neu laden und starten:

systemctl daemon-reload
systemctl start redmine
systemctl enable redmine
systemctl status redmine

Überprüfen, ob der Prozess auf Port 3000 hört:

ss -antpl | grep 3000

Nginx als Reverse Proxy konfigurieren

Installieren Sie Nginx:

dnf install nginx -y

Nginx-Virtual-Host anlegen:

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

Konfiguration (passen Sie server_name an):

upstream backend {
  server 127.0.0.1:3000;
}

server {
    listen 80;
    server_name redmine.example.com;
    access_log /var/log/nginx/redmine.example.com-access.log;
    error_log /var/log/nginx/redmine.example.com-error.log;

    location / {
        proxy_pass http://backend/;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $http_host;

        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forward-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forward-Proto http;
        proxy_set_header X-Nginx-Proxy true;
        proxy_redirect off;
    }
}

Syntax prüfen, starten und aktivieren:

nginx -t
systemctl start nginx
systemctl enable nginx
systemctl status nginx

Redmine im Browser aufrufen

Öffnen Sie im Browser: http://redmine.example.com

Sie sehen die Startseite und können sich anmelden.

Der Standardbenutzer ist admin mit dem Passwort admin (ändern Sie das Passwort sofort nach dem ersten Login):

Sicherheit und Betriebsreife

Wesentliche Schritte vor dem produktiven Einsatz:

• SSL/TLS erzwingen: Terminate SSL in Nginx (Let’s Encrypt/ACME-Client empfohlen).
• Service-Monitoring: systemd, Prometheus-Exporter oder externes Monitoring einrichten.
• Backups: Regelmäßiges Dumpen der MariaDB-Datenbank und Sichern des Verzeichnisses files/ aus dem Redmine-Installationspfad.
• Dateiberechtigungen: Redmine-Verzeichnis dem Benutzer redmine zuordnen.

Sichere Berechtigungen setzen:

chown -R redmine:redmine /opt/redmine
find /opt/redmine -type d -exec chmod 750 {} \;
find /opt/redmine -type f -exec chmod 640 {} \;

Wenn etwas schiefgeht häufige Fehler und Lösungen

• Problem: bundle install schlägt fehl wegen fehlender native Erweiterungen. Lösung: Stellen Sie sicher, dass gcc, make und die dev-Pakete installiert sind (Development Tools, ruby-devel).

• Problem: Redmine startet, aber Nginx zeigt 502 Bad Gateway. Lösung: Prüfen Sie, ob der Redmine-Prozess läuft und auf 127.0.0.1:3000 hört. Überprüfen Sie Nginx-Error-Log.

• Problem: Zeichensatzprobleme (� oder Fragezeichen). Lösung: Datenbank und Redmine auf utf8mb4 einstellen, ggf. Migrationen neu prüfen.

Alternative Ansätze

• Passenger mit Nginx Modul (Produktionsreif): Passenger integriert sich direkt in Nginx und vereinfacht das Prozessmanagement.
• Puma als App-Server hinter systemd und Nginx: modern, performant und häufig für Rails-Anwendungen verwendet.
• Containerisierung mit Docker und Orchestrierung (Kubernetes) für skalierbare Deployments.

Mini-Methodologie für produktive Rollouts

1. Testumgebung aufsetzen mit identischen Versionen (OS, Ruby, Redmine).
2. Automatisierte Konfiguration per Ansible/Chef/Puppet erstellen.
3. Backup- und Wiederherstellungsprozedur testen.
4. Staged Rollout: Erst interne Nutzer, danach produktiv.
5. Monitoring und Alerts einrichten.

Rollenspezifische Checkliste

Systemadministrator

• Repositories prüfen und sichern.
• MariaDB konfigurieren und absichern.
• Dienstüberwachung konfigurieren.

DevOps

• Automatisierte Deploys erstellen (CI/CD).
• Secrets-Management implementieren.
• Skalierungstests durchführen.

Anwendungsbetreuer

• Benutzer und Rollen in Redmine anlegen.
• Backup-Intervalle und Restore-Dokumentation pflegen.

Akzeptanzkriterien

• Redmine ist unter der konfigurierten Domain erreichbar.
• Anmeldung als Admin ist möglich und Passwortänderung funktioniert.
• Repositories/Dateianhänge werden korrekt gespeichert und wiederherstellbar.
• Logs und Monitoring liefern aussagekräftige Hinweise bei Fehlern.

Kurze Glossarzeile

• systemd: Init-System und Service-Manager unter modernen Linux-Distributionen.
• Nginx: Leichtgewichtiger Webserver und Reverse Proxy.
• Bundler: Ruby-Abhängigkeitsmanager.

Fact Box mit wichtigen Eckdaten

• Redmine-Version in Anleitung: 4.2.1
• Rails-Version in Beispielausgabe: 5.2.5
• Ruby-Version in Beispielausgabe: 2.5.5
• Standard-Application-Port: 3000
• Zielport für externe Anfragen: 80 (HTTP) bzw. 443 (HTTPS)

Datenschutzhinweise (GDPR)

• Redmine speichert Nutzerdaten und Tickets. Prüfen Sie vor Produktivbetrieb, welche personenbezogenen Daten erfasst werden.
• Implementieren Sie Zugriffsbeschränkungen und Protokollierung, begrenzen Sie die Aufbewahrungsdauer personenbezogener Einträge entsprechend gesetzlichen Vorgaben.

Testfälle und Akzeptanztests

• Login-Test: Admin kann sich anmelden und Passwort ändern.
• Projekt anlegen: Projekt erstellen und Beschreibung speichern.
• Dateiupload: Datei an ein Ticket anhängen und wieder herunterladen.
• Backup/Restore: Datenbank-Dump erstellen und in Testumgebung importieren.

Fazit

Sie haben Redmine auf CentOS 8 installiert, die Anwendung als systemd-Dienst eingerichtet und Nginx als Reverse Proxy konfiguriert. Für produktive Umgebungen empfiehlt sich die Umstellung auf Passenger oder Puma, TLS-Termination in Nginx sowie automatisierte Backups und Monitoring.

Wichtige nächste Schritte

• TLS-Zertifikat mit Let’s Encrypt einrichten.
• Wechsel auf Passenger oder Puma für bessere Stabilität.
• Deployment-Automatisierung (Ansible/CICD).