Apache e Tomcat su GNU/Linux

Sistemisti Indipendenti.ORG
http://www.sistemistiindipendenti.org
e-mail: [email protected]
Apache e Tomcat su GNU/Linux
Anche l’utilizzo di pagine JSP non rappresenta un problema sotto GNU/Linux. Ovviamente per
poter fare in modo che il nostro sistema sia in grado di interpretarle non basta un normale
server web come Apache, ma è necessario un apposito software, Jakarta disponibile sotto
diverse piattaforme , tra cui GNU/Linux sia in formato sorgente che binario.
Ovviamente questo sistema necessita del compilatore Java (J2SDK) oramai già preinstallato
su molte distribuzioni.
La configurazione migliore prevede inoltre di poter far dialogare Apache, a cui siamo
ovviamente abituati, e Tomcat in modo che quest’ultimo si occupi solo di gestire i contenuti
jsp.
E’ proprio questo che cercheremo di fare, facendo coesistere i due ambienti. Per poter
realizzare completamente il sistema abbiamo bisogno di:
? Java VM (J2SDK)
? Jakarta- Tomcat
? Apache con supporto DSO
? Connector per Apache (mod_jdk2)
Ma partiamo dall’inizio…………
Introduzione: Cosa sono Servlet e JSP
Le Java Servlet e JSP rappresentano due nuovi strumenti di programmazione creati dalla Sun
Microsystems, che permettono di realizzare di pagine web dinamiche.
Sono derivati da Java con cui condividono la sintassi:
?
le Servlet permettono di sviluppare moduli software indipendenti, per gestire pagine
web, anche molto complesse.
Possono essere viste come degli oggetti Java eseguiti direttamente dal server web,
attraverso una JVM (Java Virtual Machine), da inviare al browser. Rispetto agli applet
Java, eseguiti sul client, sono applicazioni eseguite sul lato server che producono un
output, ovvero una pagina HTML, che viene successivamente inviata al client.
?
le JSP (Java Server Pages) invece permettono più semplicemente di inserire codice
Java tra i tag delle pagine HTML.
In genere una servlet può essere richiamata in una pagina HTML, invece una pagina JSP
è qualche cosa di più strutturato, poiché fonde HTML (oppure XML), altri componenti
EJB (Enterprise Java Beans), altre applicazioni Servlets oppure codice Java. In pratica
possiamo vedere le JSP come il contenitore finale in cui fa confluire tutti i metodi che
JAVA consente di utilizzare, per generare pagine dinamiche e veri e propri moduli
software interpretati dal browser, grazie al supporto JSP che il server offre.
Con questi due strumenti si possono sviluppare ed implementare applicazioni totalmente web
oriented, anche molto complesse superando le tradizionali limitazioni e la staticità che
contraddistingue le pagine web.
Installazione JAVA (J2SDK)
Sistemisti Indipendenti.ORG
Sistemisti Indipendenti.ORG
http://www.sistemistiindipendenti.org
e-mail: [email protected]
L’installazione da noi effettuata è stata fatta su Slackware 8.1 kernel 2.4.21, distro su cui
l’ambiente Java non è preinstallato (lo abbiamo fatto appositamente).
Quindi per prima cosa dobbiamo installare JAVA :
Download Java 2 Platform, Standard Edition – Official Download Page
http://java.sun.com/j2se/1.4.2/download.html
self-extracting file (j2sdk-1_4_2_03-linux-i586.bin, 34.16 MB)
?
Alternativamente si può anche prelevare da:
ftp://ftp.tux.org/java/JDK-1.4.2/i386/rc1/
cd /usr/src
sh j2sdk-1_4_2_03-linux-i586.bin
………….
Creating j2sdk1.4.2_03/jre/lib/rt.jar
Creating j2sdk1.4.2_03/jre/lib/jsse.jar
Creating j2sdk1.4.2_03/jre/lib/charsets.jar
Creating j2sdk1.4.2_03/jre/lib/ext/localedata.jar
Creating j2sdk1.4.2_03/jre/lib/plugin.jar
Creating j2sdk1.4.2_03/jre/javaws/javaws.jar
Done.
viene creata la directory j2sdk1.4.2_03/
Su slackware 9.1 è già installata e la dir è in /usr/lib/java, utilizzeremo quindi gli stessi
percorsi anche su questo sistema , in modo da mantenere una certa uniformità.
Aggiorniamo i path aggiungendo i /etc/profile
JAVA_HOME="/usr/lib/java"
export JAVA_HOME
Aggiungia mo alla variabile PATH
# Set the default system $PATH:
PATH="/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:$JAVA_HOME/bin"
*la variabile JAVA_HOME deve precedere la variabile PATH
Proviamo se rispondono i comandi
root@box:~# java -version
java version "1.4.2_03"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_03-b02)
Java HotSpot(TM) Client VM (build 1.4.2_03-b02, mixed mode)
Come usare Java
Se volessimo provare (si fa pe dire) a compilare un sorgente java e ad eseguirlo potremmo
operare in questo modo:
Per compilare un sorgente in formato java:
Sistemisti Indipendenti.ORG
Sistemisti Indipendenti.ORG
http://www.sistemistiindipendenti.org
e-mail: [email protected]
javac Classe.java
Per eseguire un'applicazione:
java Classe
Ad esempio:
----------import java.io.*;
class print_stringa {
public static void main(String args[])
{
System.out.print("Stringa di Prova\n");
}
}
----------Compila:
javac stringa.java
Esegue:
java print_stringa
Stringa di Prova
Installazione e uso di Tomcat
Passiamo adesso all’installazione di Tomcat, il vero protagonista della nostra dimostrazione.
Installazione
Tomcat è un Application Server che consente di sviluppare applicazioni Web in grado di
generare pagine web dinamiche con tecnologia Java e J2EE, come ad esempio Java Servlet e
JSP.
Tomcat incorpora anche un normale webserver di cui supporta tutte le principali funzioni.
Download di tomcat
wget http://freshmeat.net/redir/tomcat/19610/url_tgz/jakarta-tomcat-4.1.29-src.tar.gz
wget http://distfiles.coredump.cn/jakarta-tomcat-5.0.18.tar.gz
L’installazione è davvero semplice ed immediata se si utilizza il file binario che richiede davvero
poche operazioni per poter utilizzare Tomcat sul sistema.
Scompattare
root@box:/usr/src# tar xvfz jakarta-tomcat-5.0.18.tar.gz
mv jakarta-tomcat-5.0.18 /usr/lib
cd /usr/lib
ln -s jakarta-tomcat-5.0.18 tomcat
Aggiorniamo il path in /etc/profile
CATALINA_HOME="/usr/lib/tomcat"
export CATALINA_HOME
Sistemisti Indipendenti.ORG
Sistemisti Indipendenti.ORG
http://www.sistemistiindipendenti.org
e-mail: [email protected]
# Set the default system $PATH:
PATH="/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:$JAVA_HOME/bin:$CATALINA_HOME/bin"
Configurazione accesso
Per poter accedere e gestire Tomcat occorre aggiungere un utente amministratore prima della
partenza del server.
Per fare questo occorre accedere alla directory delle configurazioni ed editare il file tomcatusers.xml e adattarlo alle nostre esigenze
<tomcat-users>
<user name="paolo" password="*****" roles="admin,manager" />
<user name="tomcat" password="tomcat" roles="tomcat" />
<user name="role1" password="tomcat" roles="role1" />
<user name="both" password="tomcat" roles="tomcat,role1" />
</tomcat-users>
Per poter gestire Tomcat ed integrarlo con Java dobbiamo copiare
cd /usr/lib/tomcat
cp common/lib/servlet-api.jar /usr/lib/java/jre/lib/ext –a
Con questa libreria potremo compilare le nostre Servlet application e JSP
Avvio di Tomcat
Per la gestione dell’avvio e dello shutdown del server Tomcat
Avvio server:
startup.sh
root@box:/usr/lib/tomcat# startup.sh
Using CATALINA_BASE: /usr/lib/tomcat
Using CATALINA_HOME: /usr/lib/tomcat
Using CATALINA_TMPDIR: /usr/lib/tomcat/temp
Using JAVA_HOME:
/usr/lib/java
Chiusura server:
shutdown.sh)
Il server risponde dei default alla porta 8080 spesso usata da altri servizi (come il proxy). Per modificare
la porta su cui risponde editare nella directory conf il file server.xml e modificare la direttiva
<!-- Define a non-SSL Coyote HTTP/1.1 Connector on port 8080 -->
<Connector port="8080"
impostando la porta desiderata,
Adesso accedendo con un normale browser potremo effettuare l’amministrazione del server e gestire le
applicazioni contenute nella directory webapps.
Finalmente il nostro tomcat, supporterà le normali pagine Web ma anche le pagine con estensione jsp.
Questo è la home di Apache/Tomcat:
Sistemisti Indipendenti.ORG
Sistemisti Indipendenti.ORG
http://www.sistemistiindipendenti.org
e-mail: [email protected]
Costruire una pagina JSP
A questo punto possiamo cominciare a creare o meglio programmare le nostre pagine jsp.
Ma come funziona il nostro Java Server?
Interpreta pagine al cui interno sono racchiuse istruzioni e parti di codice in linguaggio JAVA,
tra tag del tipo <% e %>. Queste pagine devono necessariamente essere salvate con
estensione .jsp per poter essere interpretate.
Quando il file viene richiesto al Tomcat server questi lo compila, generando un oggetto
chiamato appunto java servlet e lo mantiene in memoria, per poter essere utilizzato
successivamente.
A questo punto l’output prodotto viene inviato e qundi interpretato dal browser come se fosse
una qualsiasi pagina in formato HTML .
In pratica il nostro server agisce da compilatore in-line, velocizzando di molto il processo di
creazione delle pagine, infatti per tutte le richieste che non comportano modifiche alle pagine
originali, non ci sarà bisogno di effettuare nuove compilazioni ed il processo di generazione ed
invio al browser della pagina sarà velocissimo.
Per provare se questo risponde a verità creiamo una semplice pagina jsp con una sintassi
minimale del tipo:
<HTML>
<BODY>
<H1> Pagina JSP di Prova</H1>
<p>
<%="Pagina JSP di Prova" %>
</BODY>
La salviamo con il nome di esempio1.jsp e la depositiamo sotto la directory webapps/ROOT. A
questo punto la richiamiamo dal browser. Se successivamente la modifichiamo e la
richiamiamo sarà necessario un certo tempo per rigenerare il nuovo servlet e poi inviare
l'output al browser. In caso contrario questa operazione non verrà svolta.
Siccome non è obiettivo di questo documento occuparsi di programmazione delle jsp vi
rimando all’ottima guida di HTML.it
?
http://www.html.it/jsp/jndex.htm
Sistemisti Indipendenti.ORG
Sistemisti Indipendenti.ORG
http://www.sistemistiindipendenti.org
e-mail: [email protected]
Integrazione Apache e Tomcat
Spesso si intende utilizzare Tomcat in abbinata con Apache in modo che il primo si occupi in
modo trasparente di eseguire le pagine jsp lasciando ad apache il suo ruolo principale di
webserver.
Cominciamo con il cercare il modulo (connector) per far lavorare insieme Apache e Tomcat.
Download del Modulo
wget http://www.apache.org/dist/jakarta/tomcat-connectors/jk2/jakarta-tomcat-connectorsjk2-src -current.tar.gz
tar xvfz jakarta-tomcat-connectors-jk2-src -current.tar.gz
Compilazione del modulo per Apache
cd /usr/lib/tomcat/jakarta-tomcat-connectors-jk2-2.0.2-src/jk/native2
root@box:/usr/lib/tomcat/jakarta-tomcat-connectors-jk2-2.0.2-src/jk/native2#
with-apxs=/usr/sbin/apxs
./configure --
make
cd /usr/lib/tomcat/jakarta-tomcat-connectors-jk2-2.0.2-src/jk/build/jk2/apache13
cp mod_jk2.so /usr/libexec
? Apache per poter utilizzare il modulo in questione deve essere stato compilato con il
supporto mod_so per caricare dinamicamente i moduli (DSO).
root@box:/home/tomcat/logs# httpd -l
Compiled-in modules:
http_core.c
mod_so.c
Andrà quindi installato eseguendo il configure in questo modo:
./configure --prefix=/usr/local/apache --enable-so --enable-rewrite \
--enable-ssl --with-ssl=/usr/local/ssl --enable-proxy
Configurazione del file server.xml (avvio di Tomcat per appoggio ad Apache)
Questo file determina il comportamento del tomcat server, infatti contiene tutte le informazioni
riguardanti il server.
Nel caso in cui si voglia integrare Apache con Tomcat va comunque modificato dopo essersene
fatti una copia di backup.
<Server port="8005" shutdown="SHUTDOWN" debug="0">
<Service name="Tomcat-Apache">
<Connector className="org.apache.ajp.tomcat.Ajp13Connector"
port="8009" minProcessors="5" maxProcessors="75"
acceptCount="10" debug="0"/>
Sistemisti Indipendenti.ORG
Sistemisti Indipendenti.ORG
http://www.sistemistiindipendenti.org
e-mail: [email protected]
<Engine name="your_engine" debug="0" defaultHost="your_domain.com">
<Logger className="org.apache.catalina.logger.FileLogger"
prefix="apache_log." suffix=".txt"
timestamp="true"/>
<Host name="your_domain" debug="0" appBase="webapps"
unpackWARs="true">
<Context path="" docBase="/home/tomcat/your_application"
debug="0" reloadable="true" />
</Host>
</Engine>
</Service>
</Server>
?
Il Context path non è il path tomcat/webapps ma il path dove metteremo le applicazioni
jsp che Apache dovrà interpretare perché dialoga con Tomcat.
Nel nostro caso:
adduser tomcat
mkdir /home/tomcat/public_html
chown tomcat.users /home/tomcat/public_html/
quindi: Context path="" docBase="/home/tomcat/public_html
?
Il server apache + mod_jk2 ascolta sulla porta 8009 e quindi solo su questa deve
ascoltare Tomcat. Il suo funzionamento sarà diverso da quello “standalone” dove lui
gestiva tutte le connessioni, fungendo da server web in modo completo. In questo
contest o il suo ruolo viene relegato alla gestione della parte jsp e solo alle sessioni
provenienti dalla chiamate di Apache su porta 8009.
Ecco perché il file server.xml, perfetto per un funzionamento di Tomcat standalone va
modificato nel caso in cui lo si voglia integrare con Apache.
Configurazione Apache
#Configurazione modulo
LoadModule jk2_module
AddModule mod_jk2.c
libexec/mod_jk2.so
#per jdk
<IfModule mod_jk.c>
JkWorkersFile "/usr/lib/tomcat/conf/workers.properties"
JkLogFile "/usr/lib/tomcat/logs/mod_jk2.log"
JkLogLevel info
JkLogStampFormat "[%a %b %d %H:%M:%S %Y]"
</IfModule>
? la versione di Apache utilizzata è la 1.3.29
Configurazione del file workers.properties
http://jakarta.apache.org/tomcat/tomcat-4.1-doc/jk2/jk2/confighowto.html
JK2 richiede per funzionare due file di configurazione
Sistemisti Indipendenti.ORG
Sistemisti Indipendenti.ORG
http://www.sistemistiindipendenti.org
e-mail: [email protected]
?
?
jk2.properties:
è utilizzato dal lato Tomcat side. Il su path è in genere
$TOMCAT_HOME/conf .
workers2.properties: è utilizzato dal webserver. Per Apache il path di default è nella
ServerRoot/conf.
Questo file è necessario per fare in modo che Apache sia in grado di passare le chiamate a
Tomcat.
Un file utilizzabile senza necessità di modifiche lo si può trovare nella directory /conf del
modulo jakarta-tomcat-connectors.
Si può copiare quella nella directory dei file di configurazione di jakarta e poi far ripartire prima
Tomcat e poi Apache.
Nel mio caso:
cd /usr/src/JAVA/jakarta-tomcat-connectors-jk2-2.0.2-src/jk/conf
cp workers2.properties /usr/local/apache/conf
Inoltre dobbiamo verificare che il file jk2.properties sia in /usr/lib/tomcat/conf
Una configurazione minima per questi due file può essere:
? http://jakarta.apache.org/tomcat/tomcat-4.1-doc/jk2/jk2/confighowto.html
jk2.properties
# The default port is 8009 but you can use another one
channelSocket.port=8019
#That is all needed on the Tomcat side to configure the JK2.
workers2.properties
# Define the communication channel
[channel.socket:localhost:8009]
info=Ajp13 forwarding over socket
tomcatId=localhost:8009
# Map the Tomcat examples webapp to the Web server uri space
[uri:/examples/*]
info=Map the whole webapp
Dopo aver modificato questi file possiamo far ripartire Tomcat.
Con nmap possiamo controllare i servizi in ascolto sulle porte:
80/tcp open http
8009/tcp open ajp13
8080/tcp open http-proxy
Dopo aver posizionato questo due file ed averli adattati alle nostre esigenze, possiamo
configurare il virtualhost.
Configurazione del Virtualhost
NameVirtualHost 192.168.10.2:80
<VirtualHost 192.168.100.2>
ServerAdmin [email protected]
Sistemisti Indipendenti.ORG
Sistemisti Indipendenti.ORG
http://www.sistemistiindipendenti.org
e-mail: [email protected]
ServerName www.test.it
DocumentRoot /home/tomcat/public_html
ErrorLog /home/tomcat/logs/error_log
CustomLog /home/tomcat/logs/access_log common
<IfModule mod_jk.c>
JkWorkersFile "/usr/lib/tomcat/conf/workers2.properties"
JkMount /servlet/* ajp13
</IfModule>
</VirtualHost>
A questo punto si può provare a far partire Apache dopo averne controllato la correttezza della
sintassi:
apachectl configtest
A questo punto possiamo far partire Apache dando un’occhiata ai file di log
apachectl start
Nel file error_lo g
[Wed Feb 04 16:02:16 2004] ( info) [mod_jk2.c (290)]: mod_jk child init
[Wed Feb 04 16:02:16 2004] ( info) [mod_jk2.c (298)]: mod_jk.post_config() init worker env
[Wed Feb
4 17:02:16 2004] [notice] Apache/1.3.29 (Unix) mod_jk2/2.0.2 PHP/4.3.3 mod_ssl/2.8.16
OpenSSL/0.9.7c configured -- resuming normal operations
Per compatibilità di configurazione
Controllare in jdk2.log eventuali errori di puntamento dei file.
Ora proviamo se funziona:
Creiamo un pagina in JSP
<HTML>
<BODY>
<H1> La mia prima JSP </H1>
<%out.println("PRIMA PROVA DI JSP");%>
</BODY>
</HTML>
E la richiamiamo dal virtualhost
http://host/esempio.jsp
Avremo la nostra pagina senza passare dal Tomcat server su porta non standard e potremo
utilizzare Apache per la gestione di tutte le nostre altre pagine o applicazioni (HTML, php, cgi
ecc ecc).
Risorse
? http://www.linuxgazette.com/issue95/millson.html
? http://jakarta.apache.org/tomcat/tomcat-4.1-doc/jk2/jk2/vhosthowto.html
? http://www.apache.org/dist/jakarta/tomcat-connectors/jk2/source/
? http://www.cymulacrum.net/tomcat/jk2_compile.html
Sistemisti Indipendenti.ORG
Sistemisti Indipendenti.ORG
http://www.sistemistiindipendenti.org
e-mail: [email protected]
?
?
http://www.ejbsolutions.com/products/obox/community/ch15.html
http://www.cardon.biz/docs/tomcat/install_tomcat.html
? Direttive del mod_jk
http://jakarta.apache.org/tomcat/tomcat-4.1doc/jk2/jk/aphowto.html#mod_jk%20Directives
? Varie
http://projects.accessibilityforum.org/tomcat-docs/jk2/jk/aphowto.html
Apache e Tomcat: la soluzione ProxyPass
Questa metodologia risolve molti problemi di compatibilità, nell’utilizzo del modulo sotto
Apache (connector) e rendono semplice l’operazione.
Supponiamo di avere Apache in funzione sul sistema su porta 80 e Tomcat su porta 8081,
possiamo usare Apache come Reverse Proxy per dirottare verso Tomcat determinate richieste,
che in genere sono identificate da un percorso ben preciso, verso cui effettueremo un redirect.
Si possono far dialogare i due sistemi usando il modulo ProxyPass in questo modo:
#httpd.conf
LoadModule proxy_module /usr/libexec/mod_proxy.so
AddModule mod_proxy.c
ProxyPass
/jsp http://localhost:8081/jsp_esempi
ProxyPassReverse /jsp http://localhost:8081/jsp_esempi
/jsp = path per le applicazioni java, jsp
Creiamo la directory per depositare i nostri applicativi jsp
mkdir /usr/lib/tomcat/webapps/ROOT/jsp_esempi
* il forward avviene solo per path che contengono /jsp, in questo modo potremo dirottare a
tomcat su porta 8081, solo le chiamate per le pagine jsp residenti in /jsp (URL) e
$TOMCAT_WEBROOT/jsp_esempi (URI).
A
questo
punto
depositiamo
un
file
con
estensione
.jsp
in
/usr/lib/tomcat/webapps/ROOT/jsp_esempi e richiamiamolo dal browser attraverso Apache.
links http://host/jsp/esempio.jsp
Dovrà generarsi la pagina jsp e dovremo poterla visualizzare nel nostro browser.
Inoltre deve essere specificato un connector apposta per Tomcat del tipo:
<Connector className="org.apache.catalina.connector.http.HttpConnector"
port="8081" ...
proxyName="www.mycompany.com"
proxyPort="80"/>
Sistemisti Indipendenti.ORG
Sistemisti Indipendenti.ORG
http://www.sistemistiindipendenti.org
e-mail: [email protected]
In genere si può trovare in server.xml già i connector specifici come ad esempio :
<Connector port="8080"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false"
acceptCount="100" debug="0" connectionTimeout="20000"
proxyPort="80" disableUploadTimeout="true" />
Per maggiori informazioni:
? http://jakarta.apache.org/tomcat/tomcat-5.0-doc/proxy-howto.html
JSP Risorse in generale
?
?
?
?
?
In
?
?
?
?
http://www.risorse.net/jsp/guida.asp
http://www.html.it/jsp/index.html
http://www.google.com/search?hl=it&ie=ISO-8859-1&q=jsp+manuale&lr=lang_it
http://www.linuxjava.net/howto/webapp/
http://jakarta.apache.org/tomcat/tomcat-4.1-doc/jk2/jk/workershowto.html
Italiano
http://www.cercamanuali.it/manuale-guida/tomcat.htm
http://www.latoserver.it/cocoon/install_c1/
http://web.cefriel.it/formazionetutor/materiale/labSO/apache-tomcat-linux.pdf
http://www.apogeonline.com/webzine/2002/11/07/14/200211071401
Note
Non sono un esperto dell’argomento (si vede ?), ma ho voluto offrire la mia piccola
esperienza, viste le richieste da parte di alcuni utenti.
Consiglio comunque di appoggiarsi alla documentazione ufficiale e ai molti howto che si
possono trovare su web, sicuramente migliori del mio.
Se qualcuno fosse in grado di integrare o migliorare o riscrivere del tutto questo documento
me lo faccia sapere che glielo pubblico subito!
Se volete invece cercare di approfondire l’argomento in generale vi consiglio di passare da
Thinking in Java:
?
http://www.planetpdf.com/mainpage.asp?WebPageID=314
Doc: apache-tomcat.pdf
Dott. Paolo PAVAN [Netlink Sas]– [email protected]
Status: Bozza (in attesa di revisione)
Data : 2003/2004
Note finali
?
?
?
?
?
Il presente documento è a semplice scopo divulgativo
L’autore non si assume la responsabilità di eventuali danni diretti o indiretti derivanti dall'uso dei programmi, o
dall’applicazione delle configurazioni menzionate nel seguente articolo
I marchi citati sono di proprietà dei rispettivi proprietari e sono stati utilizzati solo a scopo didattico o divulgativo.
L’uso o il riutilizzo del presente articolo è liberamente consentito per scopi didattici o informativi previa citazione
della fonte
Sono possibili errori o imprecisioni, segnalatemele a [email protected]
Sistemisti Indipendenti.ORG
Sistemisti Indipendenti.ORG
http://www.sistemistiindipendenti.org
e-mail: [email protected]
?
Chi volesse integrare il presente documento, può scrivere a [email protected].
Sistemisti Indipendenti.ORG