lunes, noviembre 29, 2010

Instalando JBOSS en Centos - Actualizado

Tomado de:
Instalar JBoss en CentosInstalar Jboss en Centos

Hace mucho tiempo que venía escuchando sobre Jboss, pero mi interés solo era de conocer, para que servía y que se podía hacer con el, pues bien, por motivos laborales tuve que retomar lecturas, definiciones sobre Jboss, no comentaré que es, y para que sirve, lo que leerán aquí es la instalación y algunos tips sobre la instalación, pues bien empecemos ... Para realizar la instalación, esta será usando centOS, también puede usarse en RHEL u OpenSuse.
Disco duro de 120Gb, 2Gb Ram, y CPU Core 2 Duo 2.4Ghz, deben contar con acceso al usuario root


1.- Comprobamos la versión de Java
 #java -version 


2.- Si tenemos algún mensaje en consola por ejm. "java version 1.4" está bien, pero sino, es igual, ya que usaremos la versión actual de Java para nuestra instalación.
Tip.- si desean borrar java, pueden ejecutar: yum remove java

3.- Nos dirigimos este enlace para descargar la última versión de java. Tip. Descargen JDK 6u21 o la que sea la más actual, y a su vez pueden escoger la plataforma que deseen, i386 o x86_64 y en el formaro "rpm.bin"

4.- Una vez descargado ejecutamos:
#chmod 755 jdk-6u21-linux-i386-rpm.bin

5.- Ahora ejecutamos:
#./jdk-6u21-linux-i386-rpm.bin 

6.- Ejecutamos lo siguiente para saber la versión de java:
#java -version

7.- Creamos la carpeta "java" en el directorio opt:
#mkdir -p /opt/java 

8.- Realizamos un enlace simbólico al directorio java:
#ln -s /usr/java/jdk1.6.0_21 /opt/java 

 9.- Crearemos un fichero ejecutable, en el indicaremos el "JAVA_HOME" que es muy importante para nuestra instalación, este "script" estará en la ruta /etc/profile.d:
#vim /etc/profile.d/java.sh
- - - -
#java 
JAVA_HOME=/opt/java/jdk 
PATH=$PATH:$JAVA_HOME/bin 
CLASSPATH=$JAVA_HOME/lib LD_LIBRARY_PATH=$JAVA_HOME/jre/lib/i386 
export JAVA_HOME PATH CLASSPATH LD_LIBRARY_PATH
- - - -



Tip. En LD_LIBRARY_PATH, deben de escoger si, por ejm. su server es X86_64, /lib/amd64
10.- Ahora damos permisos de ejecución al script y lo ejecutamos:
#chmod 755 /etc/profile.d/java.sh #sh /etc/profile.d/java.sh 

11.- Ahora que tenemos java configurado, procedemos a instalar Jboss.

12.- Procedemos a descargar Jboss de este enlace yo, he descargado la version 4.3, el método de instalación funciona para cualquiera de las versiones. 

13.- Descomprimimos Jboss:
#unzip jboss-4-0.3.GA-jdsk6.zip -d /usr/java 

14.- Creamos un enlace simbólico:
#ln -s /usr/java/jboss-4.0.3.GA /opt/java/jboss 

15.- Creamos el script "jboss.sh" en la ruta /etc/profile.d/ 
# vim /etc/profile.d/jboss.sh
- - -
# JBoss As
JBOSS_HOME=/opt/java/jboss 
PATH=$PATH:$JBOSS_HOME/bin 
export JBOSS_HOME PATH 
- - -
16.- Damos permisos de ejecución y ejecutamos el script:
#chmod 755 /etc/profile.d/jboss.sh #sh /etc/profile.d/jboss.sh 

17.- Agregamos el usuario "jboss"
#adduser jboss o useradd jboss 

18.- Cambiamos permisos en la carpeta "jboss":
#chown -Rf jboss.jboss /opt/java/jboss/

19.- Ingresamos con el user "jboss":
 #su jboss 

20.- Ahora ejecutaremos el "run.sh", script por default que inicia los servicios para Jboss: $/opt/java/jboss/bin/run.sh 

21.- Ahora, si queremos que escuche cualquier ip:
$/opt/java/jboss/bin/run.sh -b 0.0.0.0 (Tiene que digitar 0.0.0.0, con esto publica a toda la red)

 22.- Si revisamos el log, veremos un mensaje así:
18:23:18,035 INFO [ServerImpl] JBoss (Microcontainer) [5.1.0.GA (build: SVNTag=JBoss_5_1_0_GA date=200905221634)] Started in 1m:15s:48 

 23.- Para ingresar al panel de Jboss, desde nuesto browser: http://ip_server:8080 

Espero que les sea de utilidad, y para la próxima, escribiré como crear instancias, definir proyectos bajo instancias y más.



Si usas JBoss desde consola debes modificar el archivo run.bat o run.sh, encontrarás en el script una parte que dice:
"%JAVA%" %JAVA_OPTS% ^
   -Djava.endorsed.dirs="%JBOSS_ENDORSED_DIRS%" ^
   -classpath "%JBOSS_CLASSPATH%" ^
   org.jboss.Main %*
