Diferencia entre revisiones de «Usuario:ManuelRomero/modulo TOMCAT»

De WikiEducator
Saltar a: navegación, buscar
(Página reemplazada por '{{:Usuario:ManuelRomero/micursos/Tomcat/nav}} <br>')
 
Línea 1: Línea 1:
 
{{:Usuario:ManuelRomero/micursos/Tomcat/nav}}
 
{{:Usuario:ManuelRomero/micursos/Tomcat/nav}}
<br>  
+
<br>
=Aplicaciones Web =
+
;Definición de aplicación web
+
:Aplicación informática que se ejecuta en un entorno web
+
:Modelo de ejecución Cliente /Servidor
+
:Necesario un  protocolo de comunicación .
+
;Elementos
+
:'''''Cliente''''': navegador.
+
:'''''Servidor''''': servidor web
+
:'''''Comunicación''''': protocolo HTTP
+
 
+
===Servidor de aplicaciones===
+
;Definición de servidor de aplicaciones
+
:Es un software que proporciona aplicaciones a los equipos o dispositivos cliente,
+
:Es muy frecuente el uso de la red de Internet para realizarlo
+
:Utiliza el protocolo '''''http'''''
+
:Presenta dos diferencias con los servidores web (p.e. '''''apache''''')
+
#Hace un extensivo del contenido dinámico
+
#De manera muy frecuente realiza integración con bases de datos.
+
===Ventajas de servidor de aplicaciones===
+
;centralización y simplicidad en desarrollo de aplicaciones
+
:Las aplicaciones se ensamblan desde bloques que el servidor provee
+
;Integridad de datos y de código
+
:Al actulizar los datos que estás centralizados todos los clientes serán conscientes de ello
+
===Tomcat ===
+
;Definición
+
:Tomcat es el servidor web (incluye el servidor Apache)  que puede gestionar las solicitudes y respuestas http
+
:También es servidor de aplicaciones del proyecto Yakarta contenedor de '''''Servlets y JSP'''''
+
:Especialmente útil para porgramar aplicaciones web usando '''''java'''''
+
:Incluye el compilador Jasper, que compila JSP covirtiéndolas en servlets.
+
===Servlet===
+
;Definición
+
:Un servlet es un programa escrito en java
+
:se ejecuta en un servidor
+
:normalmente se utiliza para generar contenido html dinámico.
+
*Ejemplo de servlet en java
+
<source lang=java>
+
Código de ejemplo de un Servlet que procesa una petición GET y devuelve una página web HTML sencilla:
+
package org.pruebas;
+
+
import java.io.IOException;
+
import java.io.PrintWriter;
+
import javax.servlet.ServletException;
+
import javax.servlet.http.HttpServlet;
+
import javax.servlet.http.HttpServletRequest;
+
import javax.servlet.http.HttpServletResponse;
+
+
public class HolaMundoServlet extends HttpServlet {
+
+
    /**
+
    * Servlet de ejemplo que procesa una petición GET
+
    * @param request
+
    * @param response
+
    * @throws ServletException
+
    * @throws IOException
+
    */
+
    @Override
+
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+
        PrintWriter out = response.getWriter();
+
        out.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\">");
+
        out.println("<html>");
+
        out.println("<head><title>Ejemplo Hola Mundo</title></head>");
+
        out.println("<body>");
+
        out.println("<h1>¡Hola Mundo!</h1>");
+
        out.println("</body></html>");
+
    }
+
}
+
</source>
+
*Al final del tema al estudiar el despliegue web y analizar el fichero web.xml del servidor de aplicaciones web o contendedor de servlet tomcat probaremos este fichero.
+
===JSP===
+
;Definición
+
:JSP es un lenguaje de programación parecido al lenguaje ''php''
+
:Es un código que ejecuta el servidor de aplicaciones web ,  al lado del servidor en el modelo cliente/servidor
+
:Se puede embeber junto con códgio html
+
:El servidor interpretar JSP de la misma manera en la que interpreta PHP, generando una página html que entrega al claiente
+
*Ejemplo sencillo de un jsp
+
<source lang=html4strict>
+
<html>
+
<body>
+
<% out.println("Hola mundo"); %>
+
</body>
+
</html>
+
</source>
+
 
