Introdurre e configurare Redmine su Debian 9.

Prima di iniziare assicurati di fare questo

• Avere un nome di dominio che punti a un IP pubblico sul tuo server. Utilizzeremo example.com.
• Acceduto come utente sudo preferito.
• Installato Nginx
• Avere un certificato SSL di dominio installato.

Crea un database MySQL

Redmine supporta MySQL/MariaDB, SQL Server, SQLite 3, Microsoft e PostgreSQL. Utilizzeremo MariaDB come back-end per il database. Verifica di avere installato almeno MySQL 5.7 o MariaDB 10.3 sul tuo PC. 
Se il tuo server Debian non ha MariaDB o MySQL, puoi installarlo seguendo queste istruzioni. 
Inizia accedendo alla console di MySQL digitando:
$ sudo mysql
Per creare un nuovo database, esegui la seguente istruzione SQL: 
mysql> CREATE DATABASE redmine CHARACTER SET utf8mb4;
Crea un nuovo utente per MySQL e consenti l'accesso al database: 
mysql> GRANT ALL ON redmine.* TO 'redmine'@'localhost' IDENTIFIED BY 'cambia-con-password-forte';
mysql> flush priviledges; <- questo è importante! Altrimenti, le modifiche non si applicheranno fino al riavvio del servizio mysql.
Ricorda di cambiare una password forte con cambia-con-password-forte.
Una volta fatto, esci dalla console di MariaDB digitando:
mysql> EXIT;

Installa Ruby

Installa l'ultima versione di Ruby tramite Rbenv o RVM.

RVM

1. installa rvm, eseguilo, aggiungilo all'avvio automatico
curl -sSL https://get.rvm.io | sudo bash -s master
source /etc/profile.d/rvm.sh
echo '[[ -s "/etc/profile.d/rvm.sh" ]] && source "/etc/profile.d/rvm.sh"' >> ~/.bashrc
2. Crea l'utente "easy" (o puoi chiamarlo come preferisci, l'importante è che questo utente lavori con la tua applicazione redmine, non l'utente root. Dovrebbe essere fatto per motivi di sicurezza)
useradd -m -G rvm -s /bin/bash easy
Inoltre, devi aggiungere l'utente "easy" al gruppo sudoers (dobbiamo consentire a questo utente di eseguire alcuni comandi da sudo)
usermod -a -G sudo easy
Se hai fatto questo, potresti saltare il passaggio successivo, perché dopo questo comando il tuo utente è già nel gruppo appropriato. Passa a questo utente
su - easy
3. aggiungi l'utente al gruppo rvm
usermod -a -G rvm easy
Inoltre, devi aggiungere l'utente "easy" al gruppo sudoers (dobbiamo consentire a questo utente di eseguire alcuni comandi da sudo)
usermod -a -G sudo easy
Passa all'utente "easy"
su - easy
4. installa ruby
rvm install 2.6 --patch railsexpress
5. installa git
sudo apt-get install git
6. imposta ruby 2.6 come predefinito
rvm use 2.6 --default
La parte in corsivo è necessaria solo se stai installando ruby da un utente non root. Se decidi di lasciarlo, puoi sostituire il nome utente "easy" con "redmine".

Rbenv

Segui le istruzioni in questo articolo.

Introdurre Passenger e Nginx #

Passenger è un server di applicazioni web Ruby, Node.js e Python veloce e leggero che può essere incorporato con Apache e Nginx. Passenger verrà introdotto come modulo Nginx.

Installare i pacchetti necessari per creare un repository https:

$    sudo apt install dirmngr gnupg apt-transport-https ca-certificates software-properties-common

Importare la chiave GPG del repository e consentire al repository Phusionpassenger di:

$   sudo apt-key adv --recv-keys --keyserver hkp://keyserver.ubuntu.com:80 561F9B9CAC40B2F7

$   sudo add-apt-repository 'deb https://oss-binaries.phusionpassenger.com/apt/passenger stretch main'

Aggiornare l'elenco dei pacchetti e installare il modulo Nginx Passenger con:

$   sudo apt update

$   sudo apt install libnginx-mod-http-passenger

$   gem install passenger --no-ri --no-rdoc

$   passenger-install-nginx-module

Installare Redmine su Debian

Iniziare installando le dipendenze necessarie per creare un Redmine:

$    sudo apt install build-essential libmariadbclient-dev imagemagick libmagickwand-dev curl ruby-dev libxslt-dev libxml2-dev zlib1g-dev

Prima di procedere con il passaggio successivo, è necessario verificare la pagina di download di Redmine per una versione più recente.