Debe modificarse a:
"%JAVA%" %JAVA_OPTS% ^
   -Djava.endorsed.dirs="%JBOSS_ENDORSED_DIRS%" ^
   -classpath "%JBOSS_CLASSPATH%" ^
   org.jboss.Main -b0.0.0.0 %*
(El 0.0.0.0 puede ser modificado si deseas colocar una IP específica)
Otra forma es iniciarlo desde la línea de comandos pasando el parámetro:
run -b 0.0.0.0
 
 
El objetivo de este manual es explicar breve y básicamente la estructura de este servidor de aplicaciones.
Hay que aclarar que esta descripción es igual para Linux que para Windows.
El Jboss escucha por defecto en el puerto 8080.
El servidor de aplicaciones Jboss es libre y puede descargarse de la pagina oficial de la comunidad
Una vez descargado y descomprimido o instalado, analizaremos los directorios mas importantes.
Bajo la carpeta principal JBOSSX.X.X, se crearan los siguientes directorios
  • BIN
  • CLIENT
  • LIB
  • LICENSES
  • SCRIPT
  • SERVER
Los que mas usaremos serán BIN y SERVER. En ellos se alojarán los archivos ejecutables y nuestras aplicaciones, respectivamente.
EL DIRECTORIO BIN
Aquí se encuentran los ejecutables y los ficheros de configuración de la aplicación.
Los más importantes son:
  • JBOSS_INIT_REDHAT y JBOSS_INIT_SUSE: son scripts muy básicos para convertir nuestro Jboss en un daemon (servicio). Estos ficheros son exclusivos de Linux y sirven (como su nombre indica) para distros RedHat o Suse respectivamente.
  • RUN.BAT: Es el ejecutable por excelencia. Sirve para levantar nuestro Jboss en Windows.
Este fichero se puede editar (como todos los punto BAT) para modificar la ubicación de nuestra maquina JAVA por ejemplo. Otra linea para modificar muy importante es la siguiente:
set JAVA_OPTS=%JAVA_OPTS% -Xms128m -Xmx512m -server -XX +UseConcMarkSweepGC -Dsun.rmi.dgc.client.gcInterval=3600000 -Dsun.rmi.dgc.server.gcInterval=3600000
En esta linea, podemos configurar cuanta memoria reservaremos para el servidor. -Xms indicara el valor mínimo. -Xmx, el máximo.
  • RUN.SH: es el ejecutable por excelencia, pero de los sistemas Linux. Sirve para levantar nuestro Jboss. A diferencia de Windows, en este archivo no se puede modificar la cantidad reservada de memoria para la aplicación. Este archivo apunta a otro para coger la configuración. Este archivo se llama RUN.CONF
  • RUN.CONF: este archivo contiene las opciones de las que leerá el RUN.SH para arrancar Jboss. Es exclusivo de Linux.
  • RUN.JAR: es el ejecutable para Java.
  • SHUTDOWN.BAT: Sirve para detener nuestro servidor Jboss en Windows.
  • SHUTDOWN.SH: Sirve para detener nuestro servidor Jboss en Linux.
Si no hay errores, al ejecutar RUN.BAT (Windows) o RUN.SH (Linux) podremos acceder al Jboss, poniendo en un navegador la dirección IP donde esta instalado el servidor con el puerto 8080.
Por ejemplo http://localhost:8080. Si todo es correcto aparecerá la siguiente pantalla:
jboss
EL DIRECTORIO SERVER
Para empezar nos encontraremos con 3 carpetas (MINIMAL, ALL, DEFAULT) cada carpeta cargara mas o menos servicios al ejecutar el Jboss. Cuanto mas servicios por defecto mas memoria consumirá nuestro servidor de aplicaciones.
La parte que explicaremos es la de DEFAULT, aunque también es valida para las otras 2 opciones.
Dentro de la carpeta DEFAULT, encontraremos los siguientes directorios:
  • CONF
  • DEPLOY: Este directorio es el mas importante, ya que ahí se alojara nuestra aplicación. Esta puede ser un archivo .WAR, .SAR, etc. El Jboss cargará todas las aplicaciones que copiemos aquí.
  • LIB: las librerías del Jboss.
  • LOG: aquí se encuentran dos archivos.
  1. BOOT.LOG: Es un archivo de texto plano, donde registra todas las incidencias producidas al inicio del Jboss.
  2. SERVER.LOG: Es un archivo de texto plano, donde registra todas las incidencias producidas por el servidor de aplicaciones, incluido los errores producidos por nuestra aplicación. Este fichero “rota” diariamente generando ficheros con el siguiente formato server.log.2009-x-x con los logs de días anteriores. Hay que controlar estos archivos, ya que suelen ser muy pesados y si no los borramos pueden saturar en pocos días nuestro disco duro.
  • TMP: archivos temporales.
  • WORK: mas archivos temporales.

 

Aumentar el tamaño de memoria de la máquina virtual en Java