+
===Tomcat contenedor de servlets===
+
*'''''Tomcat''''' es un contenedor de servlets con un entorno JSP.
+
*es un servidor de aplicaciones web pensado para desarrollos con java (no exclusivo para este entorno)
+
;Contenedor de servlets
+
:es un shell de ejecución que maneja e invoca servlets por cuenta del usuario.
+
:A veces al '''''contenedor de servlets''''' se le llama '''''servidor''''')
+
:Tiene una serie de características entra las que podemos enumerar:
+
#gestiona  los Servlets (instanciar, acceso, destrucción...)
+
#controla su ciclo de vida.
+
#Es un programa  adicional que hay que instalar para dar soporte a este tipo de aplicaciones Java en entornos J2EE.
+
#Algunos de estos "contenedores" disponibles son MacroMedia JRun, Bea WebLogic, Sun One y uno de los más populares: Apache Tomcat.
+
 
+
===Clasificación de contenedores de servlets===
+
;Contenedores de servlets '''''stand-alone''''' (independientes):
+
:Estos son una parte integral del servidor web.
+
:Este es el caso en el que se usa un servidor web basado en Java,
+
:Por defecto Tomcat trabaja en este modo, sin embargo, la mayoría de los servidores no están basados en Java.
+
 
+
;Contenedores de servlets '''''dentro-de-proceso''''':
+
:En esta configuración del servidor, el contenedor servlets es una combinación
+
::Un plugin para el servidor web
+
:: y una implementación de contenedor Java.
+
:El plugin del servidor web abre una JVM (Máquina Virtual Java)
+
:dentro del espacio de direcciones del servidor web
+
:permite que el contenedor Java se ejecute en él.
+
 
+
:En el caso de que una petición debiera ejecutar un servlet, el plugin toma el control sobre la petición y lo pasa al contenedor Java (usando JNI).
+
:Un contenedor de este tipo es adecuado para servidores multithread de un sólo proceso
+
:Además este tipo  proporciona un buen rendimiento pero está limitado en escalabilidad.
+
 
+
;Contenedores de servlets '''''fuera-de-proceso''''':
+
:En este caso la combinación va a ser:
+
::plugin para el servidor web
+
::y una implementación de contenedor Java
+
:'''''Este  se ejecuta en una JVM fuera del servidor web.'''''
+
:El plugin del servidor web y el JVM del contenedor Java se comunican
+
:para ello usan algún mecanismo IPC (normalmente sockets TCP/IP).
+
:Si una cierta petición tuviese que ejecutar un servlets, el plugin toma el control sobre la petición y lo pasa al contenedor Java (usando IPCs).
+
:El tiempo de respuesta en este tipo de contenedores no es tan bueno como el anterior
+
:A su favor, obtiene mejores rendimientos en otras cosas (escalabilidad, estabilidad, etc.)
+
===Instalación de Tomcat===
+
*Necesitamos tener instalado JDK
+
*buscamos el paquete java que más nos interese
+
aptitude search "?provides(java-runtime)"
+
*instalamos java-runtime
+
apt-get install default-jre
+
*actualizamos el PATH del sistema en nuestro profile
+
*Indicando donde se ubican los binarios que acabamos de instalar
+
JAVA_HOME=/usr/lib/jvm/java6openjdk/ jre/
+
PATH=$PATH:$JAVA_HOME/bin
+
export PATH JAVA_HOME
+
*actualizamos las variables de entorno
+
$ source /etc/profile
+
o  bien
+
$ .  /etc/profile
+
*Vamos a la web de tomcat y vemos la última version
+
http://apache.rediris.es/tomcat/
+
[[Imagen:webTomcat.png]]
+
*Tomamos la última version ''''' v7.0.32''''' y la descargamos
+
$  wget http://apache.rediris.es/tomcat/tomcat-7/v7.0.32/src/apache-tomcat-7.0.32-src.tar.gz
+
 
