So installieren Sie Redmine auf RHEL 8 / CentOS 8 Linux

3638
154
Janin Pletsch

Redmine ist eine beliebte Open -Source -Projektmanagement -Webanwendung. Es unterstützt Bürgermeisterdatenbanken wie MySQL und PostgreSQL als Backend. In diesem Artikel werden wir die neueste Redmine auf RHEL 8 / CentOS 8 installieren, indem wir PostgreSQL als Backend verwenden.

Erwarten Sie nicht, dass dieser Prozess einfach oder fehlerfrei ist. Selbst nach diesen Schritten zum Brief werden einige Fehler auftreten. Das Setup scheint sicher zu gehen sudo Schritte etwas uneinheitlich - aber die Lösungen sind auch enthalten, die durch diese Fehler führen werden.

In diesem Tutorial lernen Sie:

So installieren Sie die erforderlichen Betriebssystempakete
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 Konventionen verwendet

Softwareanforderungen und Linux -Befehlszeilenkonventionen

Kategorie	Anforderungen, Konventionen oder Softwareversion verwendet
System	Rhel 8 / Centos 8
Software	Redmine 4.0.3, postgresql 10.5
Andere	Privilegierter Zugriff auf Ihr Linux -System als Root oder über die `sudo` Befehl.
Konventionen	# - erfordert, dass gegebene Linux -Befehle mit Root -Berechtigungen entweder direkt als Stammbenutzer oder mit Verwendung von ausgeführt werden können `sudo` Befehl $ - Erfordert, dass die angegebenen Linux-Befehle als regelmäßiger nicht privilegierter Benutzer ausgeführt werden können

So installieren Sie Redmine auf Redhat 8 Schritt für Schritt Anweisungen

Redmine ist eine Rubinanwendung. Für die Installation müssen wir verwenden Rubygemems Und Bundler, und viele Abhängigkeiten kompilieren, also wird es eine Weile dauern. Wir werden die verfügbaren Red Hat -Repositorys verwenden, nachdem das Abonnementverwaltung die Abhängigkeit von den Abhängigkeiten des Betriebssystems gelöst hat. Die detaillierte Einrichtung der Datenbank im Allgemeinen finden Sie in dem PostgreSQL -Installationshandbuch zu RHEL8. In diesem Artikel werden wir nur die für Redmine erforderlichen Schritte behandeln. Wenn das Datenbank -Setup neu ist, vergessen Sie nicht, das zu vervollständigen initdb Schritt in die genannte Anleitung oder der Start der Datenbank fehl.

Wir erstellen einen Benutzer, der der Eigentümer der Anwendung ist, und wir geben ihn vorübergehend sudo Zugang. Wir können diesen Zugang nach Abschluss der Installation widerrufen.
```
# UserAdd Redmine
```
Wir müssen ein Passwort für den neuen Benutzer festlegen, den wir bei der Verwendung verwenden werden sudo:
```
# Passwd Redmine
```
Auf rhelbasierten Verteilungen gibt es a Rad Benutzergruppe, wer dürfte verwenden sudo Privilegierte Befehle ausführen. Um zu überprüfen, ob diese Gruppe als eingerichtet ist als sudoer, wir können Grep Die /etc/sudoers Datei:
```
# Grep " %Wheel" /etc /sudoers %Rad All = (alle) alle # %Wheel All = (alle) nopasswd: alle
```
Die zweite Zeile mit der NopassWD -Option wird kommentiert, die unseren Bedürfnissen entspricht. Mit der obigen Konfiguration müssen wir nur das hinzufügen Redmine Benutzer zum Rad Gruppe:
```
# Usermod -a -g -Rad Redmine
```

Um die Pakete zu installieren, die das Betriebssystem bereitstellt, werden wir verwenden DNF:

# DNF Installieren Sie Kernel-Devel-Kernel-Header GCC PostgreSQL-Devel Ruby Ruby-Devel Rubygemems