En Java, hay varios parámetros para controlar el tamaño inicial y el tamaño máximo que puede tomar la máquina virtual.
Además, hay que tener en cuenta el tipo de memoria sobre el que se quiere actuar: heap, non-heap (PermGen). Los valores por defecto que se dan corresponden a máquina virtuales de Sun, y son orientativos, porque pueden cambiar entre versiones de la máquina virtual. Los parámetros son los siguientes, fijándose a 128Mb.
* -Xms128m: Tamaño de inicio de la máquina virtual de Java a 128Mb. El valor por defecto son 64Mb. Si se aumenta este valor, se elimina el tiempo que se tardaría en aumentar el tamaño en memoria de la máquina virtual si se llegara el caso de que se necesitara más memoria, por lo que aumentaría el rendimiento en los casos que la aplicación haga uso intensivo de la memoria.
* -Xmx128m: Tamaño máximo de la máquina virtual de Java a 128Mb. El valor por defecto son 128Mb. Si la aplicación supera el tamaño máximo de memoria que marca este parámetro, se lanza la excepción java.lang.OutOfMemoryError. No conviene asignar a este parámetro el máximo de la memoria de la máquina porque si ya no queda memoria física disponible (por la que usa el sistema operativo u otras aplicaciones) se pueden producir escrituras en memoria asignada a otros programas y provocar un auténtico lío.
* -XX:PermSize=128m: Tamaño de inicio de la memoria de tipo PermGen a 128Mb. Arrancar la máquina virtual con un valor superior al por defecto agiliza la carga de aplicaciones, sobre todo en el caso de aplicaciones que hagan uso intensivo de este tipo de memoria (Spring, Hibernate…)
* -XX:MaxPermSize=128m: Tamaño máximo de la memoria de tipo PermGen a 128Mb. El valor por defecto son 64Mb. Si la aplicación supera el tamaño máximo de memoria para este tipo que marca este parámetro, se lanza la excepción java.lang.OutOfMemoryError: PermGen space. El valor necesario para este parámetro siempre suele ser menor que el de la memoria de tipo heap.
Si se quiere especificar un valor distinto de 128Mb, que se utiliza para todos los parámetros como ejemplo para simplificar, bastaría con sustituir el valor 128 del parámetro con el que se desee, siempre que sean múltiplos de 2 (64, 128, 256, 512, 768, 1024, 2048…)
Conocidos los tipos de memoria y los parámetros que los controlan, ahora viene la pregunta, ¿cómo especifico estos valores para mi aplicación? La respuesta es la misma para todos los casos: Los valores se especifican como parámetros en el arranque de la máquina virtual que ejecutará la aplicación. La diferencia estribará en cómo se arranca la aplicación: con un script, desde línea de comandos, mediante ant…
A continuación se dan distintos ejemplos de modificación de la memoria de distinta forma. No es necesario especificar todos los parámetros, se pueden especificar todos o ninguno (y se tomarían los valores por defecto)
Línea de comandos
* Ejecución de un jar: java -Xms128m -Xmx1024m -XX:PermSize=128m -XX:MaxPermSize=256m -jar example.jar
* Ejecución de una clase: java -Xms128m -Xmx1024m -XX:PermSize=128m -XX:MaxPermSize=256m com.programacionenjava.examples.MemoryExample
Ant
Script
Si el arranque de la máquina virtual se produce en un script, hay que editar el script y añadir estos parámetros en la sentencia de arranque. El siguiente ejemplo muestra cómo añadir estos parámetros en el script de arranque de un Tomcat.
* En Windows: set JAVA_OPTS=%JAVA_OPTS% -Xms128m -Xmx512m -XX:PermSize=128m -XX:MaxPermSize=256m
* En Linux: JAVA_OPTS=”$JAVA_OPTS -Xms128m -Xmx512m -XX:PermSize=128m -XX:MaxPermSize=256m”
Por último, recordamos que resolver el problema de una excepción de tipo java.lang.OutOfMemoryError simplemente aumentando el tamaño de la memoria virtual puede retrasar el problema pero no evitarlo si el problema es una fuga de memoria. Puedes encontrar más información aquí.
Tomado de


Script para subir, bajar y Reiniciar un JBoss

 

Tomado de: Script JBOSS
Vamos a crear un script completo que permite subir, bajar y reiniciar un JBoss sobre Kubuntu 10.10.

Las opciones de branches, trunk es para subir (si esta arriba lo baja y publica un aplicativo) desde la copia de trabajo del subversion.

Creamos el archivo que contendrá el script: sudo vi /etc/init.d/jboss

Copia este contenido:


#! /bin/sh

#

# $Id: jboss_init_redhat.sh 71252 2008-03-25 17:52:00Z dbhole $

#

# JBoss Control Script

#

# To use this script run it as root - it will switch to the specified user

#

# Here is a little (and extremely primitive) startup/shutdown script

# for RedHat systems. It assumes that JBoss lives in /usr/local/jboss,

# it's run by user 'jboss' and JDK binaries are in /usr/local/jdk/bin.

# All this can be changed in the script itself. 

#

# Either modify this script for your requirements or just ensure that

# the following variables are set correctly before calling the script.



# Init script modified for Ubuntu Server 8.04 by

# Chiral Software, Inc.



#define where jboss is - this is the directory containing directories log, bin, conf etc

JBOSS_HOME=${JBOSS_HOME:-"/RUTA/JBOSS/jboss-5.1.0.GA"}



#define the user under which jboss will run, or use 'RUNASIS' to run as the current user