Scaricare Redmine

Usare il seguente comando curl per scaricare l'archivio su Redmine:

$     sudo curl -L http://www.redmine.org/releases/redmine-4.0.4.tar.gz -o /tmp/redmine.tar.gz

Estrarre l'archivio e trasferirlo nella directory /opt una volta completato il download:

$  cd /tmp

$  sudo tar zxf /tmp/redmine.tar.gz

$  sudo mv /tmp/redmine-4.0.4 /opt/redmine

Configurare il database di Redmine:

Copiare il file di configurazione per un esempio in Redmine:

$     sudo cp /opt/redmine/config/database.yml.example /opt/redmine/config/database.yml

Aprire il file del proprio editor di testo:

$    sudo nano /opt/redmine/config/database.yml

Cercare la sezione di produzione e inserire le informazioni sul database e sull'utente MySQL creati in precedenza:

/opt/redmine/config/database.yml

Produzione:

  adapter: mysql2

  database: redmine

  host: localhost

  username: redmine

  password: "cambia-con-password-forte"

  encoding: utf8

Salvare il file e uscire dall'editor.

Installare le condizioni di Ruby

Installare bundler e altre condizioni di Ruby ed esplorare il catalogo Redmine:

$ cd path/to/redmine/

$ sudo gem install bundler

$ sudo bundle install -- without development test

Rilocare il database generando le chiavi:

Eseguire l'ordine di generazione delle chiavi accompagnatorio e rilocare il database.

$ sudo bundle exec rake generate_secret_token

$ sudo RAILS_ENV=production bundle exec rake db:migrate

Impostare le autorizzazioni corrette

Nginx viene eseguito come client e rete delle informazioni www. Impostare le autorizzazioni correttamente fornendo l'ordine chown seguente.

$    sudo chown -R www-data: /opt/redmine/

Configurazione di Nginx

Nota: In questo blog, puoi apprendere di più su letsencrypt e su un modo alternativo per creare/acquistare certificati HTTPS (cert-manager).

Se non hai ancora verificato i prerequisiti per questo tutorial, dovresti già avere Nginx con un certificato SSL installato sul tuo sistema.

Apri il tuo editor di testo e crea il seguente file di blocco per il server Nginx:

$    sudo nano /etc/nginx/sites-available/example.com

/etc/nginx/sites-available/example.com

# Reindirizza HTTP -> HTTPS

server {

    listen 80;

    server_name www.example.com example.com;

    include snippets/letsencrypt.conf;

    return 301 https://example.com$request_uri;

}

# Reindirizza WWW -> NON WWW

server {

    listen 443 ssl http2;

    server_name www.example.com;

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;

    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

    ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;

    include snippets/ssl.conf;

    return 301 https://example.com$request_uri;

}

server {

    listen 443 ssl http2;

    server_name example.com;

    root /opt/redmine/public;

    # Parametri SSL

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;

    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

    ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;

    include snippets/ssl.conf;

    include snippets/letsencrypt.conf;

    # File di log

    access_log /var/log/nginx/example.com.access.log;

    error_log /var/log/nginx/example.com.error.log;

    passenger_enabled on;

    passenger_min_instances 1;

    client_max_body_size 10m;
}
Non dimenticare di utilizzare il tuo dominio Redmine al posto di example.com e impostare il percorso corretto per i file del certificato SSL. Tutte le richieste HTTP verranno inoltrate a HTTPS. Questa guida genera i frammenti utilizzati in questa configurazione.
Abilita il server blocco creando un link simbolico alla directory abilitata per i siti:
$    sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/
Fai un test prima di riavviare il servizio Nginx per essere sicuro che non ci siano errori di sintassi: 
$  sudo nginx -t
Se non si verificano errori, l'output dovrebbe apparire così: 
nginx: il file di configurazione /etc/nginx/nginx.conf ha una sintassi corretta
nginx: il file di configurazione /etc/nginx/nginx.conf è stato testato con successo
Infine, riavvia il servizio con Nginx digitando:
$  sudo systemctl restart nginx

Accedi a Redmine

Apri il tuo browser, digita il tuo dominio e, se l'installazione è andata a buon fine, apparirà una schermata simile a quella seguente: 

Le credenziali di accesso predefinite di Redmine sono: 
Nome utente: admin
Password: admin
Alla prima connessione, ti verrà chiesto di cambiare la password come mostrato di seguito: 

Dopo aver cambiato la password, verrai reindirizzato alla pagina del tuo account utente.
Hai installato Redmine con successo sul tuo sistema Debian.