Come installare redmine su RHEL 8 / CentOS 8 Linux

Redmine è una popolare applicazione web open source per la gestione dei progetti. Supporta database principali come MySQL e PostgreSQL come backend e puoi anche cambiare il frontend in Apache dal server web WEBrick (consigliato per l'uso in produzione) fornito con l'installazione. In questo articolo installeremo l'ultimo Redmine su RHEL 8 / CentOS 8, usando PostgreSQL come backend, ma lasceremo il WEBrick predefinito come frontend, che servirà perfettamente ai nostri test.

Non aspettarti che questo processo sia facile, né privo di errori. Anche seguendo questi passaggi alla lettera, si verificheranno sicuramente degli errori, l'installazione sembra gestire sudo passaggi alquanto incoerenti, ma sono incluse anche le soluzioni che guideranno attraverso questi errori.

In questo tutorial imparerai:

Come installare i pacchetti del sistema operativo richiesti
Come impostare il database
Come installare l'applicazione Redmine
Come avviare e accedere all'applicazione

Pagina di configurazione di Redmine su RHEL 8.

Requisiti e convenzioni software utilizzati

Requisiti software e convenzioni della riga di comando Linux
Categoria	Requisiti, convenzioni o versione del software utilizzata
Sistema	RHEL 8 / CentOS 8
Software	Redmine 4.0.3, PostgreSQL 10.5
Altro	Accesso privilegiato al tuo sistema Linux come root o tramite `sudo` comando.
Convenzioni	# – richiede che i comandi linux dati vengano eseguiti con i privilegi di root direttamente come utente root o usando `sudo` comando $ – richiede che i comandi linux dati vengano eseguiti come un normale utente non privilegiato

Come installare redmine su Redhat 8 istruzioni passo passo

Redmine è un'applicazione Ruby. Per l'installazione dovremo usare rubygems e bundler e compila molte dipendenze, quindi ci vorrà del tempo. Utilizzeremo i repository Red Hat disponibili dopo aver abilitato la gestione degli abbonamenti per risolvere le dipendenze del sistema operativo. Puoi fare riferimento alla guida all'installazione di PostgreSQL su RHEL8 per la configurazione dettagliata del database in generale, in questo articolo tratteremo solo i passaggi necessari per Redmine. Se la configurazione del database è nuova, non dimenticare di completare initdb passo nella guida menzionata, o l'avvio del database fallirà.

Creeremo un utente che sarà il proprietario dell'applicazione e gli daremo sudo temporaneo accesso. Possiamo revocare questo accesso una volta completata l'installazione.
```
# useradd redmine
```
Dobbiamo impostare una password per il nuovo utente, che useremo quando useremo sudo :
```
# passwd redmine
```
Sulle distribuzioni basate su RHEL, c'è una wheel gruppo di utenti, a cui è consentito utilizzare sudo per eseguire comandi privilegiati. Per verificare che questo gruppo sia impostato come sudoer , possiamo grep il /etc/sudoers file:
```
# grep "%wheel" /etc/sudoers
%wheel  ALL=(ALL)       ALL
# %wheel        ALL=(ALL)       NOPASSWD: ALL
```
La seconda riga con l'opzione NOPASSWD è commentata, che soddisferà le nostre esigenze. Con la configurazione di cui sopra in atto, tutto ciò che dobbiamo fare è aggiungere il redmine utente alla wheel gruppo:
```
# usermod -a -G wheel redmine
```

Per installare i pacchetti forniti dal sistema operativo, utilizzeremo dnf :

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

Per ottenere l'applicazione, visitare il sito di download ufficiale (che è in esecuzione su Redmine). Da qui possiamo scaricare il tarball compresso con wget al sistema di destinazione:
```
# wget https://www.redmine.org/releases/redmine-4.0.3.tar.gz -O /opt/redmine-4.0.3.tar.gz
```
Come suggerisce il comando precedente, installeremo l'applicazione sotto /opt directory. Passeremo a questa directory ed estrarremo l'archivio:
```
# cd /opt
# tar -xzf redmine-4.0.3.tar.gz
```
Opzionalmente possiamo anche creare un symlink per un accesso più facile – in questo modo non abbiamo bisogno di ricordare la versione esatta:
```
# ln -s /opt/redmine-4.0.3 /opt/redmine
```
Ora possiamo impostare il redmine utente come proprietario della gerarchia di directory estratta, in modo ricorsivo:
```
# chown -R redmine:redmine /opt/redmine*
```
Per configurare il database per la connessione dell'applicazione, dobbiamo avviarlo se non è già in esecuzione:
```
# systemctl start postgresql
```
Dovremo creare un database vuoto in cui l'applicazione memorizzerà i suoi dati. Per farlo, passeremo a postgres utente del sistema operativo creato per impostazione predefinita durante l'installazione del database:
```
# su - postgres
```
Accederemo a psql come superutente del database:
```
$ psql
psql (10.5)
Type "help" for help.

postgres=#
```
Creeremo un ruolo che verrà utilizzato dall'applicazione (annotare nome utente e password):
```
postgres=# CREATE ROLE redmine LOGIN ENCRYPTED PASSWORD 'R3DM1N3' NOINHERIT VALID UNTIL 'infinity';
```
Creiamo anche un nuovo database con il proprietario creato sopra:
```
postgres=# CREATE DATABASE rmdb WITH ENCODING='UTF8' OWNER=redmine;
```
Avremo bisogno di nome utente, password, codifica e nome del database in un passaggio successivo.
Ora che l'utente è configurato, è necessario consentirne l'accesso sul server del database. L'utente redmine si connetterà localmente, quindi aggiungiamo la seguente riga a pg_hba.conf file, che si trova per impostazione predefinita in /var/lib/pgsql/data per impostazione predefinita su distribuzioni basate su RHEL:
```
host    rmdb        redmine             127.0.0.1/32          md5
```
Controlla il tuo file di configurazione per quanto segue:
```
# IPv4 local connections:
host    all             all             127.0.0.1/32            ident
```
Se hai tale riga, commentala, sarà in conflitto con l'accesso che prevediamo di impostare.
Con questo in atto, dobbiamo riavviare il database affinché le impostazioni abbiano effetto:
```
# systemctl restart postgresql
```
Ora abbiamo tutte le informazioni necessarie per dire all'applicazione dove e come troverà il database. C'è un esempio del file di configurazione della connessione al database con tutti i database supportati in config sottodirectory dell'archivio estratto. Possiamo fare una copia di questo file (usando il redmine utente):
```
$ cp config/database.yml.example config/database.yml
```
Possiamo eliminare o commentare tutte le impostazioni di esempio oltre a quelle relative a PostgreSQL, o semplicemente creare un file vuoto con la configurazione necessaria (meno spazzatura rimarrà nel file in quel modo). Alla fine, il /opt/redmine/config/database.yml dovrebbe contenere quanto segue:
```
# PostgreSQL configuration
production:
  adapter: postgresql
  database: rmdb
  host: 127.0.0.1
  username: redmine
  password: "R3DM1N3"
```
Tieni presente che abbiamo utilizzato le informazioni di connessione al database che abbiamo impostato negli ultimi due passaggi.
Per ridurre il numero di possibili problemi, testeremo di poter accedere a rmdb database con le credenziali fornite nel file di configurazione. È più facile eseguire il debug dei problemi di connessione con il set di strumenti PostgreSQL rispetto a qualsiasi altro:
```
$ psql -d rmdb -U redmine -W
Password for user redmine: 
psql (10.5)
Type "help" for help.

rmdb=>
```
Qui finisce la parte facile. Ora installeremo vari pacchetti Ruby da cui Redmine dipende. Alcuni di loro hanno bisogno di root accesso, alcuni installeranno nel nome del redmine utente, e in seguito alcuni avranno probabilmente bisogno di una riparazione. Non scherzo. Prima di tutto, avremo bisogno di bundler :
```
# gem install bundler
Fetching: bundler-2.0.1.gem (100%)
Successfully installed bundler-2.0.1
1 gem installed
```
Useremo bundler con il redmine utente, ma avremo anche bisogno di root per installare o riparare Ruby gems , quindi suggerisco di aprire un altro terminale, passare a redmine utente e vai a /opt/redmine directory, mantenendo aperta anche la console di root.
Come redmine utente, avviamo l'installazione nel /opt/redmine directory:
```
$ bundle install --without development test rmagick
```
Verranno installate molte dipendenze e per alcune il programma di installazione richiede il sudo password – che è la password del redmine utente. Sembra che questa funzionalità sudo sia in qualche modo interrotta e possa gestire alcune delle installazioni di pacchetti con privilegi di root e non possa andare d'accordo con gli altri. Quelli che falliscono possono essere installati sulla console di root e sul bundle sopra il comando può essere eseguito nuovamente sulla console dell'utente redmine. Cosa era necessario installare nel mio caso con root sono i seguenti:
```
# gem install nokogiri -v '1.10.2' --source 'https://rubygems.org/'
# gem install pg -v '1.1.4' --source 'https://rubygems.org/'
```
Ci sono anche alcuni pacchetti che potrebbero rompersi durante l'installazione. Questi possono essere riparati anche sulla console di root. Come per i passaggi di installazione del pacchetto non riusciti precedenti, l'output del bundler il comando dirà quale pacchetto ha riscontrato problemi e come risolverlo. Nel mio caso è stato necessario riparare i seguenti pacchetti:
```
# gem pristine nio4r --version 2.3.1
# gem pristine redcarpet --version 3.4.0
# gem pristine websocket-driver --version 0.7.0
```
Tieni presente che se stai installando un'altra versione di Redmine, i numeri di versione dei pacchetti probabilmente differiranno. Dopo aver corretto tutti i pacchetti rotti e mancanti, il bundle il comando dovrebbe essere completato senza errori, con la seguente fine dell'output:
```
[...]
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.
```
Dopo la parte complicata, dobbiamo generare un token che verrà utilizzato per codificare i cookie di sessione:
```
$ bundle exec rake generate_secret_token
```

Successivamente generiamo gli oggetti database necessari all'applicazione:

$ RAILS_ENV=production bundle exec rake db:migrate

Oltre a creare gli oggetti di database necessari, questo passaggio genererà molto output registrando tutti i passaggi sulla console. Vedremo molte voci apparire simili alle seguenti:

[...]

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

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

Questo processo dovrebbe essere completato in pochi secondi.

Possiamo controllare il database popolato con psql :

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
[...]

L'ultimo passaggio dell'installazione è il caricamento dei dati predefiniti nel database. Fornendo il REDMINE_LANG parametro possiamo salvarci da qualsiasi domanda durante il caricamento iniziale.
```
$ RAILS_ENV=production REDMINE_LANG=en bundle exec rake redmine:load_default_data
Default configuration data loaded.
```

L'installazione è completa. Possiamo avviare l'applicazione:

$ 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

L'applicazione è ora in esecuzione ed è possibile accedervi con un browser. Dall'output di cui sopra possiamo intuire che è accessibile sulla porta 3000 , quindi se abbiamo un firewall in esecuzione sulla macchina di destinazione, dobbiamo aprire questa porta per accedere al servizio da remoto:
```
# firewall-cmd --zone=public --add-port=3000/tcp --permanent
# firewall-cmd --reload
```
Aprendo un browser e puntandolo all'indirizzo della macchina e alla porta 3000 (http://192.168.1.14:3000 nella schermata seguente), possiamo accedere all'interfaccia basata sul Web della nostra nuova installazione di Redmine.
Pagina di accesso di Redmine.
Le credenziali predefinite sono admin per nome utente e anche per password. Al primo accesso, l'applicazione ben funzionante richiederà una modifica della password per questo account privilegiato. Da lì il servizio è nostro da compilare, configurare e utilizzare.
Con l'installazione completata, possiamo rimuovere il redmine utente dalla wheel gruppo, eliminando la falla di sicurezza necessaria durante il processo:
```
# gpasswd -d redmine wheel
Removing user redmine from group wheel
# id redmine
uid=1008(redmine) gid=1008(redmine) groups=1008(redmine)
```