#JBOSS_USER=${JBOSS_USER:-"jboss"}

JBOSS_USER=${JBOSS_USER:-"RUNASIS"}



#make sure java is in your path

#this must be set even if java is in a well-known place like /usr/bin

#JAVAPTH=${JAVAPTH:-"/RUTA/java/jdk1.6.0_22"}



#configuration to use, usually one of 'minimal', 'default', 'all'

JBOSS_CONF=${JBOSS_CONF:-"default"}



#if JBOSS_HOST specified, use -b to bind jboss services to that address

# JBOSS_BIND_ADDR=${JBOSS_HOST:+"-b $JBOSS_HOST"}

#JBOSS_BIND_ADDR=${JBOSS_HOST:-"-b IP_DEL_EQUIPO"}



#define the script to use to start jboss

JBOSSSH=${JBOSSSH:-"$JBOSS_HOME/bin/run.sh -c $JBOSS_CONF $JBOSS_BIND_ADDR"}



#define la ruta de la ubicación del branches donde esta el codigo fuente

BRANCHES=${BRANCHES:-"/RUTA/2_Fuentes/branches/VERSION"}



#define la ruta de la ubicación del trunk donde esta el codigo fuente

TRUNK=${TRUNK:-"/RUTA/2_Fuentes/trunk"}



if [ "$JBOSS_USER" = "RUNASIS" ]; then

  SUBIT=""
else

  SUBIT="su - $JBOSS_USER -c "
fi



if [ -n "$JBOSS_CONSOLE" -a ! -d "$JBOSS_CONSOLE" ]; then

  # ensure the file exists   touch $JBOSS_CONSOLE   if [ ! -z "$SUBIT" ]; then     chown $JBOSS_USER $JBOSS_CONSOLE   fi 
fi



if [ -n "$JBOSS_CONSOLE" -a ! -f "$JBOSS_CONSOLE" ]; then

  echo "WARNING: location for saving console log invalid: $JBOSS_CONSOLE"   echo "WARNING: ignoring it and using /dev/null"   JBOSS_CONSOLE="/dev/null"
fi



#define what will be done with the console log

JBOSS_CONSOLE=${JBOSS_CONSOLE:-"$JBOSS_HOME/server/$JBOSS_CONF/log/console.log"}



JBOSS_CMD_START="cd $JBOSS_HOME/bin; $JBOSSSH"



#if [ -z "`echo $PATH | grep $JAVAPTH`" ]; then

#  export PATH=$PATH:$JAVAPTH

#fi



if [ ! -d "$JBOSS_HOME" ]; then

  echo JBOSS_HOME does not exist as a valid directory : $JBOSS_HOME   exit 1
fi



procrunning () {

   procid=0    for procid in `pidof -x $JBOSS_HOME/bin/run.sh`; do        ps -fp $procid | grep "${JBOSSSH% *}" > /dev/null && pid=$procid    done
}



stop () {

    pid=0     procrunning     if [ $pid = '0' ]; then         /bin/echo -n -e "\nNo JBossas is currently running\n"         exit 1     fi

    RETVAL=1

    # If process is still running

    # First, try to kill it nicely     for id in `ps --ppid $pid | awk '{print $1}' | grep -v "^PID$"`; do        if [ -z "$SUBIT" ]; then            kill -15 $id        else            $SUBIT "kill -15 $id"        fi     done

    sleep=0     while [ $sleep -lt 120 -a $RETVAL -eq 1 ]; do         /bin/echo -n -e "\nwaiting for JBoss processes to stop\n";         sleep 10         sleep=`expr $sleep + 10`         pid=0         procrunning         if [ $pid = '0' ]; then             RETVAL=0         fi     done

    count=0     pid=0     procrunning

    if [ $RETVAL != 0 ] ; then         /bin/echo -e "\nTimeout: Shutdown command was sent, but process is still running with PID $pid\n"         exit 1     fi

    echo     exit 0
}



case "$1" in

start)

    echo "Iniciando el JBoss"     eval touch $JBOSS_HOME/server/$JBOSS_CONF/log/server.log     cd $JBOSS_HOME/bin     if [ -z "$SUBIT" ]; then
#        eval $JBOSS_CMD_START >${JBOSS_CONSOLE} 2>&1 &

        eval $JBOSS_CMD_START 2>&1 &     else
#        $SUBIT "$JBOSS_CMD_START >${JBOSS_CONSOLE} 2>&1 &" 

        $SUBIT "$JBOSS_CMD_START 2>&1 &"      fi     eval tail -f $JBOSS_HOME/server/$JBOSS_CONF/log/server.log     ;;
stop)

    stop     ;;
restart)

    $0 stop     $0 start     ;;
trunk)

    $0 stop     echo "Eliminando archivos existentes"     rm $JBOSS_HOME/server/$JBOSS_CONF/deploy/empaquetado.jar     rm $JBOSS_HOME/server/$JBOSS_CONF/deploy/empaquetado.war     rm $JBOSS_HOME/server/$JBOSS_CONF/lib/librerias_propias*.jar

    echo "Publicando nuevos archivos"     cp $TRUNK/RUTA/target/empaquetado.jar               $JBOSS_HOME/server/$JBOSS_CONF/deploy/empaquetado.jar     cp $TRUNK/RUTA/target/empaquetado.war   $JBOSS_HOME/server/$JBOSS_CONF/deploy/empaquetado.war 

    $0 start     ;;