Um die Bewerbung zu erhalten, besuchen Sie die offizielle Download -Website (die auf Redmine ausgeführt wird). Von hier aus können wir die komprimierten herunterladen Tarball mit wget zum Zielsystem:
```
# WGet https: // www.Redmine.org/releases/Redmine-4.0.3.Teer.gz -o /opt /redmine -4.0.3.Teer.gz
```
Wie der obige Befehl schon sagt, installieren wir die Anwendung unter dem /opt Verzeichnis. Wir werden zu diesem Verzeichnis wechseln und das Archiv extrahieren:
```
# CD /Opt # tar -xzf Redmine -4.0.3.Teer.gz
```
Optional können wir auch eine erstellen Symlink Für einfacheren Zugriff - Auf diese Weise müssen wir uns nicht an die genaue Version erinnern:
```
# ln -s /opt /redmine -4.0.3 /opt /Redmine
```
Jetzt können wir die festlegen Redmine Benutzer als Eigentümer 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, wenn sie nicht bereits ausgeführt wird:
```
# SystemCTL Start PostgreSQL
```
Wir müssen eine leere Datenbank erstellen, in der die Anwendung ihre Daten speichert. Um dies zu tun, werden wir zum Wechsel zur Postgres Betriebssystembenutzer, die standardmäßig bei der Datenbankinstallation erstellt wurden:
```
# Su - Postgres
```
Wir werden uns anmelden PSQL Als Superuser der Datenbank:
```
$ PSQL PSQL (10.5) Geben Sie "Hilfe" für Hilfe ein. postgres =#
```
Wir werden eine Rolle erstellen, die von der Anwendung verwendet wird (notieren Sie sich den Benutzernamen und das Passwort):
```
postgres =# rolle redmine login verschlüsseltes kennwort 'r3dm1n3' noinherit gültig bis 'unendlich';
```
Wir erstellen auch eine neue Datenbank mit dem oben erstellten Eigentümer:
```
postgres =# Datenbank erstellen RMDB mit coding = "utf8" Eigentümer = Redmine;
```
In einem späteren Schritt benötigen wir den Namen Benutzername, Kennwort, Codierung und Datenbank.
Nachdem der Benutzer eingerichtet ist, müssen wir uns auf dem Datenbankserver anmelden. Der Redmine -Benutzer verbindet sich lokal, sodass wir die folgende Zeile hinzufügen PG_HBA.Conf Datei, standardmäßig bei der Lage /var/lib/pgsql/Daten Standardmäßig auf rhelbasierte Verteilungen:
```
Host RMDB Redmine 127.0.0.1/32 MD5
```
Überprüfen Sie Ihre Konfigurationsdatei für Folgende:
```
# IPv4 Lokale Verbindungen: Host alle alle 127.0.0.1/32 Ident
```
Wenn Sie eine solche Zeile haben, kommentieren Sie sie aus, sie wird mit der Anmeldung in Konflikt stehen, die wir einrichten möchten.
Damit müssen wir die Datenbank neu starten, damit die Einstellungen wirksam werden:
```
# SystemCTL Neustart PostgreSQL
```
Jetzt haben wir alle Informationen erforderlich, um der Anwendung mitzuteilen, wo und wie die Datenbank findet. Es gibt ein Beispiel für die Datenbankverbindungskonfigurationsdatei mit allen unterstützten Datenbanken in der Konfiguration Unterverzeichnis des extrahierten Archivs. Wir können eine Kopie dieser Datei erstellen (mit der Redmine Benutzer):
```
$ cp config/Datenbank.YML.Beispielkonfiguration/Datenbank.YML
```
Wir können alle Beispieleinstellungen löschen oder kommentieren, neben den mit PostgreSQL, oder einfach eine leere Datei mit der erforderlichen Konfiguration erstellen (weniger Junk bleibt auf diese Weise in der Datei). Am Ende die /opt/Redmine/config/Datenbank.YML sollte Folgendes enthalten:
```
# Postgresql Konfiguration Produktion: Adapter: PostgreSQL -Datenbank: RMDB -Host: 127.0.0.1 Benutzername: Redmine Passwort: "R3DM1N3"
```
Kopieren
Beachten Sie, dass wir die Datenbankverbindungsinformationen verwendet haben, die wir in den letzten beiden Schritten eingerichtet haben.