+
*Descomprimimos y desenpaquetamos el fichero
+
$ tar xvzf apache-tomcat-7.0.32-src.tar.gz
+
*Movemos a una carpeta de destino
+
$ mv -fv apache-tomcat-7.0.32-src /usr/local
+
*Creamos un enlace para referenciar más comodamente el directorio
+
$ ln -s /usr/local/apache-tomcat-7.0.32-src/ /usr/local/tomcat
+
*De este modo tenemos acceso al directorio de tomcat de forma  más sencilla
+
 
+
===Arranque del sistema===
+
*Un script llamado '''''catalina''''' gestiona el servicio de '''''Tomcat'''''
+
*''''''catalina.hs''''' debe recibir en la invocación parámetros start|stop|restart para actuar.
+
*También disponemos de un shell que invoca explícitamente a este fichero '''''startup.sh'''''
+
*verificamos el funcionamiento escribiendo en la url
+
http://127.0.0.1:8080
+
*Debe aparecernos una página como la que sigue
+
[[Imagen:paginaTomcat.png]]
+
===Iniciando Tomcat===
+
*Por defecto '''''tomcat'''''
+
#puerto '''''8080'''''
+
#directorio ./tomcat/webapps/ROOT
+
*Por defecto '''''apache'''''
+
#puerto '''''80'''''
+
#directorio ./var/www o ./apache/htdocs ''según como se haya instalado''
+
*Vamos a hacer que apache escuche todo
+
*Lo configuramos como proxy
+
*Apache derivará lo que considere a tomcat
+
*aplicamos el principio de escalabilidad
+
**Si nuestras necesidades crecen ponemos más tomcat en el sistema
+
===Fichero de configuración===
+
'''''/usr/local/tomcat/conf/server.xml'''''
+
*Al ser un fichero '''''xml''''' se configura por ''elementos'' y ''atributos''
+
#localizamos el elemenot '''''host'''''
+
#modificamos el atributo '''''appBase'''''
+
<source lang=xml>
+
<Host name="localhost" appBase="/var/www"
+
</source>
+
=Apache y Tomcat Colaborando=
+
*Ahora tenemos en nuestro sistemas dos servicios que responden a solicitudes web, pero son diferentes
+
*Debemos otorgar a cada uno su funcionalidad
+
*Podemos hacer que convivan juntos de la siguiente manera, la idea es la siguiente
+
*Todas las peticiones la recibe el servidor de apache
+
#Si es una solicitud web estática o php la resuelve apache
+
#Si es una solicitud de una aplicación web (jsp, servlet) se la entrega a tomcat para que resuelva el
+
*El final es apache el que devuelve la solicitud al cliente
+
*Este funcionamiento es totalmente trasparente para el usuario
+
*Este escenario también es útil para que apache balancee la carga entre diferentes servidores de aplicaciones web y aligerar el trabajo
+
[[Archivo:proxy.png]]
+
===Módulos necesarios===
+
*Necesitamos que apache incorpore una serie de módulos
+
*Cargaremos estos módulos para hacer que sea apache un proxy
+
*Para cargar módulos usamos el comando  '''''a2enmod''''' ''apache to enabled module''
+
*Este comando sirve para cargar módulos nuevos
+
*Ya sabemos que apache se gestiona por módulos
+
*La lista de módulos que necesitamos son
+
; proxy, proxyf_ajp, proxy_balancer
+
 
+
*A continuación rearrancamos el sistema
+
$a2enmod proxy
+
$a2enmod proxyf_ajp
+
$a2enmod proxy_balancer
+
$ /etc/init.d/apache2 restart
+
===Directivas necesarias en epache===
+
Usaremos las siguientes directivas
+
#ProxyPass
+
#ProxyPassReverse
+
#ProxyRequests
+
#ProxyPreserveHost.
+
===ProxyPass===
+
*Esta directiva tiene dos parámetros
+
#El primero Indicamos las URL que delegamos (/)
+
#El segundo el servidor de aplicaciones que atenderá la solicitud
+
#En nuestro caso especificamos tomcat_cluster  que está definido previamente
+
<source lang=xml>
+
<Proxy balancer://tomcat_cluster>
+
Order allow,deny
+
Allow from all
+
BalancerMember ajp://localhost:8009
+
</Proxy>
+
</source>
+
===Conceto del proxy y el protocolo ajp===
+
*En lugar de usar http para comunicar apache-tomcat usamos ajp
+
*Es un protocolo interno, veloz y que usa conexiones '''''TCP persistentes'''''
+
*Funciona en el puerto 8009
+
;<nowiki>Proxy balancer://tomcat_cluster</nowiki>
+
:definimos el cluster con nombre '''''tomcat_cluster'''''
+
;<nowiki>BalancerMember ajp://localhost:8009</nowiki>
+
:Se define un miembro a '''''tomcat_cluster'''''
+
::protocolo '''''ajp'''''
+
::IP '''''localhost'''''' o '''''127.0.0.1'''''
+
::Puerto '''''8009''''' que es el que por defecto usa ''tomcat''
+
;<nowiki>ProxyPass / balancer://tomcat_cluster/</nowiki>
+
:"/" y todo lo que cuelgue de ella, sea pasado al cluster del tomcat para que lo procese él.
+
;Order allow,deny
+
:Especifica el orde de asignación de permisos
+
::Primero las especificaciones de permisos '''''allow all''''''
+
::Posteriormente restricciones especificadas en la opción '''''deny'''''
+
*Si en lugar de '''''ajp''''' queremos usar http deberíamos especificar
+
  http://localhost:8080/ en lugar de  ajp://localhost:8009
+
 
+
===Parte para apache, otra para tomcat===
+
*Queremos que apache devuelva los contenidos estáticos
+
*Estas peticiones deben comenzar por /static/
+
*Para que lo haga apache el segundo parámetro de esta directiva debe ser una negación '''''!'''''.
+
 
+
===Configuración de '''''virtualhost'''''===
+
*Debemos modificar el fichero de configuración de virtualhost
+
*Editamos /etc/apache2/sites-enabled/000-default
+
*Añadimos los siguientes elementos
+
<source lang=xml>
+
<Proxy balancer://tomcat_cluster>
+
Order allow,deny
+
Allow from all
+
BalancerMember ajp://localhost:8009
+
</Proxy>
+
ProxyPreserveHost On
+
ProxyPass /phpmyadmin/ !
+
ProxyPass / balancer://tomcat_cluster/
+
ProxyPassReverse / balancer://tomcat_cluster/
+
</source>
+
 
+
===Conceptos de los parámetros===
+
;ProxyPreserveHost On
+
: Mantiene la cabecera http host original, en vez de reescribirla.
+
* "DocumentRoot" y "<Directory /var/www/>" para que apunten a /var/www/ROOT
+
=Estructura y despliegue de una aplicación web=
+
===Conceptos generales===
+
<br/>
+
{{Conocimiento previo|
+
#Fichero de configuración de tomcat '''''./tomcat/conf/server.xml'''''
+
#Directiva para donde buscar los ficheros de las aplicacioes '''''appBase'''''
+
#Por defecto valor de appBase "webapp"
+
}}
+
;Elementos de una aplicación web
+
#servlets
+
#páginas jsp
+
#ficheros html,imágenes,texto, css,sonitos, fídels, etc
+
*La aplicación se crea en un directorio
+
*El directorio debe de colgar en el directorio base de tomcat que cuelga en el indicado en '''''appBase'''''
+
===Comenzando a desarrollar la aplicacion y despliegue===
+
*Vamos a realizar una muy sencilla aplicación para ver el despliegue
+
*Se trata de una aplicación cliente/servidor que cumpla las siguientes especificaciones
+
{{Ejemplo|
+
Un cliente solicita una página web llamada '''''acceso.jsp'''''
+
El servidor le da una página html donde se me muestra un formulario para insertar mi nombre, apellido y edad
+
 
+
*
+
;servlets
+
:aplicación java encargada de realizar un servicio específica dentro de un servidor web
+
:La especificación 2.4 define la estructura de directorios para los ficheros de una aplicación web
+
:Aquí puedes ver el fichero completo de la especificación final [[Archivo:javaservletspecivication_2_4.pdf]]
+
*Este podría ser un ejemplo sacado de la propia especificación ''pág 69-70''
+
/index.html
+
/howto.jsp
+
/feedback.jsp
+
/images/banner.gif
+
/images/jumping.gif
+
'''''/WEB-INF/web.xml'''''
+
'''''/WEB-INF/lib/'''''jspbean.jar
+
'''''/WEB-INF/classes/'''''com/mycorp/servlets/MyServlet.class
+
'''''/WEB-INF/classes/'''''com/mycorp/util/MyUtils.class
+
*los directorios/ficheros en negrita son obligatorios
+
 
+
===Estructura de directorios===
+
*El directorio raiz contendrá el nombre de la aplicación
+
*Todos los ficheros que cuelguen de él se pueden servir al cliente menos los que cuelguen de directorios '''''META-INF''''' y '''''WEB-INF'''''
+
*Normalmente después de realizar el desarrollo se empaquetarán en un archivo '''''.war'''''
+
*Una estructura de directorios almacenará el código necesario para ejecutar la aplicación.
+
*Una aplicación web se estructura en tres capas:
+
[[Imagen:EstructuraTresCapas.png ]]
+
===Archivos War===
+
*WAR '''''W'''''eb '''''A'''''pplicatio '''''A'''''rchive ''(Archivo de Aplicación Web)''
+
*Es una forma de empaquetar en un fichero la estructura de directorios que conforman la aplicación web
+
*Por lo tanto contendrá
+
#Servlets y JSP
+
#Contendio estático HTML, css, imágenes
+
#Otros recursos web
+
*Facilitan enormemente el despliegue web
+
*Su estructura ya vista anteriormente
+
;/
+
:Es la carpeta raiz del proyecto
+
:En el se crean más subdirectorios para organizar la información
+
:Los ficheros aquí ubicados serán accesibles por el cliente
+
:Habrá html, js`, css, imágenes, videos, ...
+
;/WEB/INF/
+
:Elementos de la configuración .WAR '''''web.xml'''''
+
:Suelen estar la página de inicio, ubiciación de los servlets, parámetros
+
;/WEB/INF/clases/
+
:Las clases JAVA empleadas  en el archivo .WAR
+
:Suelen encontrarse los servlet
+
;/WEB/INF/lib/
+
:Contiene ficheros '''''jar''''' utilizados por la aplicación
+
:Por ejemplo para contectarse a la base de datos
+
===Creación del fichero .WAR===
+
*Los entornos de desarrollo tipo Eclipse, NetBeans y otro tipo de IDE  (JBuilder, JDeveloper) poseen la opción para ello.
+
*Otro modo en mediante '''''Ant'''''  herramienta open-source que facilita la contrucción de aplicaciones Java
+
===Haciendo un ejemplo sencillo===
+
*Realizaremos un sencillo ejemplo para ver el proceso de despliegue
+
*Nuestra aplicación tendrá
+
#una página html que me pedirá nombre, apellido y edad
+
##Lo presentará como un formulario
+
#Un servlet que procesará dichos datos
+
##En este caso sólo los tomará y me los visualizará en otra página html que el servidor devolverá al cliente
+
#Necesitamos tener instalado e iniciado el contenedor de servlet (tomcat) éste se informará con un fichero ''''''wweb.xml''''' de todos los servlets disponibles
+
[[archivo:xml.png]]
+
====Estructura de directorios===
+
WebApp ==>
+
      DatosUsuario (datos.html)==>
