Redmine auf Rocky Linux mit PostgreSQL und Apache installieren

Führen Sie Ruby 2.7 per RVM, PostgreSQL und Phusion Passenger aus und konfigurieren Sie Apache/httpd als Frontend, um Redmine 4.2.3 unter /var/www/redmine bereitzustellen. Diese Anleitung führt Schritt für Schritt durch Voraussetzungen, Installation, VirtualHost‑Konfiguration, Tests, Fehlerbehebung, Security‑Hinweise und betriebsspezifische Checklisten.

Einführung

Redmine ist eine freie, quelloffene Webanwendung für Projektmanagement und Issue‑Tracking, hauptsächlich geschrieben in Ruby on Rails. Die Software ist plattformübergreifend, unterstützt mehrere Datenbanken und Sprachen und eignet sich für kleine bis große Organisationen. Typische Redmine‑Funktionen sind mehrprojektfähige Verwaltung, projektbezogene Wikis, Foren, Dateiverwaltung, Benachrichtigungen und Zeiterfassung.

Definition in einer Zeile: Redmine ist ein webbasiertes Issue‑Tracking- und Projektmanagement‑System auf Basis von Ruby on Rails.

Wichtige Varianten/Anwendungsfälle: Installation für Entwicklung, Test, Produktion; Betrieb mit Apache/httpd + Passenger oder Nginx + Passenger; Nutzung mit PostgreSQL, MySQL oder SQLite (nur für Tests).

Ziel und Anwendungsfall

Ziel dieser Anleitung: Redmine 4.2.3 auf Rocky Linux 8.4 (Beispiel‑Hostname redmine.example.com, IP 192.168.1.10) produktiv mit PostgreSQL und Apache/httpd + Phusion Passenger zu installieren. Die Anleitung ist für Administratoren mit Root‑Zugriff gedacht.

Diese Anleitung deckt:

• Installation von Abhängigkeiten und Systempaketen
• Installation von RVM und Ruby 2.7
• PostgreSQL‑Setup für Redmine
• Installation und Konfiguration von Redmine 4.2.3
• Installation von Phusion Passenger und Apache‑Integration
• VirtualHost für HTTP(S) mit Tipps für Let’s Encrypt
• Tests, häufige Fehler und Sicherheits‑/Datenschutz‑Hinweise
• Rollenspezifische Checklisten und Abnahmekriterien

Wichtig: Schließen Sie vorher die PostgreSQL‑Grundinstallation ab. Wenn Sie PostgreSQL noch nicht installiert haben, folgen Sie einer separaten Anleitung für PostgreSQL auf Rocky Linux.

Systemvoraussetzungen (Beispielumgebung)

• Betriebssystem: Rocky Linux 8.4 (Green Obsidian)
• IP-Adresse: 192.168.1.10
• Root‑Rechte / sudo
• Domain: redmine.example.com
• Zielinstallation: /var/www/redmine
• Redmine‑Version: 4.2.3
• Ruby: 2.7.x (per RVM)
• Datenbank: PostgreSQL
• Webserver: Apache/httpd mit Phusion Passenger

Abnahmekriterien (Kurzform):

• Redmine‑Login erreichbar unter https://redmine.example.com/login
• Default‑Account admin/admin kann sich anmelden und Passwort wird geändert
• Datenbankverbindung zur PostgreSQL ist aktiv und migrations erfolgreich
• Passenger läuft als Apache‑Modul ohne Fehlermeldungen

Vorbereitungen: Abhängigkeiten installieren

Alle folgenden Befehle als root oder mit sudo ausführen.

1. EPEL‑Repository hinzufügen:

sudo dnf install epel-release -y

2. Systempakete und Entwicklungswerkzeuge installieren:

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. Apache/httpd‑Entwicklerpakete installieren (für Passenger‑Integration):

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

Starten und aktivieren Sie httpd:

sudo systemctl enable --now httpd
sudo systemctl status httpd

Hinweis: Falls Firewalld aktiv ist, öffnen Sie Port 80/443:

sudo firewall-cmd --permanent --add-service=http
sudo firewall-cmd --permanent --add-service=https
sudo firewall-cmd --reload

Wichtiger Punkt: Verwenden Sie immer aktuelle Backups vor umfangreichen Änderungen.

RVM und Ruby 2.7 installieren

Redmine 4.2.x benötigt Ruby 2.7.x. Wir verwenden RVM (Ruby Version Manager), damit mehrere Ruby‑Versionen verwaltet werden können.

1. GPG‑Schlüssel der RVM‑Entwickler importieren:

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

2. RVM installieren und Umgebung laden:

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

3. RVM-Anforderungen prüfen und laden, dann Ruby installieren:

rvm reload
rvm requirements run
rvm install 2.7

4. Verifizieren:

rvm list
ruby --version

Hinweis: Falls Sie mehrere Ruby‑Versionen haben, setzen Sie systemweit oder projektspezifisch die gewünschte Version mit rvm use 2.7 –default.

PostgreSQL‑Datenbank für Redmine anlegen

Wichtig: Ersetzen Sie ‘StrongPasswordRedmine’ durch ein sicheres Passwort, das den Unternehmensrichtlinien entspricht.

1. In PostgreSQL‑Shell wechseln:

sudo -u postgres psql

2. Datenbankrolle und Datenbank anlegen:

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

3. psql verlassen mit \q

Sicherheitstipp: Beschränken Sie den Zugriff auf PostgreSQL über pg_hba.conf, verwenden Sie sichere Verbindungen (md5/peer/ident) und führen Sie regelmäßige Backups durch (pg_dump/pg_basebackup).

Redmine herunterladen und konfigurieren

1. Wechseln Sie nach /var/www, laden und entpacken Sie Redmine 4.2.3:

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

2. Datenbankkonfiguration erstellen:

export REDMINE=/var/www/redmine
cd $REDMINE
nano config/database.yml

Inhalt (passen Sie Benutzer/Passwort/DB an):

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

3. Bundler installieren und Abhängigkeiten einrichten:

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

4. Secret Token generieren und Datenbankmigration durchführen:

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

5. Dateiberechtigungen setzen:

sudo chown -R apache:apache $REDMINE

Hinweis: In Umgebungen mit SELinux müssen auch kontextspezifische Anpassungen vorgenommen werden (siehe SELinux‑Abschnitt weiter unten).

Passenger (Phusion Passenger) installieren und integrieren

Phusion Passenger ist ein Application Server, der Rails‑Apps zuverlässig hinter Apache oder Nginx betreibt.

1. Passenger als Gem installieren:

gem install passenger

2. Apache‑Modul bauen und installieren:

passenger-install-apache2-module

Folgen Sie den Anweisungen des Installers. Wählen Sie ‘Ruby’ als Anwendungstyp, wenn Sie dazu aufgefordert werden.

3. Passenger‑Konfiguration erstellen (Pfad abhängig von Ihrer RVM/Ruby‑Installation). Beispiel aus Installer:

   LoadModule passenger_module /usr/local/rvm/gems/ruby-2.7.2/gems/passenger-6.0.12/buildout/apache2/mod_passenger.so
   
     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
   

Erstellen Sie /etc/httpd/conf.d/passenger.conf und fügen Sie die Zeilen ein.

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

Nachdem Sie die Datei gespeichert haben, starten Sie httpd neu:

sudo systemctl restart httpd

Wenn keine Fehler auftreten, zeigt der Installer am Ende Erfolgsmeldungen an.

Apache VirtualHost für Redmine konfigurieren

Erstellen Sie /etc/httpd/conf.d/redmine.conf und passen Sie ServerName und Pfade an.

Beispiel HTTP (Port 80):

PassengerRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby


    ServerName redmine.example.io
    DocumentRoot "/var/www/redmine/public"

    ErrorLog logs/redmine_error_log
    LogLevel warn

    
        Options Indexes ExecCGI FollowSymLinks
        Require all granted
        AllowOverride all
    

Beispiel HTTPS (Port 443) mit Redirect von 80 nach 443:

PassengerRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby


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



  ServerName redmine.example.io
  Protocols h2 http/1.1

  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

  
    Options Indexes ExecCGI FollowSymLinks
    Require all granted
    AllowOverride all
  

Prüfen und Neu starten:

apachectl configtest
sudo systemctl restart httpd

Hinweis zu Let’s Encrypt: Nutzen Sie certbot, um Zertifikate automatisch zu verwalten. Aktivieren Sie mod_ssl falls nötig: sudo dnf install mod_ssl -y

Redmine prüfen (Erstzugang)

Öffnen Sie den Browser: https://redmine.example.io/login

Default‑Login:

• Benutzername: admin
• Passwort: admin

Bei Erstanmeldung müssen Sie das Passwort ändern.

Nach dem Setzen des neuen Passworts können Sie Kontodetails bearbeiten und die Sprache sowie die Standardkonfiguration laden.

Abschließende Kontrolle: Überprüfen Sie, dass die Versionsinformationen und Abhängigkeiten angezeigt werden, und legen Sie ggf. Plugins oder SMTP‑Einstellungen an.

Fehlerbehebung (Troubleshooting)

Häufige Probleme und Prüfungen:

• Passenger oder Apache startet nicht: Prüfen Sie /var/log/httpd/error_log und die Ausgabe von apachectl configtest.
• Bundler‑Fehler beim bundle install: Stellen Sie sicher, dass systemweite Abhängigkeiten (libxml2, ImageMagick, readline) installiert sind; lesen Sie die Fehlermeldungen und installieren Sie fehlende -devel Pakete.
• Datenbankmigration schlägt fehl: Prüfen Sie database.yml auf Syntaxfehler und testen Sie die Verbindung mit psql -U redmine -d redminedb.
• Berechtigungsprobleme: chown -R apache:apache /var/www/redmine ; prüfen Sie SELinux‑Kontext:

sudo restorecon -Rv /var/www/redmine
sudo chcon -R -t httpd_sys_content_t /var/www/redmine
sudo chcon -R -t httpd_sys_rw_content_t /var/www/redmine/tmp /var/www/redmine/log /var/www/redmine/public/plugin_assets

• Probleme mit passgen oder Apache‑Modulpfaden: Stellen Sie sicher, dass die in passenger.conf verwendeten Pfade zu Ihrer RVM/Gem‑Installation passen; rvm gem list | grep passenger zeigt die Version.

Fehlerbeispiel: “Permission denied @ rb_sysopen” → Dateisystemrechte / SELinux prüfen.

Sicherheit, Updates und Datenschutz

Sicherheitsempfehlungen:

• Setzen Sie starke Passwörter und aktivieren Sie 2‑Faktor‑Authentifizierung über Plugins, wenn möglich.
• Hosten Sie Redmine hinter HTTPS (Let’s Encrypt oder kommerzielles Zertifikat).
• Minimieren Sie Apache‑Module und Dienste auf dem Server.
• Automatisieren Sie Backups der PostgreSQL‑Datenbank (z. B. tägliche pg_dump‑Jobs) und der Redmine‑Dateien (/var/www/redmine/files und /public/plugin_assets).
• Rollenbasierte Rechteverwaltung: Erstellen Sie nur die notwendigen Rollen mit granularen Rechten.
• Entfernen Sie den Default‑Account oder ändern Sie das Standardpasswort unmittelbar nach Installation.

Datenschutz/GDPR Hinweise:

• Prüfen Sie personenbezogene Daten in Issues/Wiki/Anhängen; definieren Sie Aufbewahrungsfristen.
• Dokumentieren Sie Datenverarbeitungszwecke und Verantwortlichkeiten.
• Wenn Redmine externe SMTP‑Server oder OAuth verwendet, konfigurieren Sie sichere Verbindungen (TLS) und prüfen Sie Anbieter‑Standorte.

Rollenspezifische Checklisten

Administrator (System):

• Betriebssystem‑Updates planen und testen
• TLS/HTTPS konfigurieren und Erneuerung testen
• Automatisierte Backups und Restore‑Tests einrichten
• Monitoring für Apache, Passenger, PostgreSQL einrichten
• SELinux/Firewall‑Regeln prüfen

Entwickler/Plugin‑Manager:

• Kompatibilität von Plugins mit Redmine‑Version prüfen
• Entwicklungsumgebung spiegeln (Ruby, Gems)
• Testmigrationen vor Prod‑Installationen durchführen
• Release‑Notes und Breaking‑Changes lesen

Betrieb/Support:

• Standard‑Troubleshooting‑Skripte bereitstellen
• Zugriffskontrolle und Rollen dokumentieren
• Vorfall‑ und Rollback‑Prozeduren vorbereiten

Auditor/Compliance:

• Backup‑ und Restore‑Logs prüfen
• Benutzer‑ und Rollenvergabe auditieren
• Datentransfer zu Drittsystemen dokumentieren

Abnahme- und Testkriterien

Basis‑Akzeptanztests (Abnahmekriterien):

• Webzugriff: Login‑Seite ist erreichbar (HTTP 200/Redirect zu HTTPS)
• Authentifizierung: admin kann Passwort ändern und neue Benutzer anlegen
• Datenbank: db:migrate lief ohne Fehler und Tabellen sind erstellt
• Dateiupload: Dateien in Projekten lassen sich anfügen und herunterladen
• Logs: Keine kritischen Fehler in /var/log/httpd/* oder production.log

Testfälle (Beispiele):

1. Anlegen eines Projekts, Erstellen eines Issues, Zuweisung an einen Benutzer, Statuswechsel.
2. SMTP‑Konfiguration testen: E‑Mails für Benachrichtigungen auslösen.
3. Backup/Restore: DB Dump erstellen und in Testsystem wiederherstellen.

Migration und Kompatibilitätshinweise

• Migration von SQLite nach PostgreSQL: Datenexport/Import mithilfe von rake tasks oder Datenbank‑Dumps; Testmigration in isolierter Umgebung.
• Wechsel von MySQL zu PostgreSQL erfordert Datenkonvertierung und Anpassung von database.yml; prüfen Sie SQL‑kompatible Funktionen in Plugins.
• Achten Sie auf Ruby/Gem‑Versionen: Manche Plugins benötigen neuere/ältere Ruby‑Versionen.

Mini‑Methodik / SOP (Kurzworkflow für produktive Installation)

1. System‑Baseline prüfen (OS‑Updates, Firewall, Zeitserver)
2. EPEL & Abhängigkeiten installieren
3. RVM + Ruby installieren und testen
4. PostgreSQL anlegen und testen
5. Redmine entpacken, database.yml anlegen
6. bundle install, db:migrate, secret token erzeugen
7. Passenger installieren, passenger.conf erstellen
8. Apache VirtualHost erstellen (incl. HTTPS) und testen
9. Berechtigungen, SELinux, Logs prüfen
10. Erstanmeldung, Passwortänderung, Grundeinstellungen
11. Backup‑Job und Monitoring einrichten

Kurzes Cheat Sheet (Kommandos)

• Apache testen: apachectl configtest
• Apache neu starten: sudo systemctl restart httpd
• PostgreSQL psql als postgres user: sudo -u postgres psql
• RVM Ruby installieren: rvm install 2.7
• Bundler: gem install bundler ; bundle install
• Secret token und Migration: bundle exec rake generate_secret_token ; RAILS_ENV=production bundle exec rake db:migrate

SELinux‑Hinweise (wenn aktiviert)

Wenn SELinux aktiviert ist und Probleme auftreten, führen Sie folgende Schritte aus:

sudo chcon -R -t httpd_sys_rw_content_t /var/www/redmine/tmp /var/www/redmine/log /var/www/redmine/public/plugin_assets
sudo restorecon -Rv /var/www/redmine

Prüfen Sie audit.log auf AVC‑Denial‑Einträge: sudo ausearch -m avc -ts recent

Plugins, SMTP und weitere Erweiterungen

• SMTP: Konfigurieren Sie config/configuration.yml für Produktion oder nutzen Sie Umgebungsvariablen.
• Plugins: Entpacken Sie Plugins nach /var/www/redmine/plugins und führen Sie:

RAILS_ENV=production bundle exec rake redmine:plugins:migrate

Achten Sie auf Plugin‑Kompatibilität zur Redmine‑Version.

Wartung und Betrieb

• Regelmäßig ruby gems und System‑Patches prüfen
• Testumgebung für Updates pflegen
• Protokollrotation für Redmine‑Logs einrichten (logrotate)
• Monitoring: Verfügbarkeit, Antwortzeiten, DB‑Leistung

Häufige Fehlerbeispiele und Gegenmaßnahmen

• “Could not find gem ‘mysql2’” → falscher Adapter in database.yml / fehlendes Gem; für PostgreSQL gem ‘pg’ nutzen.
• “Permission denied” beim Schreiben in tmp/log → Dateirechte prüfen und Apache‑Benutzer zuweisen.
• Passenger zeigt falsche Ruby‑Version an → PassengerDefaultRuby in passenger.conf anpassen auf RVM‑Wrapper.

Faktenbox (Kernaussagen)

• Redmine 4.2.3 benötigt Ruby >= 2.7 für volle Kompatibilität.
• Empfehlte Produktionsdatenbank: PostgreSQL (stabil, mächtig bei großen Instanzen).
• Gängiger Installationspfad: /var/www/redmine
• Webserver: Apache + Passenger oder Nginx + Passenger

Glossar (1‑Zeiler)

• RVM: Ruby Version Manager, verwaltet mehrere Ruby‑Versionen.
• Passenger: Application Server zur Ausführung von Rails‑Apps hinter Apache/Nginx.
• Bundler: Gem‑Abhängigkeitsmanager für Ruby.
• db:migrate: Rails‑Task, der Datenbankschemaänderungen anwendet.

Zusammenfassung

Diese Anleitung beschreibt eine bewährte Vorgehensweise, um Redmine 4.2.3 unter Rocky Linux 8.4 mit PostgreSQL und Apache/httpd + Phusion Passenger produktiv zu betreiben. Folgen Sie den Schritten 1:1, testen Sie Migrationen in einer Staging‑Umgebung und beachten Sie die Sicherheits‑ und Datenschutzhinweise. Nach Abschluss sollten Sie Monitoring, regelmäßige Backups und ein Update‑Prozedere einrichten.

Wichtiger Hinweis: Passen Sie alle Passwörter, Domain‑Namen und Pfade an Ihre Produktionsumgebung an.

Viel Erfolg bei der Installation und beim Betrieb Ihrer Redmine‑Instanz!