Repository 32bit  Forum
Repository 64bit  Wiki

Redmine e apache via fcgi: differenze tra le versioni

Da Slacky.eu.
(Creata pagina con '<!-- Per http://www.slacky.eu/wikislack/index.php?title=Redmine_e_apache_via_fcgi --> Category: Ufficio_e_Web = Introduzione = In questo articolo vedremo come installare ...')

Versione delle 13:05, 25 nov 2012

Indice

Introduzione

In questo articolo vedremo come installare Redmine sulla Slackware (testato su Slackware 14.0 e 13.37 con gli accorgimenti riportati in seguito) e come configurare il server apache (httpd) in modo da renderlo accessibile via fcgi.

Redmine salva i propri dati su di un database e può gestire diversi tipi di DBMS ma, dato che Slackware ha come DBMS di defaul MySQL, noi useremo quest'ultimo.

Installare Redmine

L'installazione avviene senza problemi seguendo la guida ufficiale. Di seguito, comunque, riporto un sunto di quello che va fatto per installarlo su Slackware.

Step 0: installare fcgi e mod_fcgi

Per poter usare httpd via fcgi (Fast CGI) va installata nel sistema sia la libreria fcgi che il modulo mod_fcgid (per httpd stesso).

fcgi versione 2.4.1-SNAP-0910052249

Il progetto è molto vecchio (2009), ma gli sviluppatori dicono che le modifiche sono minime perché il protocollo è stabile. Il sorgente lo trovate qui, ma noi creeremo il pacchetto per Slackware grazie ai comandi seguenti (l'ultimo va eseguito come root):

cd /tmp
mkdir fcgi
cd fcgi
wget http://www.fastcgi.com/dist/fcgi-2.4.1-SNAP-0910052249.tar.gz
wget http://www.slacky.eu/wikislack/upload/1/13/Fcgi-SlackBuild.tar.bz2
tar -xf Fcgi-SlackBuild.tar.bz2
sh fcgi.SlackBuild

Il pacchetto verrà creato nella directory corrente (/tmp/fcgi).

mod_fcgid versione 2.3.7

Per controllare l'uscita di versioni più recenti si veda questo link. Di seguito, i comandi necessari alla costruzione del pacchetto per Slackware (al solito, l'ultimo va eseguito come root):

cd /tmp
mkdir mod_fcgid
cd mod_fcgid
wget http://apache.panu.it//httpd/mod_fcgid/mod_fcgid-2.3.7.tar.bz2
wget http://www.slacky.eu/wikislack/upload/8/8a/Mod_fcgid-SlackBuild.tar.bz2
tar -xf Mod_fcgid-SlackBuild.tar.bz2
sh mod_fcgid.SlackBuild

Il pacchetto verrà creato nella directory corrente (/tmp/mod_fcgid).

Una volta installato il pacchetto, va anche detto al server httpd di usarlo:

echo 'LoadModule fcgid_module lib64/httpd/modules/mod_fcgid.so' >> /etc/httpd/httpd.conf
Note
Una volta lanciato il server apache, noterete nel suo log /var/log/httpd/error_log, se il modulo è stato caricato correttamente, una riga simile a questa:
AH00489: Apache/2.4.3 (Unix) PHP/5.4.7 mod_fcgid/2.3.7 configured

Alternativamente, si può controllare tra i moduli caricati da apache con:

httpd -M 

Step 1: scaricare Redmine

Scaricate redmine dal sito ufficiale ed estraete l'archivio nella directory che preferite. Tenete conto che la sotto-directory public (contenuta nell'archivio) è quella che verrà gestita dal server web. Per questa wiki, l'archivio è stato scaricato nella directory /tmp ed è stato estratto sotto /var/www/htdocs/ con i comandi (per Redmine 2.1.4):

cd /tmp
wget http://rubyforge.org/frs/download.php/76578/redmine-2.1.4.tar.gz
cd /var/www/htdocs/
tar -xf /tmp/redmine-2.1.4.tar.gz
mv redmine-2.1.4 redmine
chown root.root -R redmine
chmod go-w -R redmine/
Note
Visto che abbiamo installato redmine sotto /var/www/htdocs/, tutti i comandi vanno eseguiti con i diritti dell'utente root. In realtà, se si installa redmine in una directory accessibile all'utente non amministratore, i comandi possono anche essere eseguiti senza l'ausilio del superutente.

Step 2: installare i requisiti

Installate il pacchetto bundler per Ruby eseguendo, come root:

gem install bundler
Slackware 13.37 o precedenti
Il pacchetto bundler necessita di una versione recente di gem non installata nel pacchetto Slackware di Ruby. Si può comunque provare ad installare la versione di Ruby presente nella Slackware 14.0 usando direttamente lo SlackBuild di Pat. Prima di compilare ed installare Ruby, comunque, va compilata e installata anche la libreria libyaml, sempre presenta nella Slackware 14.0. Ecco i link agli SlackBuild ufficiali:


Note
Dato che redmine necessita di tutta una serie di dipendenze per Ruby di cui è difficile trovare i pacchetti Slackware, qui useremo il package manager per Ruby di default, gem. Tutti i pacchetti installati, comunque, saranno inseriti da gem nella directory (su una slackware64-14.0) /usr/lib64/ruby/gems/1.9.1/gems.

Ora, assicuratevi di essere all'interno della directory di redmine:

cd /var/www/htdocs/redmine

Tramite bundler e il file Gemfile fornito con redmine, si possono installare tutte le dipendenze necessarie a quest'ultimo. Prima però bisogna eseguire il comando:

echo "gem 'fcgi'" > Gemfile.local

per dire a bundler che deve installare anche il pacchetto fcgi (per Ruby). Ora siamo pronti ad installare il tutto tramite il comando:

bundle install --without development test postgresql sqlite

le opzioni dicono a bundler di non installare i pacchetti necessari al ramo di sviluppo, a quello di test, e di ignorare anche i pacchetti necessari ai DBMS PostgreSQL e SQLite.

Step 3: preparare il database MySQL

Ora dobbiamo creare sia un database che un utente per MySQL a cui garantire pieno accesso. Come suggerito nella guida ufficiale creiamo il database redmine e l'utente redmine (con password redminepass) via mysql:

mysql -u'root' -p'root_pass'
create database redmine character set utf8;
create user 'redmine'@'localhost' identified by 'redminepass';
grant all privileges on redmine.* to 'redmine'@'localhost';
exit

Step 4: configurare redmine all'uso del database

Per dire a redmine di usare il database creato al passo precedente bisogna creare il file config/database.yml con all'interno le seguenti righe:

production:
  adapter: mysql2
  database: redmine
  host: localhost
  username: redmine
  password: redminepass

Possiamo farlo eseguendo il comando seguente:

echo -e 'production:\n  adapter: mysql2\n  database: redmine\n  host: localhost\n  username: redmine\n  password: redminepass' > config/database.yml

Step 5: generare il secret token

Questo passo genera una chiave random usata da Rails (il framework Ruby usato da Redmine) per codificare i cookie di sessione:

rake generate_secret_token

Step 6: creare le tabelle del database

Ora create le tabelle di redmine con il comando:

RAILS_ENV=production rake db:migrate
Note
La variabile di ambiente RAILS_ENV serve a dire a Rails quale ramo deve usare, quello che abbiamo configurato noi (vedi file config/database.yml) è quello di produzione (c'è anche quello di test e di sviluppo).

Step 7: popolare le tabelle con i dati di default

RAILS_ENV=production REDMINE_LANG=it rake redmine:load_default_data
Note
{{{2}}}

Step 8: permessi a file e directory

Ora dobbiamo garantire l'accesso al server httpd ad alcuni file e directory:

mkdir -p tmp/pdf public/plugin_assets
chown -R apache.apache files log tmp public/plugin_assets

Step 9: testare il tutto

Per controllare se redmine è stato installato correttamente, basta eseguire il comando:

ruby script/rails server webrick -e production

e poi andare all'indirizzo http://localhost:3000/

Step 10: login

Nello step 7 redmine ha creato anche un utente amministratore di default con le seguenti credenziali:

  • login: admin
  • password: admin

Usare fcgi

Una volta installato redmine, possiamo "integrarlo" nel server web apache (httpd) via fcgi. Prima assicuriamoci di aver seguito lo Step 0 del paragrafo precedente e di aver installato via gem il pacchetto fcgi anche per Ruby (Step 2 del paragrafo precedente).

Prima di eseguire i passi seguenti, assicuriamoci ancora una volta di stare nella directory in cui abbiamo decompresso redmine:

cd /var/www/htdocs/redmine

Step 0: preparare redmine e apache

Redmine viene fornito di uno script FCGI che esegue il vero processo. Lo script si chiama public/dispatch.fcgi.example, rinominiamolo (o copiamolo) eliminando l'estensione .example.

mv public/dispatch.fcgi.example public/dispatch.fcgi

Ora che abbiamo il wrapper fcgi, abbiamo anche bisogno di istruire apache in modo che lo esegua. Anche per questo redmine ha un file htaccess di esempio, public/htaccess.fcgi.example. Rinominiamo anche questo:

mv public/htaccess.fcgi.example public/.htaccess
Note
Se date uno sguardo al file public/.htaccess appena spostato, noterete che ci sono una serie di IfModule. Questo perché redmine può essere eseguito via fcgi sia con il modulo per apache mod_fcgid (il nostro caso) sia con mod_fastcgi. Per l'ultimo caso si veda la guida sul sito di redmine. Per le nostre esigenze, il file public/.htaccess potrebbe essere anche riscritto nel modo seguente:
# General Apache options
AddHandler fcgid-script .fcgi

Options +FollowSymLinks +ExecCGI

RewriteEngine On

RewriteRule ^$ index.html [QSA]
RewriteRule ^([^.]+)$ $1.html [QSA]
RewriteCond %{REQUEST_FILENAME} !-f

RewriteRule ^(.*)$ dispatch.fcgi [QSA,L]

ErrorDocument 500 "<h2>Application error</h2>Rails application failed to start properly"


Attenzione
La Slackware non ha, di default, il modulo apache mod_rewrite attivo, necessario per poter usare i file .htaccess. Per attivarlo assicuriamoci che la relativa riga nel file /etc/httpd/httpd.conf sia decommentata (qui la riga per la Slackware64 14.0):
LoadModule rewrite_module lib64/httpd/modules/mod_rewrite.so

Quello che resta da fare è dire a Rails di eseguire l'ambiente di produzione, altrimenti di default verrà eseguito l'ambiente di sviluppo. Per fare questo bisogna inserire all'inizio del file config/environment.rb le seguenti righe:

# Force the rails environment to production
ENV['RAILS_ENV'] ||= 'production'

Possiamo farlo direttamente eseguendo il seguente comando:

sed -i '1i \
# Force the rails environment to production \
ENV["RAILS_ENV"] ||= "production" \
' config/environment.rb

Step 1: configurare il virtual host di apache

Ci sono due modi per rendere disponibile redmine via apache. Possiamo settargli un virtual host dedicato, oppure renderlo disponibile come sotto-directory di un virtual host già esistente.

Virtual host dedicato

Aggiungiamo al file che contiene le impostazioni sui virtual host, /etc/httpd/extra/httpd-vhosts.conf, seguenti righe:

# Redmine
<VirtualHost *:80>
  DocumentRoot "/var/www/htdocs/redmine/public"
  ServerName redmine
  <Directory "/var/www/htdocs/redmine/public">
    AllowOverride FileInfo Options
    Require all granted
  </Directory>
</VirtualHost>
Note
Le due direttive di AllowOverride servono rispettivamente, per abilitare l'uso del file .htaccess e per dare la possibilità a quest'ultimo di aggiungere le opzioni di cui necessita (+FollowSymLinks e +ExecCGI).

Dopo aver riavviato il server apache, basta collegarsi a http://redmine per vedere se il server è attivo (la prima volta ci vorrà un po' tempo affinché il framework Rails faccia il setup completo).

Attenzione
Affinché il link http://redmine funzioni, c'è bisogno che la richiesta venga rediretta al nostro server apache. Nel nostro caso, dato che stiamo provando tutto in locale, questo può essere fatto aggiungendo la riga seguente al file /etc/hosts:
127.0.0.1       redmine

Usare un virtual host esistente

Possiamo installare redmine sotto un virtual host esistente. Per fare questo, però, dato che la directory pubblica è una sotto-directory di redmine (la directory public/), per non dover scrivere nel URL /redmine/public/ è più conveniente settare un alias.

Supponiamo che ci sia già il seguente virtual host configurato nel file /etc/httpd/extra/httpd-vhosts.conf (notate il ServerName come localhost):

<VirtualHost *:80>
  DocumentRoot "/srv/httpd/htdocs"
  ServerName localhost
</VirtualHost>

Per settare l'alias per redmine bisogna modificare la precedente configurazione, con questa:

<VirtualHost *:80>
  DocumentRoot "/srv/httpd/htdocs"
  ServerName localhost

  # Redmine
  Alias "/redmine" "/var/www/htdocs/redmine/public"
  <Directory "/var/www/htdocs/redmine/public">
    AllowOverride FileInfo Options
    Require all granted
  </Directory>
</VirtualHost>

Ora però va modificato il file public/.htaccess settando la RewriteBase come /redmine, altrimenti le richieste a http://localhost/redmine saranno riscritte in maniera errata (in particolare, non andranno verso public/dispatch.fcgi ma direttamente verso dispatch.fcgi). Possiamo farlo con il comando seguente:

sed -i '/^RewriteEngine/a \
RewriteBase /redmine' public/.htaccess

Prima di testare il tutto, bisogna correggere un piccolo bug del framework Rails che gli impedisce di avviarsi in maniera corretta quando l'applicazione è un alias di un virtual host. Quindi modifichiamo il file config/environment.rb sostituendo le righe:

# Initialize the rails application
RedmineApp::Application.initialize!

in:

# Initialize the rails application
RedmineApp::Application.routes.default_scope =  { :path => '/redmine', :shallow_path => '/redmine' }
RedmineApp::Application.initialize!
Redmine::Utils::relative_url_root = '/redmine'

Ora tutto dovrebbe essere pronto e redmine dovrebbe rispondere correttamente all'indirizzo http://localhost/redmine.

Possibili problemi

Se redmine non dovesse funzionare a dovere, potete provare a guardare il file di log log/production.log.

`require': no such file to load -- fcgi (LoadError)

Se trovate questo errore, provate a modificare il file public/dispatch.fcgi inserendovi all'inizio le seguenti righe:

require 'rubygems'
require 'fcgi'

Ovviamente dovete anche aver installato il pacchetto fcgi per Ruby, come visto nello Step 2 fatto durante l'installazione di redmine. Se non l'avete fatto, potete sempre farlo con:

gem install fcgi

Rimuovere il tutto

Durante l'installazione di redmine, abbiamo modificato qualche file di configurazione ed installato un bel po' di software. Vediamo come poter tornare indietro.

Rimozione pacchetti installati

I pacchetti da rimuovere, con removepkg, sono:

  • mod_fcgid
  • fcgi

(eventualmente anche ruby e libyaml).

removepkg mod_fcgid fcgi

Vanno anche cancellati, il file:

/var/run/fcgid_shm

e la directory:

/var/run/fcgidsock/

con:

rm -r /var/run/fcgid_shm /var/run/fcgidsock/

Pacchetti per Ruby

Via gem e bundler abbiamo installato i seguenti pacchetti sotto (per Slackware64-14.0) /usr/lib64/ruby/gems/1.9.1/gems/:

  • actionmailer-3.2.8
  • actionpack-3.2.8
  • activemodel-3.2.8
  • activerecord-3.2.8
  • activeresource-3.2.8
  • activesupport-3.2.8
  • arel-3.0.2
  • builder-3.0.0
  • bundler-1.2.2
  • coderay-1.0.8
  • erubis-2.7.0
  • fcgi-0.8.8
  • hike-1.2.1
  • i18n-0.6.1
  • journey-1.0.4
  • jquery-rails-2.0.3
  • json-1.7.5
  • mail-2.4.4
  • mime-types-1.19
  • multi_json-1.3.7
  • mysql2-0.3.11
  • net-ldap-0.3.1
  • polyglot-0.3.3
  • rack-1.4.1
  • rack-cache-1.2
  • rack-openid-1.3.1
  • rack-ssl-1.3.2
  • rack-test-0.6.2
  • rails-3.2.8
  • railties-3.2.8
  • rake-10.0.2
  • rdoc-3.12
  • rmagick-2.13.1
  • ruby-openid-2.1.8
  • sprockets-2.1.3
  • thor-0.16.0
  • tilt-1.3.3
  • treetop-1.4.12
  • tzinfo-0.3.35

Tutti questi pacchetti possono essere rimossi con il comando seguente (occhio che se qualche altro software per Ruby li usa ...):

cd /usr/lib64/ruby/gems/1.9.1
rm -r */actionmailer-3.2.8* */actionpack-3.2.8* */activemodel-3.2.8* \
*/activerecord-3.2.8* */activeresource-3.2.8* */activesupport-3.2.8* \
*/arel-3.0.2* */builder-3.0.0* */bundler-1.2.2* */coderay-1.0.8* */erubis-2.7.0* \
*/fcgi-0.8.8* */hike-1.2.1* */i18n-0.6.1* */journey-1.0.4* */jquery-rails-2.0.3* \
*/json-1.7.5* */mail-2.4.4* */mime-types-1.19* */multi_json-1.3.7* \
*/mysql2-0.3.11* */net-ldap-0.3.1* */polyglot-0.3.3* */rack-1.4.1* \
*/rack-cache-1.2* */rack-openid-1.3.1* */rack-ssl-1.3.2* */rack-test-0.6.2* \
*/rails-3.2.8* */railties-3.2.8* */rake-10.0.2* */rdoc-3.12* */rmagick-2.13.1* \
*/ruby-openid-2.1.8* */sprockets-2.1.3* */thor-0.16.0* */tilt-1.3.3* \
*/treetop-1.4.12* */tzinfo-0.3.35*

Redmine

Ovviamente va anche eliminato redmine stesso:

cd /var/www/htdocs/
rm -r redmine

Database

Il database e l'utente creati si possono eliminare con:

mysql -u'root' -p'root_pass'
drop database redmine;
drop user redmine@localhost;
exit

File modificati

  • /etc/httpd/httpd.conf: eliminare la riga
LoadModule fcgid_module lib64/httpd/modules/mod_fcgid.so
  • /etc/hosts: solo se l'abbiamo modificato inserendo la riga:
127.0.0.1       redmine

Autore

Targzeta (discussioni) 13:05, 25 nov 2012 (CET)

Strumenti personali
Namespace

Varianti