Um die Anzahl der möglichen Probleme zu senken, werden wir testen, dass wir uns anmelden können RMDB Datenbank mit den in der Konfigurationsdatei angegebenen Anmeldeinformationen. Es ist einfacher, Verbindungsprobleme mit PostgreSQL Toolset zu debuggen als in jedem anderen:
```
$ PSQL -D RMDB -U Redmine -W -Passwort für Benutzer Redmine: PSQL (10.5) Geben Sie "Hilfe" für Hilfe ein. rmdb =>
```
Hier endet der einfache Teil. Jetzt installieren wir verschiedene Ruby -Pakete Redmine hängt davon ab. Einige von ihnen brauchen Wurzel Zugriff werden einige im Namen der installiert Redmine Benutzer und später werden einige wahrscheinlich eine Reparatur benötigen. Im Ernst. Zunächst brauchen wir wir brauchen Bundler:
```
# Gem Installieren Sie Bundler Abrufen: Bundler-2.0.1.GEM (100%) erfolgreich installiert Bundler-2.0.1 1 Gem installiert
```
Wir werden verwenden Bundler mit dem Redmine Benutzer, aber wir brauchen auch Wurzel zu installieren oder zu reparieren Ruby Edelsteine, Deshalb schlage ich vor, ein weiteres Terminal zu öffnen, um zu wechseln zu Redmine Benutzer und navigieren Sie zur /opt/Redmine Verzeichnis, während gleichzeitig die Wurzelkonsole offen bleibt.
Als Redmine Benutzer starten die Installation in der /opt/Redmine Verzeichnis:
```
$ bündel install -ohne Entwicklungstest rmagick
```
Viele Abhängigkeiten werden installiert, und für einige fragt das Installationsprogramm nach dem sudo Passwort - welches das Passwort der ist Redmine Benutzer. Es scheint, dass diese Sudo -Funktionalität irgendwie ein wenig kaputt ist und einige der privilegierten Paket -Installationen ausführen kann und nicht mit anderen weitermachen kann. Diejenigen, die ausfallen bündeln Der Befehl kann erneut auf der Konsole des Redmine -Benutzers ausgeführt werden. Was musste in meinem Fall mit installiert werden Wurzel sind die folgenden:
```
# Gem Installieren Sie Nokogiri -v '1.10.2 ' - -source' https: // rubygemems.org/' # gem eine installieren pg -v' 1.1.4 ' - -source' https: // rubygemems.org/'
```
Es gibt auch einige Pakete, die während der Installation möglicherweise kaputt gehen. Diese können auch auf der Wurzelkonsole repariert werden. Wie bei den obigen fehlgeschlagenen Paketinstallationsschritten die Ausgabe der Ausgabe der Bundler Der Befehl wird sagen, welches Paket Probleme hat und wie es gelöst werden kann. In meinem Fall mussten die folgenden Pakete repariert:
```
# Gem Pristine Nio4r --version 2.3.1 # Gem Pristine Redcarpet --version 3.4.0 # Gem Pristine WebSocket-Fahrer --version 0.7.0
```
Bitte beachten Sie, dass sich die Versionsnummern der Pakete wahrscheinlich unterscheiden, wenn Sie eine andere Version von Redmine installieren. Nachdem alle kaputten und fehlenden Pakete repariert wurden, die bündeln Der Befehl sollte ohne Fehler mit dem folgenden Ende der Ausgabe abgeschlossen werden:
```
[…] Installieren von Roadie-Rails 1.3.0 Rouge 3 holen 3.3.0 Rouge 3 installieren 3.3.0 Bündel komplett! 26 GemFile -Abhängigkeiten, 57 Edelsteine jetzt installiert. Edelsteine in den Gruppenentwicklung, Test und RMagick wurden nicht installiert. Verwenden Sie "Bündelinfo [Gemname]", um zu sehen, wo ein gebündeltes Edelstein installiert ist.
```
Mit dem schwierigen Teil müssen wir ein Token generieren, mit dem Sitzungs Cookies codiert werden:
```
$ Bundle Exec Rake generate_secret_token
```
Als nächstes generieren wir die von der Anwendung benötigten Datenbankobjekte:
```
$ Rails_env = Produktion Bundle Execs Rake DB: Migrieren
```
Abgesehen vom Erstellen der erforderlichen Datenbankobjekte generiert dieser Schritt viel Ausgabe, indem alle Schritte bei der Konsole protokolliert werden. Wir werden sehen, dass viele Einträge ähnlich wie folgt erscheinen:
```
[…] == 20180913072918 addVefypeToAuthSources: Migrieren ================================= -Change_table (: auth_sources) -> 0.0082S == 20180913072918 AddVerifypeToAuthSources: Migrated (0).0083s) ============== == 20180923082945 ändert (0.0000) =============
```
Dieser Vorgang sollte in wenigen Sekunden abgeschlossen werden.