branches)

    $0 stop     echo "Eliminando archivos existentes"


    rm $JBOSS_HOME/server/$JBOSS_CONF/deploy/empaquetado.jar
    rm $JBOSS_HOME/server/$JBOSS_CONF/deploy/empaquetado.war
    rm $JBOSS_HOME/server/$JBOSS_CONF/lib/librerias_propias*.jar


    echo "Publicando nuevos archivos"

    cp $BRANCHES/RUTA/target/empaquetado.jar               $JBOSS_HOME/server/$JBOSS_CONF/deploy/empaquetado.jar
    cp $BRANCHES/RUTA/target/empaquetado.war      $JBOSS_HOME/server/$JBOSS_CONF/deploy/empaquetado.war 

    $0 start
    ;;
*)
    echo "usage: $0 (start|stop|restart|branches|trunk|help)"
esac


Terminando de pegar el contenido del script, lo guarda dando ESC :wq

Ya tenemos el script, ahora es solo darle permisos de ejecución: sudo chmod 755 jboss

Y listo, ya lo podemos ejecutar: service jboss aplicacion

Con esto debería subir el JBoss realizando la publicación de nuestro aplicativo que esta en el aplicacion del repositorio.

Tomado de: Jboss basico

JBoss básico funcionando en pocos pasos


1. Instalación
2. Arrancar y parar el servidor
3. Desplegar una aplicación
4. Configurar una Base de Datos
5. Múltiples instancias del servidor
6. Conectividad Apache - JBoss (mod_jk2)
7. Seguridad extra



Para el caso nos vamos a centrar en la versión 4.0.5GA que era la última versión estable a la hora de hacer la instalación. La máquina virtual es de Sun - JDK 1.6.0-b105. El sistema utilizado es un Debian Etch.


1. Instalación
Para la instalación he usado la guia oficial de JBoss.
Nos bajamos el servidor del site de JBoss, descomprimimos, ejecutamos

$ java -jar jems-installer-1.2.0.jar

y seguimos las instrucciones - idioma de la instalación, licencia, directorio de la instalación (apartir de ahora JBOSS_HOME) y los componentes. Aquí­ hay que tener cuidado - si vamos a usar EJB3, con clustering o no, tenemos que instalar Java5 porque EJB3 no es compatible con 1.4. Luego viene el nombre de la instancia (default en un principio nos sirve), configuración de la base de datos (seleccionad la vuestra), datasource por defecto y el usuario administrador. Aquí ponemos una contraseña y nos queda esperar hasta que el instalador termine su trabajo. Sencillo.
El instalador en linea de comandos no es mucho mas complicado.

Hemos terminado la instalación.




2. Arrancar y parar el servidor
En linea de comandos y como root creamos un usuario que va a ser el encargado de administrar el servidor :

$adduser jboss

El arranque del servidor lo hacemos en consola :

$JBOSS_HOME/bin/run.sh

Pararlo, igual :

$JBOSS_HOME/bin/shutdown.sh

Esto inicia y para el servidor, pero no nos va a servir. Para hacer las cosas bién tenemos que arrancar el servidor con nuestro usuario jboss :

su jboss -p -s /bin/sh -c "sh JBOSS_HOME/bin/run.sh"

Para pararlo - lo mismo pero con shutdown.
Como shell del usuario he puesto /bin/sh. Vosotros poned el vuestro favorito.
Ahora está bién. Pero, claro, la consola donde hemos tecleado esto está ocupada e inservible, y, además, cada vez que arrancamos nuestro sistema temenos que iniciar el servidor a mano ... incomodo.
Nos preparamos un script de inicio, lo colocamos en /etc/init.d y hacemos los links necesarios. Así la próxima vez que iniciemos nuestro sistema se iniciará el servidor.
Para cosas sencillas yo utilizo nano, vosotros - vuestro preferido.

$nano /etc/init.d/jboss

#!/bin/sh
# /etc/init.d/jboss: Start and stop JBoss AS

TEST=/usr/bin/test

JBOSS_HOME=${JBOSS_HOME:-"/donde/este/vuestro/jboss/jboss-4.0.5.GA"}
JBOSS_HOST=${JBOSS_HOST:-"0.0.0.0"}
JAVAPTH=${JAVAPTH:-"/opt/jdk1.6.0/bin"}

JBOSS_START_SCRIPT=$JBOSS_HOME/bin/run.sh
JBOSS_STOP_SCRIPT=$JBOSS_HOME/bin/shutdown.sh

OPT="-b $JBOSS_HOST"

JBOSS_USER=jboss

if [ `id -u` -ne 0 ]; then
   echo "Not starting/stopping JBoss, you are not root."
   exit 4
fi

$TEST -x $JBOSS_START_SCRIPT || exit 0
$TEST -x $JBOSS_STOP_SCRIPT || exit 0

