Redmine 3.4.4 auf CentOS 7 installieren mit Apache & SSL

Redmine ist ein leistungsfähiges, kostenloses und quelloffenes Projektmanagement-Tool. Es basiert auf dem Ruby-on-Rails-Framework, läuft webbasiert und kann mit verschiedenen Datenbanksystemen betrieben werden. Zu den umfangreichen Funktionen gehören Multi-Projekt-Unterstützung, rollenbasierte Zugriffskontrolle und ein integriertes Ticketsystem. Weitere Features umfassen Gantt-Diagramme, Kalender, Dateiverwaltung, projektbezogene Wikis und Foren sowie Kompatibilität mit Versionskontrollsystemen wie Git, SVN und CVS. Redmine ist mehrsprachig und unterstützt bis zu 49 Sprachen.

Diese Anleitung wurde für Redmine Version 3.4.4 verfasst, ist aber möglicherweise auch auf neuere Versionen anwendbar.

Systemvoraussetzungen

• Ein aktiver CentOS 7 Server
• Ein Benutzerkonto mit sudo-Rechten
• Eine auf den Server verweisende Domain

In diesem Beispiel wird die IP-Adresse 192.168.1.1 und die Domain redmine.example.com verwendet. Ersetze diese Werte durch deine tatsächliche IP-Adresse und Domain.

Stelle sicher, dass dein CentOS 7 System vor Beginn auf dem neuesten Stand ist. Siehe dazu die Anleitung How to Update CentOS 7. Nach dem Update kannst du mit der Installation der erforderlichen Pakete fortfahren.

Apache installieren

Da Redmine auf Ruby on Rails basiert, wird Phusion Passenger benötigt, um die Anwendung über Apache bereitzustellen. Installiere zuerst Apache:

sudo yum -y install httpd httpd-devel libcurl-devel

Um Redmine zu kompilieren, sind zusätzliche Entwicklungswerkzeuge erforderlich. Installiere diese mit folgendem Befehl:

sudo yum -y install ImageMagick ImageMagick-devel git libxml2-devel libxslt-devel gcc bzip2 openssl-devel zlib-devel gdbm-devel ncurses-devel autoconf automake bison gcc-c++ libffi-devel libtool patch readline-devel sqlite-devel glibc-headers glibc-devel libyaml-devel libicu-devel libidn-devel

PostgreSQL für Redmine unter CentOS 7 einrichten

Redmine unterstützt verschiedene Datenbanksysteme wie MySQL, MSSQL und PostgreSQL. In dieser Anleitung verwenden wir PostgreSQL als Datenbank für Redmine.

PostgreSQL ist ein modernes objekt-relationales Datenbanksystem. Da das standardmäßige CentOS-Repository nur eine veraltete Version enthält, wird zunächst das offizielle PostgreSQL-Repository hinzugefügt:

sudo yum -y install https://download.postgresql.org/pub/repos/yum/10/redhat/rhel-7-x86_64/pgdg-centos10-10-1.noarch.rpm

Installiere nun den PostgreSQL-Server und zusätzliche Komponenten:

sudo yum -y install postgresql10-server postgresql10-contrib postgresql10

Initialisiere anschließend das Datenverzeichnis von PostgreSQL:

sudo /usr/pgsql-10/bin/postgresql-10-setup initdb

Aktiviere den automatischen Start des Dienstes und starte ihn sofort:

sudo systemctl start postgresql-10
sudo systemctl enable postgresql-10

Setze ein Passwort für den voreingestellten Benutzer postgres:

sudo passwd postgres

Wechsle in die PostgreSQL-Benutzerumgebung:

sudo su - postgres

Lege einen neuen PostgreSQL-Benutzer für Redmine an (Name frei wählbar):

createuser redmine

Starte die PostgreSQL-Shell:

psql

Vergib nun ein Passwort für den zuvor erstellten Benutzer:

ALTER USER redmine WITH ENCRYPTED password 'DBPassword';

Ersetze DBPassword durch ein sicheres Kennwort. Lege anschließend die Redmine-Datenbank an und übertrage dem Benutzer die Rechte:

CREATE DATABASE redmine WITH ENCODING='UTF8' OWNER=redmine;

Verlasse die psql-Konsole:

\q

Wechsle zurück zum ursprünglichen sudo-Nutzer:

exit

Bearbeite nun die Datei pg_hba.conf, um die Authentifizierungsmethode auf md5 umzustellen:

sudo nano /var/lib/pgsql/10/data/pg_hba.conf

Ändere die Datei wie folgt ab:

# TYPE  DATABASE        USER            ADDRESS                 METHOD

# "local" is for Unix domain socket connections only
local   all             all                                     trust
# IPv4 local connections:
host    all             all             127.0.0.1/32            md5
# IPv6 local connections:
host    all             all             ::1/128                 md5

Starte den PostgreSQL-Dienst neu, damit die Änderungen aktiv werden:

sudo systemctl restart postgresql-10

Installiere zum Schluss noch zusätzliche PostgreSQL-Bibliotheken, die Redmine benötigt:

sudo yum -y install libpqxx-devel protobuf-devel

PostgreSQL für Redmine unter CentOS 7 einrichten

Redmine unterstützt verschiedene Datenbanksysteme wie MySQL, MSSQL und PostgreSQL. In dieser Anleitung verwenden wir PostgreSQL als Datenbank für Redmine.

PostgreSQL ist ein modernes objekt-relationales Datenbanksystem. Da das standardmäßige CentOS-Repository nur eine veraltete Version enthält, wird zunächst das offizielle PostgreSQL-Repository hinzugefügt:

sudo yum -y install https://download.postgresql.org/pub/repos/yum/10/redhat/rhel-7-x86_64/pgdg-centos10-10-1.noarch.rpm

Installiere nun den PostgreSQL-Server und zusätzliche Komponenten:

sudo yum -y install postgresql10-server postgresql10-contrib postgresql10

Initialisiere anschließend das Datenverzeichnis von PostgreSQL:

sudo /usr/pgsql-10/bin/postgresql-10-setup initdb

Aktiviere den automatischen Start des Dienstes und starte ihn sofort:

sudo systemctl start postgresql-10
sudo systemctl enable postgresql-10

Setze ein Passwort für den voreingestellten Benutzer postgres:

sudo passwd postgres

Wechsle in die PostgreSQL-Benutzerumgebung:

sudo su - postgres

Lege einen neuen PostgreSQL-Benutzer für Redmine an (Name frei wählbar):

createuser redmine

Starte die PostgreSQL-Shell:

psql

Vergib nun ein Passwort für den zuvor erstellten Benutzer:

ALTER USER redmine WITH ENCRYPTED password 'DBPassword';

Ersetze DBPassword durch ein sicheres Kennwort. Lege anschließend die Redmine-Datenbank an und übertrage dem Benutzer die Rechte:

CREATE DATABASE redmine WITH ENCODING='UTF8' OWNER=redmine;

Verlasse die psql-Konsole:

\q

Wechsle zurück zum ursprünglichen sudo-Nutzer:

exit

Bearbeite nun die Datei pg_hba.conf, um die Authentifizierungsmethode auf md5 umzustellen:

sudo nano /var/lib/pgsql/10/data/pg_hba.conf

Ändere die Datei wie folgt ab:

# TYPE  DATABASE        USER            ADDRESS                 METHOD

# "local" is for Unix domain socket connections only
local   all             all                                     trust
# IPv4 local connections:
host    all             all             127.0.0.1/32            md5
# IPv6 local connections:
host    all             all             ::1/128                 md5

Starte den PostgreSQL-Dienst neu, damit die Änderungen aktiv werden:

sudo systemctl restart postgresql-10

Installiere zum Schluss noch zusätzliche PostgreSQL-Bibliotheken, die Redmine benötigt:

sudo yum -y install libpqxx-devel protobuf-devel

Ruby und Phusion Passenger für Redmine installieren

Um eine bessere Trennung und Sicherheit zu gewährleisten, sollte Redmine nicht als Root-Benutzer ausgeführt werden. Lege daher einen separaten Benutzer an und wechsle zu diesem:

sudo adduser redmine
sudo su - redmine

Zur Installation und Verwaltung von Ruby-Versionen wird RVM (Ruby Version Manager) verwendet. Importiere zunächst die notwendigen GPG-Schlüssel:

gpg --keyserver hkp://keys.gnupg.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB

Installiere RVM und lade die RVM-Umgebung:

curl -sSL https://get.rvm.io | bash -s stable
source ~/.rvm/scripts/rvm

Zeige alle verfügbaren Ruby-Versionen an:

rvm list known

Installiere aus der Liste die gewünschte Ruby-Version und aktiviere sie direkt im Anschluss:

rvm install 2.4
rvm use 2.4

Prüfe die installierte Ruby-Version:

ruby -v

Beispielausgabe:

[redmine@centron ~]$ ruby -v
ruby 2.4.1p111 (2017-03-22 revision 58053) [x86_64-linux]

Installiere nun Bundler, den Paketmanager für Ruby-Abhängigkeiten:

gem install bundler

Phusion Passenger installieren

Als Nächstes wird Phusion Passenger installiert, um Ruby mit dem Apache-Webserver zu verbinden:

gem install passenger

Stelle sicher, dass der Benutzerordner von Redmine ausführbar ist, damit Passenger darauf zugreifen kann:

chmod o+x "/home/redmine"

Installiere nun das Apache-Modul für Passenger:

passenger-install-apache2-module

Während der Installation zeigt das Skript eine Übersicht an und fordert zur Auswahl der Programmiersprache auf. Wähle Ruby aus und bestätige mit Enter.

Passenger prüft anschließend die Systemanforderungen, kompiliert das Modul und installiert es automatisch, sofern keine Fehler auftreten.

Nach erfolgreicher Installation erscheint ein Konfigurationsbeispiel, das später in Apache eingefügt werden muss:

LoadModule passenger_module /home/redmine/.rvm/gems/ruby-2.4.1/gems/passenger-5.1.12/buildout/apache2/mod_passenger.so

  PassengerRoot /home/redmine/.rvm/gems/ruby-2.4.1/gems/passenger-5.1.12
  PassengerDefaultRuby /home/redmine/.rvm/gems/ruby-2.4.1/wrappers/ruby

Drücke Enter, um diesen Schritt zu überspringen – der aktuelle Benutzer hat keine sudo-Rechte. Die Konfiguration wird später im Tutorial ergänzt.

Am Ende überprüft das Installationsskript die Umgebung. Es kann eine Warnung anzeigen, wenn die Apache-Konfigurationsdatei die Passenger-Direktiven noch nicht enthält:

Validating installation...

 * Checking whether this Passenger install is in PATH... ✓
 * Checking whether there are no other Passenger installations... ✓
 * Checking whether Apache is installed... ✓
 * Checking whether the Passenger module is correctly configured in Apache... (!)

   You did not specify 'LoadModule passenger_module' in any of your Apache
   configuration files. Please paste the configuration snippet that this
   installer printed earlier, into one of your Apache configuration files, such
   as /etc/httpd/conf/httpd.conf.

Detected 0 error(s), 1 warning(s).
Press ENTER to continue.

Phusion Passenger wurde nun erfolgreich installiert. Du kannst jetzt mit dem Herunterladen und Einrichten von Redmine fortfahren.

Redmine unter CentOS 7 herunterladen und installieren

Beginne damit, die aktuellste Redmine-Version von der offiziellen Webseite herunterzuladen:

cd ~
wget http://www.redmine.org/releases/redmine-3.4.4.tar.gz

Entpacke das Archiv und benenne den Ordner zur besseren Übersicht um:

tar -xf redmine-*.tar.gz
mv redmine-*/ redmine/

Kopiere die Beispielkonfigurationsdateien in ihre entsprechenden Zielpfade:

cd redmine
cp config/configuration.yml.example config/configuration.yml
cp config/database.yml.example config/database.yml

Bearbeite nun die Datenbankkonfiguration und trage die PostgreSQL-Daten ein:

nano config/database.yml

Kommentiere die MySQL-Konfiguration für die Abschnitte production, development und test aus:

#production:
#  adapter: mysql2
#  database: redmine
#  host: localhost
#  username: root
#  password: ""
#  encoding: utf8

#development:
#  adapter: mysql2
#  database: redmine_development
#  host: localhost
#  username: root
#  password: ""
#  encoding: utf8

#test:
#  adapter: mysql2
#  database: redmine_test
#  host: localhost
#  username: root
#  password: ""
#  encoding: utf8

Aktiviere und passe die PostgreSQL-Konfiguration wie folgt an (beachte die Einrückung mit zwei Leerzeichen):

production:
  adapter: postgresql
  database: redmine
  host: localhost
  username: redmine
  password: "DBPassword"

Lege den Pfad zur PostgreSQL-Konfiguration für den Build-Vorgang fest:

bundle config build.pg --with-pg-config=/usr/pgsql-10/bin/pg_config

Installiere die notwendigen Ruby-Bibliotheken, jedoch ohne Entwicklungs- und Testmodule:

bundle install --without development test

Am Ende der Installation wird eine Meldung wie diese erscheinen:

Installing roadie-rails 1.1.1
Bundle complete! 31 Gemfile dependencies, 55 gems now installed.
Gems in the groups development and test were not installed.
Use `bundle info [gemname]` to see where a bundled gem is installed.

Erzeuge einen geheimen Schlüssel für die Sitzungsverschlüsselung:

bundle exec rake generate_secret_token

Führe die Datenbankmigration für die Produktionsumgebung durch:

RAILS_ENV=production bundle exec rake db:migrate

Lade nun die Standarddaten und Sprachdateien in die Datenbank:

RAILS_ENV=production bundle exec rake redmine:load_default_data

Während der Ausführung wirst du aufgefordert, die Standard-Sprache auszuwählen. Standard ist Englisch:

[redmine@centron redmine]$ RAILS_ENV=production bundle exec rake redmine:load_default_data

Select language: ar, az, bg, bs, ca, cs, da, de, el, en, en-GB, es, es-PA, et, eu, fa, fi, fr, gl, he, hr, hu, id, it, ja, ko, lt, lv, mk, mn, nl, no, pl, pt, pt-BR, ro, ru, sk, sl, sq, sr, sr-YU, sv, th, tr, uk, vi, zh, zh-TW [en]
====================================
Default configuration data loaded.

Erstelle anschließend die notwendigen Verzeichnisse und setze die Dateirechte korrekt:

mkdir -p tmp tmp/pdf public/plugin_assets
chown -R redmine:redmine files log tmp public/plugin_assets
chmod -R 755 files log tmp public/plugin_assets

Damit sind alle Schritte unter dem eingeschränkten Benutzer abgeschlossen. Wechsle zurück zu deinem Hauptnutzer mit sudo-Rechten:

su - <username>

Apache-Konfiguration für Redmine mit SSL unter CentOS 7

Aktiviere zunächst das Passenger-Modul in der Apache-Konfiguration, damit es beim Systemstart automatisch geladen wird:

echo "LoadModule passenger_module /home/redmine/.rvm/gems/ruby-2.4.1/gems/passenger-5.1.12/buildout/apache2/mod_passenger.so" | sudo tee -a /etc/httpd/conf.modules.d/00-base.conf

Erstelle anschließend eine neue Virtual-Host-Konfiguration für Redmine:

sudo nano /etc/httpd/conf.d/redmine.conf

Füge folgenden Inhalt ein und ersetze redmine.example.com mit deiner Domain:

<VirtualHost *:80>
    ServerName redmine.example.com

    DocumentRoot /home/redmine/redmine/public
    
    PassengerRoot /home/redmine/.rvm/gems/ruby-2.4.1/gems/passenger-5.1.12
    PassengerRuby /home/redmine/.rvm/gems/ruby-2.4.1/wrappers/ruby
    PassengerUser redmine

    <Directory /home/redmine/redmine/public>
      Allow from all
      Options -MultiViews
      Require all granted
    </Directory>
</VirtualHost>

Vergewissere dich, dass die Pfade korrekt sind, indem du folgenden Befehl ausführst:

sudo su redmine -c "passenger-config about ruby-command"

Starte Apache neu, damit die neue Konfiguration aktiv wird:

sudo systemctl restart httpd

Öffne die Firewall für HTTP (Port 80):

sudo firewall-cmd --zone=public --add-service=http --permanent
sudo firewall-cmd --reload

Redmine ist jetzt über http://redmine.example.com erreichbar. Die Standard-Zugangsdaten sind admin / admin.

HTTPS mit Let's Encrypt SSL aktivieren

Um die Verbindung zu verschlüsseln, richte ein SSL-Zertifikat mit Let's Encrypt und Certbot ein.

Installiere die nötigen Pakete:

sudo yum -y install epel-release
sudo yum -y install certbot mod_ssl

Erlaube HTTPS (Port 443) in der Firewall:

sudo firewall-cmd --zone=public --add-service=https --permanent
sudo firewall-cmd --reload

Hinweis: Die Domain muss bereits auf den Server zeigen.

Fordere nun das SSL-Zertifikat an:

sudo certbot certonly --webroot -w /home/redmine/redmine/public -d redmine.example.com

Die Zertifikate findest du unter /etc/letsencrypt/live/redmine.example.com/.

Richte einen Cronjob ein, um die automatische Erneuerung zu ermöglichen:

sudo crontab -e

Füge folgende Zeile für die tägliche Erneuerung um 5:30 Uhr hinzu:

30 5 * * * /usr/bin/certbot renew --quiet

Bearbeite nun die Apache-Konfigurationsdatei für Redmine:

sudo nano /etc/httpd/conf.d/redmine.conf

Ergänze die Datei wie folgt, um HTTP auf HTTPS umzuleiten und SSL zu aktivieren:

<VirtualHost *:80>
    Redirect permanent / https://www.example.com/
    ServerName redmine.example.com
</VirtualHost>

<VirtualHost *:443>
    ServerAdmin admin@example.com
    ServerName redmine.example.com
    DocumentRoot "/home/redmine/redmine/public"
    <Directory "/home/redmine/redmine/public">
        Options None
        Require all granted
    </Directory>
    PassengerAppEnv production
    PassengerRoot /home/redmine/.rvm/gems/ruby-2.4.1/gems/passenger-5.1.12
    PassengerRuby /home/redmine/.rvm/gems/ruby-2.4.1/wrappers/ruby
    PassengerUser redmine
    PassengerHighPerformance on

    SSLEngine on
    SSLCertificateFile      /etc/letsencrypt/live/redmine.example.com/cert.pem
    SSLCertificateKeyFile   /etc/letsencrypt/live/redmine.example.com/privkey.pem
    SSLCertificateChainFile /etc/letsencrypt/live/redmine.example.com/chain.pem

    SSLProtocol             all -SSLv2 -SSLv3
    SSLHonorCipherOrder     on
    SSLCipherSuite          ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:ECDHE-ECDSA-DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:DES-CBC3-SHA:!DSS

    <IfModule headers_module>
        Header always edit Set-Cookie ^(.*)$ $1;HttpOnly;Secure
        Header always set Strict-Transport-Security "max-age=15768000; includeSubDomains"
    </IfModule>
</VirtualHost>

Speichere die Datei und starte Apache neu, um die Änderungen zu übernehmen:

sudo systemctl restart httpd

Redmine ist jetzt sicher über https://redmine.example.com erreichbar.

Herzlichen Glückwunsch! Die Redmine-Installation unter CentOS 7 ist vollständig eingerichtet und mit SSL geschützt. Du kannst jetzt Projekte erstellen oder importieren und loslegen.

Fazit

Du hast die Installation und Konfiguration von Redmine 3.4.4 unter CentOS 7 erfolgreich abgeschlossen – inklusive Apache, PostgreSQL und Phusion Passenger. Die Plattform ist nun live geschaltet und durch ein SSL-Zertifikat von Let's Encrypt geschützt, was eine verschlüsselte Kommunikation über HTTPS ermöglicht. Durch die Einhaltung bewährter Sicherheitspraktiken – wie der Nutzung eines nicht privilegierten Benutzers und der automatischen SSL-Erneuerung – ist dein System sowohl sicher als auch betriebsbereit.

Mit der einsatzbereiten Redmine-Umgebung kannst du nun Aufgaben verwalten, Probleme nachverfolgen, im Team zusammenarbeiten und Projektzeitpläne visualisieren – dank integrierter Tools wie Gantt-Diagrammen und dem Ticketsystem. Ob du bestehende Daten importierst oder dein erstes Projekt startest: Redmine bietet dir eine leistungsstarke und anpassbare Plattform für dein Projektmanagement.

Du kannst deine Redmine-Instanz jederzeit erweitern – z. B. durch Plugins, E-Mail-Benachrichtigungen oder die Anpassung von Benutzerrechten, wenn dein Team wächst. Viel Erfolg bei der Projektarbeit!