Wir können die besiedelte Datenbank mit überprüfen PSQL:

rmdb => \ dt Liste der Beziehungsschema | Name | Typ | Besitzer --------+-------------------------------------+-- ------+--------- öffentlich | ar_internal_metadata | Tabelle | Redmine Public | Anhänge | Tabelle | Redmine Public | Auth_Sources | Tabelle | Redmine Public | Boards | Tabelle | Redmine Public | Änderungen | Tabelle | Redmine […]

Der letzte Schritt der Installation ist das Laden der Standarddaten in die Datenbank. Durch Bereitstellung der Redmine_lang Parameter Wir können uns während der ersten Belastung vor Fragen speichern.
```
$ Rails_env = produktion redmine_lang = en bündele ExecT Rake Redmine: load_default_data Standardkonfigurationsdaten geladen.
```

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

$ Bundle Exec Rails Server Webrick -e -Produktion => Booting webrick => Schienen 5.2.2.1 Anwendung beginnend in der Produktion auf http: // 0.0.0.0: 3000 => Run 'Rails Server -h' für weitere Startoptionen [2019-04-14 18:39:12] Info Webebick 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 Webebrick :: httpserver#start: pid = 30062 port = 3000

Die Anwendung wird jetzt ausgeführt und kann mit einem Browser zugegriffen werden. Aus der obigen Ausgabe können wir vermuten, dass es am Port zugänglich ist 3000, Wenn wir also eine Firewall auf der Zielmaschine laufen, müssen wir diesen Port öffnen, um auf den Service aus der Ferne zuzugreifen:
```
# Firewall-cmd --zone = public --add-port = 3000/tcp --permanent # Firewall-CMD-Reload
```
Durch Öffnen eines Browsers und auf die Adresse der Maschine und Port 3000 (http: // 192.168.1.14: 3000 auf dem folgenden Screenshot) können wir auf die webbasierte Schnittstelle unserer neuen Redmine-Installation zugreifen. Anmeldeseite von Redmine.
Die Standard -Anmeldeinformationen sind Administrator für den Benutzernamen und auch für Passwort. Beim ersten Anmeldung fordert die wohlbettete Anwendung eine Passwortänderung für dieses privilegierte Konto auf. Von dort aus ist der Service unseres, um zu bevölkern, zu konfigurieren und zu genießen.
Nach Abschluss der Installation können wir die entfernen Redmine Benutzer aus dem Rad Gruppe, beseitigen Sie das während des Prozesses erforderliche Sicherheitsloch:
```
# gpasswd -d Redmine Rad Entfernen des Benutzers Redmine aus Gruppenrad # id Redmine uid = 1008 (Redmine) GID = 1008 (Redmine) Gruppen = 1008 (Redmine)
```

So installieren Sie Redmine auf RHEL 8 / CentOS 8 Linux

Softwareanforderungen und Konventionen verwendet

So installieren Sie Redmine auf Redhat 8 Schritt für Schritt Anweisungen

Verwandte Linux -Tutorials:

Beste Artikel

11 Beste Open-Source-Notizen-Apps für Linux

Mit einer Notizen-App können Sie Notizen unterwegs aufzeichnen, egal ob Sie im Unterricht sind oder ...

So installieren Sie Puppet Master und Agent in rhelbasierten Systemen

In diesem Handbuch werden wir demonstrieren, wie man Puppet Master und Agent in rhelbasierten Vertei...