start() {
   echo -e "Starting JBoss ...\n"
   export PATH=$PATH:$JAVAPTH

   chown -R $JBOSS_USER $JBOSS_HOME
   cd $JBOSS_HOME/bin

   su $JBOSS_USER -p -s /bin/sh -c "sh $JBOSS_START_SCRIPT $OPT 2> /dev/null &"
}

stop() {
   echo -e "Stopping JBoss ...\n"
   su $JBOSS_USER -p -s /bin/sh -c "sh $JBOSS_STOP_SCRIPT -S &"
   wait
}

case "$1" in
   start)
      start
      ;;
   stop)
      stop
      sleep 20
      ;;
   restart)
      stop
      sleep 20
      start
      ;;
   *)
   echo -e "\nUsage: jboss {start|stop|restart}\n"
   exit 1
esac

exit 0


El parámetro -b indica la dirección IP donde escucha nuestro servidor. Ahora le hemos indicado que acepte todas las direcciones. En capítulo 5. Múltiples instancias del servidor este parámetro cobra mas sentido.

La tercera linea de la función start() la podeis eliminar. Eso sí, el comando hay que ejecutarlo en consola y como root por lo menos una vez después de la instalación. Si no lo haceis vais a recibir un mensaje muy bonito de tipo :

ERROR [MainDeployer] Could not make local copy for file:/JBOSS_HOME/server/default/conf/jboss-service.xml java.io.FileNotFoundException: /JBOSS_HOME/server/default/tmp/deploy/server/default/conf/jboss-service.xml/1.jboss-service.xml (Permission denied)

Ya tenemos el script. Lo linkamos en /etc/rc5 como :

$ln -s S55jboss /etc/init.d/jboss

y en rc.0 :

$ln -s K15jboss /etc/ini.d/jboss

Lo mismo en los demás runlevels pero siempre teniendo cuidado - el jboss tiene que iniciarse antes que el apache y pararse antes que vuestra base de datos.

Parece que hemos completado el arranque.




3. Desplegar una aplicación
Después de preparar una aplicación y empaquetarla (como hacer esto no es nuestro objetivo por ahora), lo único que tenemos que hacer para desplegarla es copiarla en el directorio JBOSS_HOME/server/default/deploy del sitio de la compilación.

Para hacer el undeploy - borrarla del dicho directorio. Si no quereis borrar, preparad un directorio, por ejemplo undeploy, y simplemente copiad el fichero de la aplicación de .../deploy a .../undeploy.

Estas operaciones hay que hacerlas como root - acordaos que JBOSS_HOME es del usuario jboss. Si lo intentamos como un usuario normal no vamos a tener permisos.
Otra opción sería hacer un link (sí, como root) hacia el directorio donde teneis los proyectos.

Ya sabemos como desplegar aplicaciones.




4. Configurar una Base de Datos

Por defecto la Base de Datos que viene configurada con JBoss es HSQLDB (Hypersonic), así que ya la tenemos. Ahora nos falta la que queremos usar con nuestras aplicaciones. Nos centramos en MySQL. Es la que mas facil instalamos en nuestro sistema y la que uso habitualmente. Bueno, he probado también Oracle y SQL Server (esta última casi mejor no mencionarla) pero como son gestores de BD propietarios, los vamos a dejar por ahora.

Vamos allá.

Primero nos hacemos con el driver de la Base de Datos mysql-connector-java-3.0.9-stable-bin.jar y lo copiamos en JBOSS_HOME/server/default/lib.
También copiamos /docs/examples/jca/mysql-ds.xml a JBOSS_HOME/server/default/deploy y lo modificamos - en la etiqueta <driver-class/> ponemos com.mysql.jdbc.Driver y en <connection-url/> colocamos jdbc:mysql://<host_mysql>/<nombre_base_datos>.

Abrimos standardjaws.xml o jaws.xml y modificamos <datasource> and <type-mapping> como sigue :
<jaws>
   <datasource>java:/MySqlDS</datasource>
   <type-mapping>mySQL</type-mapping>
</jaws>

También tenemos que arreglar <datasource> y <type-mapping> en standardjbosscmp-jdbc.xml (o jbosscmp-jdbc.xml) :
<jbosscmp-jdbc>
   <defaults>
      <datasource>java:/MySqlDS</datasource>
      <datasource-mapping>mySQL</datasource-mapping>
   </defaults>
</jbosscmp-jdbc>

Ya queda poco. Modificamos login-config.xml añadiendo el tag <application-policy/> con la configuración de nuestra Base de Datos :
<application-policy name = "MySqlDbRealm">
   <authentication>
      <login-module code = "org.jboss.resource.security.ConfiguredIdentityLoginModule" flag = "required">
         <module-option name ="principal">NOMBRE_BASE_DATOS</module-option>
         <module-option name ="userName">USUARIO_BASE_DATOS</module-option>
         <module-option name ="password">PASSWORD_BASE_DATOS</module-option>
         <module-option name ="managedConnectionFactoryName">
            jboss.jca:service=LocalTxCM,name=MySqlDS
         </module-option>
      </login-module>
   </authentication>
</application-policy>

Listo.




5. Múltiples instancias del servidor