+
                          WEB-INF (web.xml)==>
+
                              clases(ProcesaDatos.class)
+
                               
+
 
+
http://tomcat.apache.org/tomcat-7.0-doc/proxy-howto.html#Apache_2.0_Proxy_Support
+
 
+
===Fichero html===
+
<source lang=html4strict>
+
<!--Param.html Lectura de parámetros con formularios + servlets -->
+
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+
<HTML>
+
  <HEAD><TITLE>Param.html</TITLE></HEAD>
+
  <BODY BGCOLOR="#CCCCFF">
+
  <P></P>
+
  <H2>Introduce tus datos:</H2><BR>
+
  <%   
+
  java.util.Date today = new java.util.Date();   
+
  out.println("Today's date is: "+today);   
+
  %> 
+
    <HR></HR>
+
    <CENTER>
+
<FORM NAME="FORM1" METHOD="POST"
+
ACTION="http://localhost:8080/misServlets/ParamServlet">
+
  <TABLE BORDER>
+
<TR>
+
  <TD><B>Nombre:</TD>
+
  <TD><INPUT TYPE=TEXTBOX NAME="NOM" SIZE="25" VALUE=""></TD>
+
</TR>
+
<TR>
+
  <TD><B>Edad:</TD>
+
  <TD><INPUT TYPE=TEXTBOX NAME="EDA" SIZE="20" VALUE=""></TD>
