SafeChildren Banner

Havoc Oracle Solaris Experts

viernes, 23 de abril de 2010

Cómo añadir una ruta estática persistente en Solaris 10

Introducción
Para añadir rutas estáticas a nuestro tabla de enrutado, deberemos utilizar el comando <route> con las opciones <{add | delete}> -según lo que queramos hacer-, sin embargo, éstas rutas desaparecían cuando hacíamos un reboot de la máquina.

Para solucionar esto tenemos dos posibilidades: Tener Instalado el path 118833-36 o crearnos un script de inicio. Si tenemos el patch el comando <route> acepta una nueva opción <-p> que hace la ruta permanente y no debemos preocuparnos por más, para comprobar si tenemos instalado el patch utilizaremos <showrev> con la opción <-p>

# showrev -p|grep "Patch: 118833-36"
Patch: 118833-36 Obsoletes: 118822-30, 118348-01 ...
.....
Podemos añadir la ruta de forma permanente
# route -p add -net 192.168.20.0 172.26.17.2
Y comprobar su estado utilizando <netstat -rn>

# netstat -rn

Routing Table: IPv4
  Destination           Gateway           Flags  Ref     Use     Interface
-------------------- -------------------- ----- ----- ---------- ---------
127.0.0.1            127.0.0.1            UH        2          0 lo0
172.26.0.0           172.26.17.1          U         3         17 e1000g0
192.168.20.0         172.26.17.2          UG        2         17

Routing Table: IPv6
  Destination/Mask            Gateway                   Flags Ref   Use    If
--------------------------- --------------------------- ----- --- ------- -----
::1                         ::1                         UH      2       0 lo0
Si no tenemos el patch instalado, deberemos crear un script de inicio en /etc/init.d/rc3.d donde incluyamos nuestras rutas, por ejemplo,
# echo "route add -net 192.168.20.0 172.26.17.1" >> /etc/init.d/rc3.d/S99myroutes
# chmod 555 /etc/init.d/rc3.d/S99myroutes
Referencias

miércoles, 21 de abril de 2010

Cómo ver la tabla de enrutado en Solaris 10

Introducción
Para poder ver la tabla de rutas activa utilizaremos el comando <netstat> con la opción <-r>

root@http:~# netstat -r

Routing Table: IPv4
  Destination           Gateway           Flags  Ref     Use     Interface
-------------------- -------------------- ----- ----- ---------- ---------
localhost            localhost            UH        2          0 lo0
172.26.0.0           http                 U         3         39 e1000g0
192.168.20.0         172.26.17.2          UG        2         39

Routing Table: IPv6
  Destination/Mask            Gateway                   Flags Ref   Use    If
--------------------------- --------------------------- ----- --- ------- -----
localhost                   localhost                   UH      2       0 lo0

Sin embargo, si queremos que no nos resuelva las IPs y nos muestre los valores -no los DNS-, añadiremos la opción <-n>, así
root@http:~# netstat -rn

Routing Table: IPv4
  Destination           Gateway           Flags  Ref     Use     Interface
-------------------- -------------------- ----- ----- ---------- ---------
127.0.0.1            127.0.0.1            UH        2          0 lo0
172.26.0.0           172.26.17.1          U         3         41 e1000g0
192.168.20.0         172.26.17.2          UG        2         41

Routing Table: IPv6
  Destination/Mask            Gateway                   Flags Ref   Use    If
--------------------------- --------------------------- ----- --- ------- -----
::1                         ::1                         UH      2       0 lo0



Referencias

lunes, 19 de abril de 2010

Instalación de Apache HTTPD con Tomcat6 y Mod_JK

Introducción
En esta serie de artículos, vamos a ver las diferentes formas que hay para definir una estructura de Apache Tomcat para su puesta en producción. Veremos cómo podemos configurar Apache Tomcat con Apache HTTP mediante <mod_jk> y cómo poner <squid-cache> como frontend haciendo de proxy reverso.

Como es una serie y no un unico post iremos viendo cómo montar la infraestructura, desde lo más básico, hasta -en las últimas entregas- cómo ponerlo en producción.

Instalación de Apache HTTPD como frontend de Tomcat6 con Mod_JK
En esta ocasión vamos a ver cómo podemos utilizar Apache HTTP 2.2.x como frontend de nuestro Tomcat6. Para ello disponemos de varias soluciones, entre ellas:
  • Utilizar mod_proxy
  • Utilizar mod_jk 
Antes de comenzar, vamos a ver cuáles son las diferencias principales entre ambos métodos, y posteriormente explicaremos cómo son los pasos de instalación en ambos casos.
  • Técnica de Mod_Proxy:  Cuando utilizamos este método, todas las peticiones que entren en nuestro Apache HTTPD serán enviadas al Tomcat, es decir, tanto contenido estático como dinámico.
  • Técnica de Mod_JK: Cuando utilizamos este método, podemos discriminar qué queremos en Tomcat y que no queremos, es decir, podemos utilizar <*.jsp> para que sea tomcat quien lo procese, y el resto sea httpd quien lo gestion -contenido dinámico a tomcat, estático a httpd- Además, podemos gestionar cargas y failovers de nuestros balanceadores.
Una vez explicadas las diferencias, nos vamos a centrar en el uso de mod_jk ya que creo es una solución más robusta y nos permite más optimizaciones

Configuración Apache 2.2.x HTTPD en 64bits
Lo primero que vamos hace es decargar y compilar -yo voy a utilizar SunCC- el servidor http de Apache desde su web, si quieres puedes optar por Compilar Apache 1.3.x en 64bits sobre Solaris 10
$  wget http://www.eu.apache.org/dist/httpd/httpd-2.2.15.tar.gz
$ export CFLAGS="-m64 -O3"
$ export CC=cc
$ export LDFLGAS="-64"
$ ./configure 
   --prefix=/opt/www/apache2/64 \
   --enable-so \
   --enable-rewrite  \
   --enable-vhost-alias  \
   --enable-unique-id  \
   --enable-head  \
   --with-included-apr \
$ make
# make install
Instalación de Mod_JK 1.30 en 64bits
Al igual que antes, vamos a compilar Mod_JK en 64bits utilizando el compilador de SunCC -Sun Compiler Tools-
$ wget http://www.apache.org/dist/tomcat/tomcat-connectors/jk/source/jk-1.2.30/tomcat-connectors-1.2.30-src.tar.gz
$ gtar zxpf tomcat-connectors-1.2.30-src.tar.gz
$ cd tomcat-connectors-1.2.30-src/native
$ export CC=cc
$ export CFLAGS="-m64 -O2"
$ ./configure --with-apxs=/opt/www/apache2/64/bin/apxs
$ make
# make install
Configuración de Apache Mod_JK
A continuación vamos a configurar el módulo <mod_jk>, para ello, deberemos indicar en el archivo de configuración <$APACHE_HOME/conf/httpd.conf> que carge el módulo de mod_jk utilizando para ello "LoadModule" -en Apache 2.2 la ubicación es $APACHE_HOME/modules, en 1.3.x es $APACHE_HOME/libexec-
#############################################
# CARGA DE MODULOS JK
#############################################
LoadModule jk_module          modules/mod_jk.so

#################################################
## MOD_JK
#################################################
<IfModule mod_jk.c>
  JkWorkersFile conf/extra/modules/modjk.conf.d/modjk.conf
 JkLogFile logs/mod_jk.log
 JkLogLevel error
<IfModule>
Continuaremos con la creación del archivo de configuración <modjk.conf> que hemos definido en <JkWorkersFile> donde definiremos los nombres, puertos y demás parámetros de los tomcat que queremos utilizar.

El formato del archivo <JkWorkersFile> puedes encontrarlo en la documentación oficial de Apache Tomcat, pero os he preparado un JkWorkersFile de ejemplo con las principales propiedades para que no empeceis desde cero.

Configurar Apache Tomcat JK Connector
Ahora toca el turno a nuestra instalación de Apache Tomcat, para ello editaremos el archivo <$TOMCAT_HOME/conf/server.xml> y en el apartado <SERVICE> deberemos declarar un connector nuevo, pero esta vez, utilizará el protocolo <AJP/1.3>. El puerto debe ser el mismo que hemos puesto en el valor de la propiedad <Worker.Port>, por si alguno tiene dudas, aquí os dejo un archivo de configuración de Apache Tomcat Server.xml de Ejemplo:

    <Connector
        port="13201"
        protocol="AJP/1.3"
        redirectPort="8443"
        connectionTimeout="20000"
        bufferSize="8192"
        URIEncoding="UTF-8"
    />
Configuración VirtualHost de Apache
Por último, sólo nos queda indicar a Apache HTTPD Qué contenido debe ser procesado por Tomcat y cuál por él. Para ello, deberemos utilizar la propiedad <JkMount _mountpoint_ _worker_> donde mountpoint hace referencia a la expresión regular y worker al nombre del tomcat, por ejemplo, si queremos que todas las JSP y Servlet los procese nuestro worker router, haremos
JkMount /*.jsp router cluster1
JkMount /*servlet* cluster1
Por lo tanto, nuestro virtualhost deberá quedar así -ten en cuenta que es un ejemplo-
################################################
## WWW.TEST.COM
################################################
<VirtualHost *:80>
  JkMount /*.jsp cluster1
  JkMount /*servlet* cluster1
</VirtualHost>
Finalización de proceso
Ya tenemos configurado el sistema, sólo nos queda iniciar el Tomcat y el Apache, para probar que todo está como queremos.

Conclusión
En esta ocasión hemos visto cómo podemos poner un servidor Apache HTTPD haciendo de frontend de Tomcat y, esto nos va a permitir utilizar -por ejemplo- mod_rewrite para simular URL estáticas, además de proporcionarnos un LoadBalance que nos permitirá escalar nuestros aplicativos de forma sencilla.

Sin embargo, todavía esta configuración no es para ir a producción ya que no hemos tratado en ningún caso el uso de recursos, cargas, ... y, debemos separar las capas para establecer un punto de entrada (DMZ) el cual tengo un acceso muy controlado -utilizando IPFilter-

En la próxima entrega ya sí que veremos cómo establecer una configuración de producción -ahora que tenemos las bases- y veremos cómo utilizar la tecnología de zonas para encapsular nuestros servicios y hacerlos mucho más seguros.


<< Instalación de Apache Tomcat "Stand Alone"

Referencias

viernes, 16 de abril de 2010

Cómo crear un Banner/Poster desde linea de comandos

Introducción
Para crear banner -o poster- desde línea de comandos para hacer más interesantes nuestros mensajes de </etc/motd> o </etc/issue> utilizaremos el comando <banner _texto_>. El tamaño máximo de nuestro <texto> es de 10 caracteres por línea
$ banner Hola
#     #
#     #   ####   #         ##
#     #  #    #  #        #  #
#######  #    #  #       #    #
#     #  #    #  #       ######
#     #  #    #  #       #    #
#     #   ####   ######  #    #

Por ejemplo, podemos utilizarlo para crear nuestro Banner de acceso de SSH, FTP, etc
# banner SFChildren >> /etc/issue
Referencias

miércoles, 14 de abril de 2010

Configurar Virtual Hosts en Tomcat 6 y Contextos de Aplicación - Parte 1

Introducción
En esta serie de artículos, vamos a ver las diferentes formas que hay para definir una estructura de Apache Tomcat para su puesta en producción. Veremos cómo podemos configurar Apache Tomcat con Apache HTTP mediante <mod_jk> y cómo poner <squid-cache> como frontend haciendo de proxy reverso.

Como es una serie y no un unico post iremos viendo cómo montar la infraestructura, desde lo más básico, hasta -en las últimas entregas- cómo ponerlo en producción.

Instalar Apache Tomcat "Stand Alone"
Uno de los problemas con los encontramos al montar Apache Tomcat, es que si no queremos ejecutarlo con root debemos levantarlo en un puerto superior a 1024. Esto hace que tengamos que utilizar ipfilter para realizar un redirect, por ejemplo:
rdr ed0 0.0.0.0/0 port 80 -> 127.0.0.1 port 8080
De esta forma, hacemos que la peticiones a nuestro puerto http(80) sean redireccionadas al puerto 8080 de localhost.

Con este sencillo paso, hemos conseguido publicar nuestro Apache Tomcat en el puerto http(80), sin embargo, esta configuración -así sola- no nos sirve de mucho, ya que principalmente no tenemos alta disponibilidad, balanceo, firewall, virtual hosts. Además, se incluye el problema del contexto.

Contextos de Aplicaciones Web
El contexto de una aplicación Web es -en casos generales- el nombre de la aplicación, por ejemplo, si tenemos la aplicación web llamada HelloWorld.war, su contexto será <HelloWord>, es decir, la URL resultante será:
http://www.sfchildren.com/HelloWord/index.jsp
Así que tendremos tantos contextos como aplicaciones. Sin embargo, si tecleamos la URL
http://www.sfchildren.com/
Nuestro tomcat utilizará una aplicación expecífica llamada ROOT -que en la instalación por defecto será el manager-

# ls -l $TOMCAT_HOME/webapps/ROOT
total 256
-rw-r--r--   1 webrunner www         5866 may 14  2009 asf-logo-wide.gif
-rw-r--r--   1 webrunner www         3376 may 14  2009 build.xml
-rw-r--r--   1 webrunner www        21630 may 14  2009 favicon.ico
-rw-r--r--   1 webrunner www         7777 may 14  2009 index.html
-rw-r--r--   1 webrunner www         8307 may 14  2009 index.jsp
-rw-r--r--   1 webrunner www         7317 may 14  2009 RELEASE-NOTES.txt
-rw-r--r--   1 webrunner www         2324 may 14  2009 tomcat-power.gif
-rw-r--r--   1 webrunner www         1934 may 14  2009 tomcat.gif
-rw-r--r--   1 webrunner www        65643 may 14  2009 tomcat.svg
drwxr-xr-x   2 webrunner www          512 jun 16  2009 WEB-INF
Para evitar que nos muestre la página de administración de Tomcat, tenemos varias soluciones, vamos a ir viendo cada una de ellas.

Crear un <index.html> con un redirect a la página correcta
Por ejemplo, podemos crear una página <index.html> con un pequeño script en JavaScript que nos mande un 301 a la nueva dirección. Siguiendo con el ejemplo,
$ cd $TOMCAT_HOME/webapps/ROOT
$ vi index.html
  <HTML>
  <HEAD>
  <META
     HTTP-EQUIV="Refresh"
     CONTENT="0; URL=http://www.sfchildren.com/HelloWord/index.jsp">
  </HEAD>
  <BODY>
  </BODY>
  </HTML>
:wq

Problemas de esta solución
Bueno, no hace falta decir que si tenemos varias aplicaciones en el mismo tomcat sólo podremos hacer un redirect a una de ellas, además de no tener soporte para VirtualHosts


Sustituir la aplicación <ROOT> por nuestra <HelloWord>
Ya hemos comentado antes que tomcat tiene definida una aplicación por defecto llamada <ROOT> la cual hace referencia a la aplicación sin contexto, podemos por lo tanto, sustituir esta por nuestra aplicación <HelloWord>, veamos un ejemplo -imaginamos que tenemos la aplicación HelloWorld.war en nuestro HOME-
$ cd $TOMCAT_HOME/webapps/ROOT
$ jar xvf $HOME/HelloWorld.war
$ ls -l
total 258
-rw-r--r--   1 webrunner www          148 abr 14 11:35 index.html
drwxr-xr-x   2 webrunner www          512 jun 16  2009 WEB-INF

Qué hemos conseguido
Al hacer este cambio, hemos hecho que el contexto <HelloWord> no sea necesario, y por lo tanto, nuestra URL ahora será la siguiente:
http://www.sfchildren.com/


Problemas de esta solución
Al igual que sucedía antes, seguimos necesitando una instalación de tomcat por aplicación y por lo tanto, muchos sistemas a administrar. Además, no tenemos VirtualHosts ...


Creación de VirtualHosts en Tomcat6
Para solucionar estos problemas tenemos los VirtualHost que -de forma sencilla- hacen una discriminación de la petición en función del valor de la cabecera HOST de cada petición http, por lo tanto, lo que nosotros queremos es que las peticiones a:
  • http://app1.sfchildren.com/ sean enviadas a HelloWorld1
  • http://app2.sfchildren.com/ sean enviadas a HelloWorld2
La activación de los virtualhost en Tomcat6 no requiere de grandes configuraciones, tan sólo es necesario modificar un par de archivos de configuración, es muy importante que el tomcat esté detenido antes de comenzar

Lo primero que debemos hacer es dar de alta los hosts en el archivo de configuración del servidor <$TOMCAT_HOME/conf/server.xml> en el apartado de <Engine>. El formato del tag es:
<Host name="_nombre_vhost_"     appBase="_path_to_base_dir" />

En nuesto ejemplo, crearemos <app1> y <app2> como virtual hosts
$ vi $TOMCAT_HOME/conf/server.xml
    ...
        <Host name="app1.sfchildren.com"      appBase="vdomains/app1.sfchildren.com" />
        <Host name="app2.sfchildren.com"      appBase="vdomains/app2.sfchildren.com" />
   ...

:wq
A continuación crearemos el directorio appBase con sus subdominios
$ mkdir -p $TOMCAT_HOME/vdomains/app1.sfchildren.com
$ mkdir -p $TOMCAT_HOME/vdomains/app2.sfchildren.com
Y creamos las aplicación <ROOT> con nuestra HelloWorld -como hemos visto antes-

$ mkdir $TOMCAT_HOME/vdomains/app1.sfchildren.com/ROOT
$ mkdir $TOMCAT_HOME/vdomains/app2.sfchildren.com/ROOT
$ cd $TOMCAT_HOME/vdomains/app1.sfchildren.com/ROOT
$ jar xvf $HOME/HelloWorld1.war
$ cd ../app2.sfchildren.com/ROOT
$ jar xvf $HOME/HelloWorld2.war
A continuación, levantaremos el tomcat con svc y con un navegador nos pondremos en cada una de las diferentes URL para ver cómo vamos a una u otra.

Un concepto muy importante a tener en cuenta es el uso de resources dentro de los contextos de aplicaciones, es decir, el acceso mediante JNDI a un DataSource. Para que el procedimiento de virtualhost de tomcat no nos amargue la vida con problemas, deberemos pedir que los aplicativos (war) tengan definido su context.xml dentro de la carpeta <WebAPP/META-INF/>, esto nos hará los despliegues en virtualhost mucho más sencillos
$ ls -l $TOMCAT_HOME/vdomains/app1.sfchildren.com/ROOT/META-INF/
total 4
-rw-r--r--   1 webrunner www          536 feb 28 22:51 context.xml
-rw-r--r--   1 webrunner www          102 abr 13 00:02 MANIFEST.MF

Problemas de esta Solución
Claro, no todo puede ser tan bonito. Hemos solucionado el problema del contexto y de tener varias aplicaciones web sobre el mismo servidor Tomcat, sin embargo, tenemos algunas carencias que no podemos cubir: Balanceo de Carga -Alta disponibilidad-, URL Rewrite, Firewall L7

Conclusiones
En esta primera parte de Puesta en producción de Apache Tomcat, hemos visto cómo podemos utilizar los VirtualHosts para solucionar los problemas a múltiples aplicaciones dentro del mismo tomcat. Sin embargo, sólo con apache tomcat no podemos ofrecer las soluciones a todos los problemas que se nos presentan -alta disponibilidad, URL rewrite-.

En la próxima entrega veremos cómo incluir Apache HTTPD con su módulo <mod_jk> el cual nos permitirá  conectarnos a tomcat y realizar tareas de balanceo, standby, ... hasta entonces, esperar


Referencias