Pocas razones, excepto pruebas, se me ocurren para querer iniciar mas de una instancia del servidor.
Una, con algo de sentido, sería que montando un hosting, uno de los clientes exije una máquina virtual que no es la que ya teneis instalada.
Podría darse el caso que quereis ejecutar EJB3 pero las aplicaciones que ya teneis hechas corren mejor en JVM 1.4 (por ejemplo) o simplemente no os la quereis jugar a la ruleta rusa mudando una aplicación a otra máquina virtual. Entonces os haceis con dos instancias - una con JVM 1.4 para las aplicaciones "antiguas" y otra con 1.5 (os acordais ¿verdad?) para los EJB3.

Creando otra instancia.

Lo primero es crear dos configuraciones para las instancias. Así que copiamos nuestra configuración por defecto a, por ejemplo, instancia2 :

$cp JBOSS_HOME/server/default/* JBOSS_HOME/server/instancia2/

Si iniciamos la segunda instancia recibiremos un conflicto en puertos de escucha, así que vamos cambiando. Añadiremos un "1" delante en todos los puertos del servidor.
Los ficheros y puertos a retocar en JBOSS_HOME/server/instancia2 son los siguientes :
deploy/jbossweb-tomcat55.sar/server.xml
8080 -> 18080
conf/jboss-service.xml
1099 -> 11099
1098 -> 11098
4445 -> 14445
4444 -> 14444
8083 -> 18083
conf/jboss-minimal.xml
1099 -> 11099
1098 -> 11098
deploy/jms/uil2-service.xml
8093 -> 18093
Nos queda iniciar las instancias. Usamos opción -c : $JBOSS_HOME/bin/run.sh -c instancia2 -b 192.168.1.18 (o -b instancia2.jboss_cluster.erFlako.net) Cambiando nombre y dirección de cada instancia. De la misma forma (con shutdown.sh) las paramos. Para evitar problemas es buena práctica añadir algún retardo en el arranque / parada de las instancias - unos 20 segundos es suficiente. Esto nos evitará conflictos en el servicio HA-JMS y ... en fin - a poner el retardo. Otra cosa hecha. 
6. Conectividad Apache - JBoss (mod_jk2)

JBoss 4.0.5 trae Tomcat 5.5, así que la configuración no es muy diferente de un Tomcat cualquiera.
Las pequeñas diferencias las comentaremos aparte.

Suponiendo que ya tenemos Apache 2 y mod_jk1.2.x vamos directos a la configuración.
Los comentarios entre paréntesis se refieren a las peculiaridades de Debian.

6.1 Apache
Añadimos al final de APACHE_HOME/conf/apache2.conf (en Debian /etc/apache2.conf) :
Include conf/mod-jk.conf
Para los usuarios de Debian - simplemente linkar mod-jk.conf de sites-available a sites-enabled.

6.2. mod-jk
Creamos APACHE_HOME/conf/mod-jk.conf (Debian /etc/apache2/mods-available) :
# Cargar el modulo mod_jk
# Nombre de la librería mod_jk
LoadModule jk_module modules/mod_jk.so

# Sitio de workers.properties
JkWorkersFile conf/workers.properties

# Sitio de los logs de jk
JkLogFile logs/mod_jk.log

# Nivel de log [debug/error/info]
JkLogLevel info

# Formato de log
JkLogStampFormat "[%a %b %d %H:%M:%S %Y]"

# JkOptions
JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories

# JkRequestLogFormat
JkRequestLogFormat "%w %V %T"

# Sitio de donde montar las aplicaciones
JkMount /aplicaciones_java/* loadbalancer

# Para indicar puntos de montaje se puede usar un fichero externo.
# Se actualiza cada 60 segundos.
# El formato es: /url=worker
# /ejemplos/*=loadbalancer
JkMountFile conf/uriworkermap.properties
# en mi caso (Debian) : # JkMountFile uriworkermap.properties

# Se puede añadir memoria compartida.
# A partir de versión 1.2.10 y posteriores de mod_jk.
# Necesario para el correcto funcionamiento del balanceo de carga.
JkShmFile logs/jk.shm

# Añadir jkstatus para manejar datos en tiempo de ejecución
<Location /jkstatus/>
   JkMount status
   Order deny,allow
   Deny from all
   Allow from 127.0.0.1
</Location>

6.3 workers.properties
En APACHE_HOME/conf/worker.properties o donde hemos indicado en jk.conf (yo lo tengo en /etc/apache2).
# Directivas validas para mod_jk 1.2.18 y posteriores

# Definimos la lista de workers a usar

worker.list=loadbalancer,status

# Definimos Nodo1
# Modificar el host con vuestra IP o nombre DNS
worker.node1.port=8009
worker.node1.host=test.er-flako.dyndns.org
worker.node1.type=ajp13
worker.node1.lbfactor=1
# worker.node1.connection_pool_size=10 (1)

# Definimos Nodo2
worker.node2.port=8009
worker.node2.host=pruebas.er-flako.dyndns.org
worker.node2.type=ajp13
worker.node2.lbfactor=1
# worker.node2.connection_pool_size=10 (1)

# Comportamiento del loadbalancer
worker.loadbalancer.type=lb
worker.loadbalancer.balance_workers=node1,node2

# Un worker de estado para manejar el balanceo de carga
worker.status.type=status
En caso de duda con las directivas y la versión de mod-jk. consultar la completa lista de directivas.

Las dos lineas de connection_pool_size están comentadas porque connection_pool_size se indica solamente si el número de conexiones al servidor http es mayor que el maxThreads de server.xml.

Si indicamos worker.loadbalancer.sticky_session=Off, las peticiones serán balanceadas entre nodo1 y nodo2 con todo lo que esto conlleva - si un usuraio abre sesión en un servidor y el loadbalancer le envia al otro, el usuario perderá la sesión http. Así que si vais a usar balanceo de carga no podeis usar el objeto session para transportar datos entre la capa de negocio y la capa web. O sincronizar los datos entre las sesiones.
Es buena idea enviar un cliente siempre al mismo servidor.
Por defecto sticky_session está habilitado.

6.4 uriworkermap.properties
En APACHE_HOME/conf o directamente en /etc/apache2 :
# Ejemplo de configuración de workers

# Montamos el Servlet context con el ajp13 worker
/jmx-console=loadbalancer
/jmx-console/*=loadbalancer
/web-console=loadbalancer
/web-console/*=loadbalancer

# corresponde a node1 de worker.properties
/test=loadbalancer
/test/*=loadbalancer

# y node2
/pruebas=loadbalancer
/pruebas/*=loadbalancer
Tenemos nuestras consolas y los nodos que hemos definido redirigidas hacia el Tomcat.

6.5 Tomcat
En JBOSS_HOME/server/NOMBRE_DE_INSTANCIA/deploy/jbossweb-tomcat55.sar/server.xml (cambiamos NOMBRE_DE_INSTANCIA con el nombre de la instancia para cada caso) encontramos la etiqueta Engine y añadimos jvmRoute :
<Engine name="jboss.web" defaultHost="localhost" jvmRoute="test">
   ...
</Engine>
jvmRoute tiene que coincidir con el nombre especificado en worker.properties.

Aseguraos de que las lineas correspondientes al conector AJP 1.3 están descomentadas :
<!-- A AJP 1.3 Connector on port 8009 -->
   <Connector port="8009" address="${jboss.bind.address}"
         emptySessionPath="true" enableLookups="false" redirectPort="8443"
         protocol="AJP/1.3"/>
Si no quereis que Tomcat esté disponible através del puerto 8080, simplemente comentad las lineas correspondientes a la conexión tradicional.

Y por último decirle a Tomcat que añada el valor de jvmRoute a las cookies de sesión para que mod_jk pueda enrutar peticiones entrantes.
Editamos JBOSS_HOME/server/NOMBRE_DE_INSTANCIA/deploy/jbossweb-tomcat55.sar/META-INF/jboss-service.xml. Buscamos el atributo UseJK y lo ponemos a true :
<attribute name="UseJK">true</attribute>
Si al acceder a http://localhost/web-console veis la consola de JBoss, el trabajo está bien hecho.

Que lo disfruteis.




7. Seguridad extra

Esta parte del "tutorial" tiene algo que ver con la anterior - Conectividad Apache - JBoss (mod_jk2).
Por defecto JBoss inicia muchos servicios y cada servicio escucha un puerto.

1099        TCP     org.jboss.naming.NamingService
1098        TCP     org.jboss.naming.NamingService
1162        UDP     org.jboss.jmx.adaptor.snmp.trapd.TrapdService
4444        TCP     org.jboss.invocation.jrmp.server.JRMPInvoker
4445        TCP     org.jboss.invocation.pooled.server.PooledInvoker
8009        TCP     org.jboss.web.tomcat.tc4.EmbeddedTomcatService
8009        TCP     org.jboss.web.tomcat.tc4.EmbeddedTomcatService
8083        TCP     org.jboss.web.WebService
8090        TCP     org.jboss.web.OILServerILService
8092        TCP     org.jboss.mq.il.oil2.OIL2ServerILService
8093        TCP     org.jboss.mq.il.uil2.UILServerILService
anónimo  TCP     org.jboss.mq.il.rmi.RMIServerILService
anónimo  UDP     org.jboss.jmx.adaptor.snmp.agent.SnmpAgentService

Para impedir el acceso a estos servicios desde fuera de vuestra red local (o VPN) actualizamos la configuración de JBoss para que escuche solamente las direcciones locales y así prohibir el acceso a todos los puertos excepto 80.
En el script de inicio (2. Arrancar y parar el servidor) cambiamos JBOSS_HOST a 127.0.0.1. Ahora JBoss escucha solamente localhost.

Para acceder al servidor podemos crear un tunel através de ssh :
$ssh -L 8081:localhost:8080 vuestra_IP.
Ahora http://localhost:8081 nos lleva al puerto 8080 de nuestro JBoss.

Lo mismo si hemos configurado mod_jk y Apache - accedemos al puerto 80 y mod_jk nos lleva al 8080 de JBoss.

También se puede hacer un redireccionamiento usando iptables, pero esto impedirá tener un apache en el puerto 80.

De todas formas, usemos el método que usemos, hay que cerrar todos los puertos que no se utilizan en nuestro router y dejar abiertos solamente los necesarios para el funcionamiento de JBoss.




No hay comentarios: