So installieren Sie Redmine unter RHEL 8 / CentOS 8 Linux

Redmine ist eine beliebte Open-Source-Projektmanagement-Webanwendung. Es unterstützt größere Datenbanken wie MySQL und PostgreSQL als Backend, und Sie können das Frontend auch vom WEBrick-Webserver (empfohlen für den Produktionseinsatz), der mit der Installation geliefert wird, auf Apache umstellen. In diesem Artikel werden wir das neueste Redmine auf RHEL 8 / CentOS 8 installieren, wobei wir PostgreSQL als Backend verwenden, aber wir werden das standardmäßige WEBrick als Frontend belassen, das unseren Tests perfekt dienen wird.

Erwarten Sie nicht, dass dieser Vorgang einfach oder fehlerfrei ist. Selbst wenn Sie diese Schritte buchstabengetreu befolgen, werden sicherlich einige Fehler auftreten, das Setup scheint sudo zu handhaben Schritte etwas widersprüchlich – aber es sind auch die Lösungen enthalten, die durch diese Fehler führen.

In diesem Tutorial lernen Sie:

Erforderliche Betriebssystempakete installieren
So richten Sie die Datenbank ein
So installieren Sie die Redmine-Anwendung
So starten und melden Sie sich bei der Anwendung an

Konfigurationsseite von Redmine auf RHEL 8.

Softwareanforderungen und verwendete Konventionen

Softwareanforderungen und Linux-Befehlszeilenkonventionen
Kategorie	Anforderungen, Konventionen oder verwendete Softwareversion
System	RHEL 8 / CentOS 8
Software	Redmine 4.0.3, PostgreSQL 10.5
Andere	Privilegierter Zugriff auf Ihr Linux-System als root oder über `sudo` Befehl.
Konventionen	# – erfordert, dass bestimmte Linux-Befehle mit Root-Rechten ausgeführt werden, entweder direkt als Root-Benutzer oder durch Verwendung von `sudo` Befehl $ – erfordert, dass bestimmte Linux-Befehle als normaler, nicht privilegierter Benutzer ausgeführt werden

Schritt-für-Schritt-Anleitung zur Installation von Redmine auf Redhat 8

Redmine ist eine Ruby-Anwendung. Für die Installation müssen wir rubygems verwenden und bundler , und viele Abhängigkeiten kompilieren, daher wird es eine Weile dauern. Wir verwenden die Red Hat-Repositories, die nach der Aktivierung der Abonnementverwaltung verfügbar sind, um die Betriebssystemabhängigkeiten zu lösen. Für die detaillierte Einrichtung der Datenbank im Allgemeinen können Sie sich auf die PostgreSQL-Installationsanleitung auf RHEL8 beziehen. In diesem Artikel behandeln wir nur die Schritte, die für Redmine erforderlich sind. Wenn die Datenbankeinrichtung neu ist, vergessen Sie nicht, die initdb abzuschließen Schritt in der genannten Anleitung, oder der Start der Datenbank schlägt fehl.

Wir erstellen einen Benutzer, der Eigentümer der Anwendung sein wird, und geben ihm vorübergehend sudo Zugriff. Wir können diesen Zugriff widerrufen, sobald die Installation abgeschlossen ist.
```
# useradd redmine
```
Wir müssen ein Passwort für den neuen Benutzer festlegen, das wir verwenden werden, wenn wir sudo verwenden :
```
# passwd redmine
```
Bei RHEL-basierten Distributionen gibt es ein wheel Benutzergruppe, die sudo verwenden darf um privilegierte Befehle auszuführen. Um zu überprüfen, ob diese Gruppe als sudoer eingerichtet ist , können wir grep /etc/sudoers Datei:
```
# grep "%wheel" /etc/sudoers
%wheel  ALL=(ALL)       ALL
# %wheel        ALL=(ALL)       NOPASSWD: ALL
```
Die zweite Zeile mit der Option NOPASSWD ist auskommentiert, was unseren Anforderungen entspricht. Mit der obigen Konfiguration müssen wir nur noch redmine hinzufügen Benutzer zum wheel Gruppe:
```
# usermod -a -G wheel redmine
```

Um die vom Betriebssystem bereitgestellten Pakete zu installieren, verwenden wir dnf :

# dnf install kernel-devel kernel-headers gcc postgresql-devel ruby ruby-devel rubygems

Um die Anwendung zu erhalten, besuchen Sie die offizielle Download-Site (die auf Redmine läuft). Von hier können wir den komprimierten tarball herunterladen mit wget zum Zielsystem:
```
# wget https://www.redmine.org/releases/redmine-4.0.3.tar.gz -O /opt/redmine-4.0.3.tar.gz
```
Wie der obige Befehl andeutet, installieren wir die Anwendung unter /opt Verzeichnis. Wir wechseln in dieses Verzeichnis und extrahieren das Archiv:
```
# cd /opt
# tar -xzf redmine-4.0.3.tar.gz
```
Optional können wir auch einen symlink erstellen für einen einfacheren Zugriff – auf diese Weise müssen wir uns nicht die genaue Version merken:
```
# ln -s /opt/redmine-4.0.3 /opt/redmine
```
Jetzt können wir das redmine setzen Benutzer als Besitzer der extrahierten Verzeichnishierarchie, rekursiv:
```
# chown -R redmine:redmine /opt/redmine*
```
Um die Datenbank für die Verbindung der Anwendung einzurichten, müssen wir sie starten, falls sie noch nicht läuft:
```
# systemctl start postgresql
```
Wir müssen eine leere Datenbank erstellen, in der die Anwendung ihre Daten speichert. Dazu wechseln wir zu postgres Betriebssystembenutzer, der standardmäßig bei der Datenbankinstallation erstellt wird:
```
# su - postgres
```
Wir melden uns bei psql an als Superuser der Datenbank:
```
$ psql
psql (10.5)
Type "help" for help.

postgres=#
```
ein
Wir erstellen eine Rolle, die von der Anwendung verwendet wird (notieren Sie sich den Benutzernamen und das Passwort):
```
postgres=# CREATE ROLE redmine LOGIN ENCRYPTED PASSWORD 'R3DM1N3' NOINHERIT VALID UNTIL 'infinity';
```
Wir erstellen auch eine neue Datenbank mit dem oben erstellten Eigentümer:
```
postgres=# CREATE DATABASE rmdb WITH ENCODING='UTF8' OWNER=redmine;
```
Wir benötigen den Benutzernamen, das Passwort, die Kodierung und den Datenbanknamen in einem späteren Schritt.
Da der Benutzer nun eingerichtet ist, müssen wir ihm die Anmeldung auf dem Datenbankserver erlauben. Der Redmine-Benutzer wird sich lokal verbinden, also fügen wir die folgende Zeile zur pg_hba.conf hinzu Datei, die sich standardmäßig unter /var/lib/pgsql/data befindet standardmäßig bei RHEL-basierten Distributionen:
```
host    rmdb        redmine             127.0.0.1/32          md5
```
Überprüfen Sie Ihre Konfigurationsdatei auf Folgendes:
```
# IPv4 local connections:
host    all             all             127.0.0.1/32            ident
```
Wenn Sie eine solche Zeile haben, kommentieren Sie sie aus, sie wird mit dem Login in Konflikt geraten, das wir einrichten möchten.
Damit müssen wir die Datenbank neu starten, damit die Einstellungen wirksam werden:
```
# systemctl restart postgresql
```
Jetzt haben wir alle erforderlichen Informationen, um der Anwendung mitzuteilen, wo und wie sie die Datenbank finden wird. Ein Beispiel für die Konfigurationsdatei der Datenbankverbindung mit allen unterstützten Datenbanken befindet sich in der config Unterverzeichnis des extrahierten Archivs. Wir können eine Kopie dieser Datei erstellen (mit dem redmine user):
```
$ cp config/database.yml.example config/database.yml
```
Wir können alle Beispieleinstellungen außer denen, die sich auf PostgreSQL beziehen, löschen oder auskommentieren oder einfach eine leere Datei mit der erforderlichen Konfiguration erstellen (auf diese Weise verbleibt weniger Müll in der Datei). Am Ende die /opt/redmine/config/database.yml sollte Folgendes enthalten:
```
# PostgreSQL configuration
production:
  adapter: postgresql
  database: rmdb
  host: 127.0.0.1
  username: redmine
  password: "R3DM1N3"
```
Beachten Sie, dass wir die Datenbankverbindungsinformationen verwendet haben, die wir in den letzten beiden Schritten eingerichtet haben.
Um die Anzahl möglicher Probleme zu verringern, testen wir, ob wir uns bei der rmdb anmelden können Datenbank mit den in der Konfigurationsdatei angegebenen Anmeldeinformationen. Es ist einfacher, Verbindungsprobleme mit dem PostgreSQL-Toolset zu beheben als mit jedem anderen:
```
$ psql -d rmdb -U redmine -W
Password for user redmine: 
psql (10.5)
Type "help" for help.

rmdb=>
```
ein
Hier endet der einfache Teil. Jetzt installieren wir verschiedene Ruby-Pakete, von denen Redmine abhängt. Einige von ihnen benötigen root zugreifen, einige werden im Namen von redmine installiert Benutzer, und einige werden später wahrscheinlich eine Reparatur benötigen. Im Ernst. Als erstes brauchen wir bundler :
```
# gem install bundler
Fetching: bundler-2.0.1.gem (100%)
Successfully installed bundler-2.0.1
1 gem installed
```
Wir verwenden bundler mit dem redmine user, aber wir brauchen auch root um Ruby gems zu installieren oder zu reparieren , also schlage ich vor, ein anderes Terminal zu öffnen, zu redmine zu wechseln Benutzer und navigieren Sie zu /opt/redmine Verzeichnis, während gleichzeitig die Root-Konsole geöffnet bleibt.
Als redmine user starten wir die Installation im /opt/redmine Verzeichnis:
```
$ bundle install --without development test rmagick
```
Viele Abhängigkeiten werden installiert, und für einige fragt der Installer nach dem sudo password – das ist das Passwort von redmine Benutzer. Es scheint, dass diese sudo-Funktionalität irgendwie ein wenig kaputt ist und einige der root-privilegierten Paketinstallationen verarbeiten kann und mit anderen nicht weiterkommt. Diejenigen, die fehlschlagen, können auf der Root-Konsole und dem obigen bundle installiert werden Befehl kann erneut auf der Konsole des Redmine-Benutzers ausgeführt werden. Was benötigt wurde, musste in meinem Fall mit root installiert werden sind die folgenden:
```
# gem install nokogiri -v '1.10.2' --source 'https://rubygems.org/'
# gem install pg -v '1.1.4' --source 'https://rubygems.org/'
```
Es gibt auch einige Pakete, die während der Installation beschädigt werden können. Diese können auch auf der Root-Konsole repariert werden. Wie bei den obigen fehlgeschlagenen Paketinstallationsschritten wird die Ausgabe von bundler Der Befehl zeigt an, welches Paket Probleme hat und wie man es löst. In meinem Fall mussten die folgenden Pakete repariert werden:
```
# gem pristine nio4r --version 2.3.1
# gem pristine redcarpet --version 3.4.0
# gem pristine websocket-driver --version 0.7.0
```
Bitte beachten Sie, dass die Versionsnummern der Pakete wahrscheinlich abweichen werden, wenn Sie eine andere Version von Redmine installieren. Nachdem alle defekten und fehlenden Pakete repariert wurden, wird das bundle Der Befehl sollte ohne Fehler abgeschlossen werden, mit dem folgenden Ende der Ausgabe:
```
[...]
Installing roadie-rails 1.3.0
Fetching rouge 3.3.0
Installing rouge 3.3.0
Bundle complete! 26 Gemfile dependencies, 57 gems now installed.
Gems in the groups development, test and rmagick were not installed.
Use `bundle info [gemname]` to see where a bundled gem is installed.
```
Nachdem der knifflige Teil erledigt ist, müssen wir ein Token generieren, das zum Kodieren von Sitzungscookies verwendet wird:
```
$ bundle exec rake generate_secret_token
```

Als nächstes generieren wir die von der Anwendung benötigten Datenbankobjekte:

$ RAILS_ENV=production bundle exec rake db:migrate

Abgesehen von der Erstellung der erforderlichen Datenbankobjekte generiert dieser Schritt eine Menge Ausgaben, indem alle Schritte in der Konsole protokolliert werden. Wir werden sehen, dass viele Einträge ähnlich wie die folgenden aussehen:

[...]

== 20180913072918 AddVerifyPeerToAuthSources: migrating =======================
-- change_table(:auth_sources)
   -> 0.0082s
== 20180913072918 AddVerifyPeerToAuthSources: migrated (0.0083s) ==============

== 20180923082945 ChangeSqliteBooleansTo0And1: migrating ======================
== 20180923082945 ChangeSqliteBooleansTo0And1: migrated (0.0000s) =============

Dieser Vorgang sollte in wenigen Sekunden abgeschlossen sein.

Wir können die gefüllte Datenbank mit psql überprüfen :

rmdb=> \dt
                       List of relations
 Schema |                Name                 | Type  |  Owner  
--------+-------------------------------------+-------+---------
 public | ar_internal_metadata                | table | redmine
 public | attachments                         | table | redmine
 public | auth_sources                        | table | redmine
 public | boards                              | table | redmine
 public | changes                             | table | redmine
[...]

Der letzte Schritt der Installation ist das Laden der Standarddaten in die Datenbank. Durch Angabe des REDMINE_LANG Parameter können wir uns eventuelle Rückfragen beim initialen Laden ersparen.
```
$ RAILS_ENV=production REDMINE_LANG=en bundle exec rake redmine:load_default_data
Default configuration data loaded.
```

Die Installation ist abgeschlossen. Wir können die Anwendung starten:

$ bundle exec rails server webrick -e production
=> Booting WEBrick
=> Rails 5.2.2.1 application starting in production on http://0.0.0.0:3000
=> Run `rails server -h` for more startup options
[2019-04-14 18:39:12] INFO  WEBrick 1.4.2
[2019-04-14 18:39:12] INFO  ruby 2.5.1 (2018-03-29) [x86_64-linux]
[2019-04-14 18:39:12] INFO  WEBrick::HTTPServer#start: pid=30062 port=3000

Die Anwendung wird jetzt ausgeführt und kann mit einem Browser aufgerufen werden. Aus der obigen Ausgabe können wir erraten, dass auf Port 3000 zugegriffen werden kann , wenn also auf dem Zielcomputer eine Firewall läuft, müssen wir diesen Port öffnen, um remote auf den Dienst zuzugreifen:
```
# firewall-cmd --zone=public --add-port=3000/tcp --permanent
# firewall-cmd --reload
```
Indem wir einen Browser öffnen und ihn auf die Adresse und den Port 3000 des Computers (http://192.168.1.14:3000 auf dem Screenshot unten) richten, können wir auf die webbasierte Schnittstelle unserer frischen neuen Redmine-Installation zugreifen.
Anmeldeseite von Redmine.
Die Standardanmeldeinformationen sind admin für den Benutzernamen und auch für das Passwort. Bei der ersten Anmeldung fordert die gut funktionierende Anwendung zur Kennwortänderung für dieses privilegierte Konto auf. Von dort aus können wir den Dienst füllen, konfigurieren und nutzen.
Nach Abschluss der Installation können wir redmine entfernen Benutzer vom wheel Gruppe, wodurch die während des Vorgangs benötigte Sicherheitslücke beseitigt wird:
```
# gpasswd -d redmine wheel
Removing user redmine from group wheel
# id redmine
uid=1008(redmine) gid=1008(redmine) groups=1008(redmine)
```