+
</TR>
+
  </TABLE>
+
  <P></P>
+
  <INPUT TYPE=SUBMIT VALUE="Enviar">
+
  <HR></HR>
+
  Formulario HTML que invocará a un servlet
+
        </FORM>
+
      </CENTER>
+
  </BODY>
+
</HTML>
+
</source>
+
<!--
+
<!DOCTYPE HTML>
+
<html>
+
  <HEAD><TITLE>Mi primer despliegue web con servlet</TITLE></HEAD>
+
  <BODY BGCOLOR="#CCCCFF">
+
  <P></P>
+
  <H2>Inserta tus datos:</H2><BR>
+
    <HR></HR>
+
    <CENTER>
+
<FORM NAME="FORM1" METHOD="POST"
+
ACTION="http://localhost:8080/DatosUsuario/ProcesaDatos">
+
  <TABLE BORDER>
+
<TR>
+
  <TD><B>Nombre:</TD>
+
  <TD><INPUT TYPE=TEXTBOX NAME="NOM" SIZE="25" VALUE=""></TD>
+
</TR>
+
<TR>
+
  <TD><B>Edad:</TD>
+
  <TD><INPUT TYPE=TEXTBOX NAME="EDA" SIZE="20" VALUE=""></TD>
+
</TR>
+
  </TABLE>
+
  <P></P>
+
  <INPUT TYPE=SUBMIT VALUE="Enviar">
+
  <HR></HR>
+
  Formulario HTML que invocará a un servlet
+
        </FORM>
+
      </CENTER>
+
  </BODY>
+
</HTML>
+
-->
+
<source lang=html4strict>
+
<!DOCTYPE HTML>
+
<html>
+
  <head>
+
    <title>Mi primer despliegue web con servlet</title>
+
  </head>
+
  <body>
+
...
+
 
+
<form name="MisDatos" method="POST"
+
ACTION="http://localhost:8080/DatosUsuario/ProcesaDatos">
+
  <table border>
+
<tr>
+
  <td><B>Nombre:</td>
+
  <td><input type=TEXTBOX name="NOM" size="25" value=""></TD>
+
...
+
 
+
</html>
+
</source>
+
*Se ha hecho una tabla y se ha dado un color de fondo para darle más vistosidad
+
*Es importante entender el valor del atributo '''''ACTION'''''
+
 
+
====El servlet: ProcesaDatos.java====
+
<source lang=java>
+
import java.io.*;
+
import javax.servlet.*;
+
import javax.servlet.http.*;
+
 
+
public class ParamServlet extends HttpServlet {
+
 
+
private static final long serialVersionUID = 1L;
+
 
+
public void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
+
// Obtenemos un objeto Print Writer para enviar respuesta
+
res.setContentType("text/html");
+
PrintWriter pw = res.getWriter();
+
pw.println("<HTML><HEAD><TITLE>Leyendo parámetros</TITLE></HEAD>");
+
pw.println("<BODY BGCOLOR=\"#CCBBAA\">");
+
pw.println("<H2>Leyendo parámetros desde un formulario html</H2><P>");
+
pw.println("<UL>\n");
+
pw.println("Te llamas " + req.getParameter("NOM") + "<BR>");
+
pw.println("y tienes "  + req.getParameter("EDA") + " años<BR>");
+
pw.println("</BODY></HTML>");
+
pw.close();
+
}
+
}
+
</source>
+
 
+
===Referencias===
+
Página donde explica el proceso
+
http://elblogdepicodev.blogspot.com.es/2011/02/unir-apache-httpd-y-tomcat-mediante-un.html
+

Última revisión de 09:52 24 nov 2012