lunes, 21 de febrero de 2011

Instalación de un Servidor de Desarrollo - Parte 3 : Instalación de Java, MySQL, Apache, y Tomcat

En el tutorial anterior de la serie (personalización del prompt) explicamos de forma muy breve las ventajas que nos daba tener un servidor de desarrollo para la fase de implementación de nuestros proyectos, además vimos cómo agregar un poco de color a nuestro prompt.

Una parte importante de un servidor de desarrollo son las herramientas con las que este cuente (que dependerán un poco de los tipos de proyectos y políticas de nuestra empresa/trabajo/grupo de desarrollo) y que nos facilitarán este tan arduo pero gratificante trabajo ^_^.

Instalaremos varias aplicaciones para este fin, como un servidor para control de versiones de código fuente, un servidor de integración continua, una aplicación para reportes de incidencias, etc. Además veremos cómo integrar todas estas herramientas con nuestro IDE de cabecera, el NetBeans, para trabajar de una forma integral.

En este tutorial aprenderemos a instalar las versiones más recientes de las herramientas básicas con las que contará nuestro servidor (entre las cuales se encuentra el JDK de java). En este tutorial instalaremos los siguientes servicios:

Y veremos cómo configurarlos para que arranquen junto con nuestro servidor.

Instalaremos todas estas herramientas usando su código fuente intentando cubrir la mayor cantidad posible de distribuciones de Linux. Esto además nos permitirá usar las últimas versiones de estas herramientas sin tener que agregar repositorios extraños. Aunque si alguien quiere facilitarse la vida siempre pueden usar herramientas como YaST o con el mismo apt-get. También haremos todo esto desde una consola y usando comandos ya que, como recordarán, la única forma que tenemos de acceder a nuestro servidor es a través de SSH, por lo que no contaremos con una interface gráfica de usuario.

Lo primero que haremos es acceder a nuestro servidor remoto usando una cliente de SSH, como putty o kitty. Accedemos como cualquier usuario que tengamos dados de alta y luego nos logueamos como root usando el comando


su




*Nota: Por motivos de seguridad es recomendable no usar nunca el usuario root (si es posible también se recomienda desactivarlo) y en lugar de esto ejecutar las instrucciones necesarias usando "sudo". Pero en estos tutoriales haré caso omiso de esta recomendación ^_^.

Ahora crearemos los siguientes grupos a los que pertenecerán las aplicaciones que instalaremos:
  • desarrollo
  • basesDeDatos
  • servidores

Algunas de las aplicaciones pertenecerán a más de un grupo. Esto nos permitirá que conforme vayamos agregando nuevos usuarios a nuestro servidor, estos solo puedan usar las herramientas de los grupos a los que pertenecen. Por ejemplo, los usuarios que solo tengan que acceder a nuestra base de datos, no queremos que también pueda hacer cosas dentro de nuestro servidor apache.

Procedemos a crear los grupos con el comando "groupadd", de la siguiente forma:


groupadd desarrollo
groupadd basesDeDatos
groupadd servidores




En la secciones correspondientes iremos agregando los usuarios que serán los propietarios de cada una de nuestras herramientas.

En este momento les recomiendo cambiar su directorio de trabajo a "/usr/src", que es dónde se recomienda colocar el código fuente de las aplicaciones que instalamos desde el código fuente (al menos en la distribución con la que estamos trabajando).

Comencemos instalando lo que es el corazón de nuestro servidor para el desarrollo de aplicaciones, la última versión del JDK.

*Nota: Dependiendo de los paquetes que hayas seleccionado al momento de realizar la instalación de tu sistema operativo, es posible que ya tengas el JDK instalado. Si este es el caso aún así te recomiendo que descargues e instales la última versión. Yo he instalado los paquetes mínimos, por lo que no tengo el JDK, y esto se reflejará en los screenshots que muestre.


Instalación de la última versión de Java (JDK 6) en Debian

En el momento de escribir este artículo, la última versión del JDK es la 6.25, por lo que será esa la que usaremos para nuestra instalación. Para revisar la última versión puedes hacerlo en este sitio:

http://www.java.net/download/jdk6/

Nosotros descargaremos el archivo auto-extraible para Linux (el que tiene el ".bin" al final) usando el comando "wget"

wget http://www.java.net/download/jdk6/6u25/promoted/b01/binaries/jdk-6u25-ea-bin-b01-linux-i586-27_jan_2011.bin




Esperamos a que termine de realizar la descarga, y una vez todo listo procedemos con la instalación.

Creamos un usuario "java", el cual pertenecerá al grupo "desarrollo", con el comando "useradd":


useradd -g desarrollo java


Luego hacemos que este nuevo usuario sea el dueño del archivo que acabamos de descargar:


chown java:desarrollo jdk-6u25-ea-bin-b01-linux-i586-27_jan_2011.bin




Asignamos permisos para que el usuario, y los miembros del grupo "desarrollo" puedan ejecutar el archivo "jdk-6u25-ea-bin-b01-linux-i586-27_jan_2011.bin", usando el comando "chmod", de la siguiente forma:


chmod ug+x jdk-6u25-ea-bin-b01-linux-i586-27_jan_2011.bin




Ahora creamos el directorio "/usr/java", se lo asignamos al usuario "java", y movemos el archivo "jdk-6u25-ea-bin-b01-linux-i586-27_jan_2011.bin" a este directorio (y de paso acortaremos su nombre):


mkdir /usr/java
chown -R java:desarrollo /usr/java
mv jdk-6u25-ea-bin-b01-linux-i586-27_jan_2011.bin /usr/java/jdk-6u25.bin


Entramos como el usuario "java" y nos movemos al directorio "/usr/java":


su - java
cd /usr/java


Ahora ejecutamos el archivo ".bin" para iniciar la instalación:


./jdk-6u25.bin


Con lo que nuestro archivo comenzará a descomprimirse, hasta que nos muestre un mensaje indicando que la instalación se ha realizado correctamente, y que solo nos falta presionar "Enter":



Presionamos la tecla "Enter" y después de unos segundos se mostrará el mensaje "Done" y se nos volverá a mostrar la línea de comandos:



Terminamos la sesión del usuario "java" y regresamos a la que teníamos como root (para esto pueden presionar las teclas Ctrl + D)

Nuevamente como root creamos un enlace simbólico a al directorio "/usr/java/jdk1.6.0_25" al directorio "/usr/java/jdk", usando el comando "ln":


ln -s /usr/java/jdk1.6.0_25 /usr/java/jdk




Ahora si ejecutan los comandos "java" y "javac" verán aparecer en la consola un hermoso mensaje que dice:


bash: java: command not found
bash: javac: command not found


O si ya tenían instalado un jdk más antiguo, es posible que les muestre una salida diferente. Pero si usan la opción "-v", o "-version", verán que la versión que están llamando es la antigua, y no la que acabamos de instalar.

Esto se debe a que, aunque java ya se encuentra instalado en nuestro sistema, aún hace falta configurarlo para que funcione correctamente. En Debian existe un script de Perl llamado "update-alternatives" el cual nos permite seleccionar qué programa responderá por defecto de entre varias instaladas para el mismo propósito (en este caso "java" o "javac").

Lo primero que haremos es indicar que existen nuevas opciones para los programas "java" y "javac" usando la opción "--install", de la siguiente forma:


update-alternatives --install /usr/bin/javac javac /usr/java/jdk/bin/javac 100
update-alternatives --install /usr/bin/java java /usr/java/jdk/bin/java 100




Ahora que ya tenemos alternativas para estas aplicaciones podemos, si es que tenemos versiones antiguas instaladas, configurar cuál queremos usar usando la opción "--config":


update-alternatives --config java


y con


update-alternatives --config java




En mi caso esto no me servirá de nada porque solo tengo una opción. Pero, como dije antes, si ustedes tienen más pueden seleccionar aquí cuál quieren usar por defecto.

Ahora agregaremos un par variables de entorno y configuraremos nuestro PATH para que apunten al directorio "bin" de nuestro nuevo jdk. Abrimos el archivo "/etc/profile" con nuestro editor de texto favorito, y al final de este, antes de la línea que dice:


export PATH


Agregamos lo siguientes:


JAVA_HOME="/usr/java/jdk"
JRE_HOME=$JAVA_HOME
PATH=$PATH:$JAVA_HOME/bin
PATH=$PATH:$JRE_HOME/bin


y modificamos la línea que dice:


export PATH


Para que diga:


export PATH JAVA_HOME JRE_HOME




Guardamos el archivo y ejecutamos el siguiente comando, para que el sistema se dé cuenta del cambio:


source /etc/profile


y después pueden hacer:


echo $PATH
echo $JAVA_HOME
echo $JRE_HOME


para verificar que todo se configurado correctamente:



Ahora cuando ejecutemos los comandos:


java –version
javac –version


Obtendremos lo siguiente:



Por lo que nuestro jdk está listo para ser usado.

Ahora instalaremos nuestra base de datos.


Instalación de MySQL 5.5 en Debian

Instalaremos la última versión de MySQL, que en este momento es la 5.5.9. Lo haremos de la misma forma que hemos hecho con el jdk: descargaremos el código fuente de MySQL, lo compilaremos, instalaremos, y crearemos un usuario que será el dueño de esta aplicación.

*Nota: La instalación de MySQL 5.5 varia un poco con respecto a la instalación de la versión anterior (5.1). Si por alguna razón no quieren instalar la versión 5.5 haré las anotaciones correspondientes sobre cómo instalar MySQL 5.1 en las partes donde el proceso de instalación varíe ^_^.

Lo primero que haremos es instalar una librería llamada "libncurses5", la cual es necesaria para compilar aplicaciones que hagan uso de ncurses, como MySQL (ñ_ñ). Solo como breviario cultural, "ncurses" son unas librerías que ayudan a la programación en modo texto para Linux. Es decir, movimientos de cursores, colores, recoger teclas (sin tener que esperar el "Enter") y un largo etcétera. Como MySQL hace uso de estas librerías, debemos instalarlas en nuestro sistema, haciendo uso de "apt-get", como root, de la siguiente forma:

apt-get install libncurses5-dev


Una vez que ejecutemos este comando, veremos cómo comienza a descargar, y posteriormente instalar las librerías:



Ahora descargaremos el código fuente de MySQL, usando nuevamente el comando "wget":

Para descargar MySQL 5.5 ejecuten:


wget http://gd.tuwien.ac.at/db/mysql/Downloads/MySQL-5.5/mysql-5.5.9.tar.gz


Y para MySQL 5.1:


wget http://downloads.mysql.com/archives/mysql-5.1/mysql-5.1.50.tar.gz


Si no realizaron la descarga en el directorio "/usr/src" deberán mover el archivo descargado al este directorio:


mv mysql-5.5.9.tar.gz /usr/src/


O para MySQL 5.1:


mv mysql-5.1.50.tar.gz /usr/src/


Nos cambiamos a al directorio "/usr/scr", y descomprimimos el archivo archivo.


tar -xvf mysql-5.5.9.tar.gz


o para MySQL 5.1:


tar -xzf mysql-5.1.50.tar.gz


Una vez descomprimido, entramos al directorio que se acaba de crear "mysql-5.5.9":


cd mysql-5.5.9


o "mysql-5.1.50" para MySQL 5.1:


cd mysql-5.1.50


Ahora configuraremos el código fuente para instalar la base de datos. Para entender un par de parámetros que usaremos debo dar una explicación sobre los conjuntos de caracteres que podemos usar en la base de datos y sobre el "collate" o colación de los mismos.

Un conjunto de caracteres es un conjunto de símbolos y codificaciones. Una colación es un conjunto de reglas para comparar caracteres en un conjunto de caracteres. Vamos a dejar clara la distinción con un ejemplo de un conjunto de caracteres imaginario.

Supongamos que tenemos un alfabeto con cuatro letras: 'A', 'B', 'a', 'b'. Damos a cada letra un número: 'A' = 0, 'B' = 1, 'a' = 2, 'b' = 3. La letra 'A' es un símbolo, el número 0 es la codificación para 'A', y la combinación de las cuatro letras y sus codificaciones es un conjunto de caracteres.

Suponga que queremos comparar dos cadenas de caracteres, 'A' y 'B'. La forma más fácil de hacerlo es mirar las codificaciones: 0 para 'A' y 1 para 'B'. Ya que 0 es menor a 1, decimos que 'A' es menor que 'B'. Lo que acabamos de hacer es aplicar una colación a un conjunto de caracteres. La colación es un conjunto de reglas (sólo una en este caso): "compara las codificaciones". Llamamos a la más sencilla de todas las colaciones una colación binaria.

Pero, ¿qué pasa si queremos decir que las letras en mayúsculas y minúsculas son equivalentes? Entonces tendríamos como mínimo dos reglas: (1) tratar las letras minúsuclas 'a' y 'b' como equivalentes a 'A' y 'B'; (2) luego comparar las codificaciones. Llamamos a esto una colación no sensible a mayúsuculas y minúsculas (case-insensitive). Es un poco más compleja que una colación binaria.

En el mundo real, la mayoría de conjuntos de caracteres tienen varios caracteres: no sólo 'A' y 'B' sino alfabetos completos, a veces varios alfabetos o sistemas de escritura orientales con miles de caracteres, junto con muchos símbolos especiales y signos de puntuación. También en el mundo real, la mayoría de colaciones tienen muchas reglas: no sólo distinción entre mayúsculas y minúsculas, sino también sensibilidad a tildes (una "tilde" es una marca añadida a un carácter como en alemán 'Ö') y mapeos de múltiples caracteres (tales como la regla que 'Ö' = 'OE' en una de las dos colaciones alemanas).

Después de haber leído esta teoría, podrían estarse preguntando, ¿qué nos importa esto para la instalación de nuestra base de datos? Pues en realidad podríamos decir que poco. Estableceremos cuál será el conjunto de caracteres y el collate que se usará por default en MySQL. Esto es para que nuestra base de datos acepte caracteres con acentos y la famosa "ñ", que muchos problemas nos han dado en alguna ocasión. Usaremos el conjunto de caracteres "utf-8" que es el conjunto de caracteres más amplio. Para el collate usaremos "utf8_spanish_ci". Esto quiere decir que las comparaciones que se hagan no distinguirán entre mayúsculas y minúsculas, o sea que "Alex" y "alex" serán exactamente iguales. Hay una convención para nombres de colaciones: empiezan con el nombre del conjunto de caracteres al que están asociados, normalmente incluyen el nombre del idioma, y acaban con "_ci" (no distingue entre mayúsculas y minúsculas, case insensitive), "_cs" (distingue entre mayúsculas y minúsculas, case sentitive), o "_bin" (binario).

Ahora sí, pasaremos a configurar el código fuente para su instalación, con la siguiente línea:

*Nota: MySQL 5.5 está configurado para usar el sistema de construcción cmake, además de usar las librerías de bison, mientras que MySQL 5.1 está configurado para usar el make "regular", así que los que estamos instalando MySQL 5.5 primero deberemos instalar "cmake" usando el siguiente comando:


apt-get install bison
apt-get install cmake


Y configurar el código fuente usando:


cmake . -DCMAKE_INSTALL_PREFIX=/usr/local/mysql-5.5.9 -DDEFAULT_CHARSET=utf8 -DDEFAULT_COLLATION=collation=utf8_spanish_ci -DWITH_INNOBASE_STORAGE_ENGINE=1


Los que estén instalando MySQL 5.1 pueden configurar el código fuente usando el comando siguiente:


./configure --prefix=/usr/local/mysql-5.1.50 --with-charset=utf8 --with-collation=utf8_spanish_ci --with-innodb


Con lo que la configuración comenzará a ejecutarse. Si quieren qué otras opciones podemos establecer en la configuración pueden hacerlo en la página de la configuración de MysQL 5.1

Una vez terminado este proceso, deberemos ver en la consola un mensaje que diga "Thank you for choosing MySQL!"



Los que estamos instalando MySQL 5.5 no veremos el mensaje anterior :(.

Ahora continuaremos con el proceso para ambas versiones. Compilaremos el código de MySQL ejecutando el comando "make", en el directorio en el que nos encontramos:


make


En la consola podemos ver todo el proceso que se está ejecutando. Después de unos (muchos, créanme, bastantes) minutos, al terminarse este proceso, veremos nuevamente la línea de comandos.



Finalmente, realizamos la instalación ejecutando el comando:


make install clean


Nuevamente tardara unos minutos realizando algunas tareas y al final nos devolverá a la línea de comandos. Y listo, ya tendremos nuestro servidor instalado. Si vamos al directorio "/usr/local" veremos que se nos ha creado un directorio nuevo llamado "mysql-5.5.9", o "mysql-5.1.50" para los que instalaron la versión 5.1:



Ahora, si ejecutamos el comando "mysql", veremos aparecer en la consola el siguiente mensaje:


bash: mysql: command not found




Esto quiere decir que aún nos faltan cosas por configurar.

Primero crearemos un enlace simbólico del directorio "/usr/local/mysql-5.5.9" a "/usr/local/mysql":

ln -s /usr/local/mysql-5.5.9 /usr/local/mysql


O de "/usr/local/mysql-5.1.59", para los que instalaron la versión 5.1:

ln -s /usr/local/mysql-5.1.50 /usr/local/mysql




Ahora procedemos a crear un usuario "mysql", que pertenecerá a los grupos "desarrollo", y "basesDeDatos".

Creamos al usuario "mysql" con el comando "useradd":


useradd –g basesDeDatos –G desarrollo mysql




Dependiendo de su versión y distribución de Linux, tal vez no puedan agregar al usuario a los dos grupos al mismo tiempo, en este caso deberán agregarlo al grupo "basesDeDatos" al momento de crearlo, y después a "desarrollo" usando el comando "usermod", de la siguiente forma:


usermod -a -G desarrollo mysql


O modificando directamente el archivo "/etc/group".

Asignamos este directorio al usuario "mysql":


chown -R mysql:basesDeDatos /usr/local/mysql


Y damos permisos de que el dueño del directorio tenga permisos completos, los usuarios del mismo grupo puedan leer y ejecutar, y los otros usuarios no puedan hacer nada:


chmod -R 750 /usr/local/mysql




Hacemos lo mismo para el directorio "mysql-5.5.9"


chown -R mysql:basesDeDatos /usr/local/mysql-5.5.9
chmod -R 750 /usr/local/mysql-5.5.9


O para el directorio "mysql-5.1.50", dependiendo de la versión que hayamos instalado:


chown -R mysql:basesDeDatos /usr/local/mysql-5.1.50
chmod -R 750 /usr/local/mysql-5.1.50


Ahora regresamos al directorio "/usr/src/mysql-5.5.9" y entramos al subdirectorio "support-files":


cd /usr/src/mysql-5.5.9/support-files


o, para MySQL 5.1 a "/usr/src/mysql-5.1.50":


cd /usr/src/mysql-5.1.50/support-files


Este es un directorio especial con algunos archivos de configuración y otras cosas. Nosotros tomaremos el archivo de configuración más simple ("my-small.cnf") y lo usaremos para terminar de configurar nuestro servidor de base de datos. Movemos este archivo al directorio "/etc" y lo renombramos como "my.cnf"


cp my-small.cnf /etc/my.cnf


Después editamos este archivo usando nuestro editor de texto favorito (yo usare nano, no es mi favorito pero creo que es el más fácil de usar):


nano /etc/my.cfg


Buscamos la línea que dice:


#The MySQL server
[mysqld]


Y agregamos la línea:


user = mysql




Agregamos también las siguientes variables que nos proporcionarán un log de errores y un log general de queries:


general-log=/var/log/mysql.log
log-error=/var/log/mysql_error.log


Guardamos el archivo y agregamos a nuestra variable de entorno "PATH" la ruta del directorio "bin" de MySQL. Recuerden que para esto debemos editar el archivo "/etc/profile":


PATH=$PATH:/usr/local/mysql/bin




Guardamos el archivo y ejecutamos el comando


source /etc/profile


Ahora terminaremos la configuración creando la base de datos que usa MySQL para guardar su configuración. Entre otras cosas, se inicializará el directorio de datos y creará las tablas del sistema. Es importante ejecutar este comando con el mismo usuario que será usado para levantar el servicio de mysql (mysqld). Nos logueamos como el usuario "mysql", nos movemos al directorio "/usr/local/mysql":


cd /usr/local/mysql


y ejecutamos el siguiente comando, para MySQL 5.5 usamos:


/usr/local/mysql/scripts/mysql_install_db --user=mysql


Y para MySQL 5.1:

/usr/local/mysql/bin/mysql_install_db --user=mysql


Después iniciamos el servicio de MySQL de modo seguro con el siguiente comando:


/usr/local/mysql/bin/mysqld_safe --user=mysql &




Entraremos ahora a hacer unas configuraciones de usuarios. Entraremos a mysql usando la cuenta de "root". En este momento aunque la cuenta existe esta no está protegida con ninguna contraseña (cosa que arreglaremos en unos momentos). Accedemos a mysql con la siguiente instrucción:


/usr/local/mysql/bin/mysql -u root


Ahora, si no queremos permitir acceso a usuarios anónimos, los eliminamos con la siguiente sentencia:


DELETE FROM mysql.user WHERE User = '';




Si consultamos los usuarios que tenemos ahora, que tienen acceso a nuestro servidor de base de datos, ahora solo debemos tener al usuario "root":


SELECT Host, User FROM mysql.user;




En la imagen anterior "miniServer" es el nombre del servidor que estoy configurando, así que seguramente a ustedes les aparecerá un nombre distinto.

Pasemos a proteger la cuenta del usuario "root" con una contraseña, usando los siguientes comandos:


SET PASSWORD FOR 'root'@'localhost'=OLD_PASSWORD('contraseña');
SET PASSWORD FOR 'root'@'localhost'=PASSWORD('contraseña');


La función "OLD_PASSWORD" deja la contraseña con un formato tal que nos permitirá conectarnos a esta usando algunas herramientas antiguas como el "DBDesigner" o algunos módulos del mismo Apache.

*Nota: en MySQL 5.5 tal vez sea necesario que reinicien el servidor para que estos cambios tomen efecto.

Ahora salimos del manejador de base de datos:


quit


Detenemos el servicio de MySQL con el siguiente comando, que nos pedirá la contraseña de "root" que acabamos de configurar:


/usr/local/mysql/bin/mysqladmin -u root -p shutdown




El siguiente paso será hacer que MySQL se inicie o levante de forma automática al iniciar nuestro servidor. Para esto copiaremos un script que se encuentra en el directorio "/usr/src/mysql-5.5.9" o "/usr/src/mysql-5.1.50", llamado "mysql.server". Este script básicamente nos permitirá iniciar y detener el servicio de MySQL. Copiamos, como root, este archivo al directorio "/etc/init.d/" y le damos permisos de ejecución:


cp /usr/src/mysql-5.5.9/support-files/mysql.server /etc/init.d/mysql
chmod 755 /etc/init.d/mysql


o, si estamos instalando MySQL 5.1:


cp /usr/src/mysql-5.1.50/support-files/mysql.server /etc/init.d/mysql
chmod 755 /etc/init.d/mysql


Ahora haremos que nuestro servidor inicie el servicio de MySQL de forma automática registrándolo como un servicio de nuestro servidor. Primero lo eliminaremos como servicio (si es que ya existe) y después lo agregaremos nuevamente, con los siguientes comandos:


update-rc.d -f mysql remove
update-rc.d -f mysql defaults


Los dos comandos anteriores son usados en Debian y las distribuciones basadas en este, si están usando otra distribución tal vez deban usar estos comandos:


chkconfig --add mysql
chkconfig --level 35 mysql on


Ahora que ya tenemos todo listo podemos, si es que lo desean, reiniciar el servidor y entrar nuevamente a mysql, como root, con el comando:


mysql –u root –p


*Nota: tal vez sea necesario que reinicien el servidor en este paso si es que no les permite conectarse a mysql



Ahora pasaremos a instalar el servidor HTTP Apache 2.


Instalación de Apache Http Server 2.2 en Debian

Instalaremos la última versión del servidor Apache (en este momento la 2.2.17). Lo primero que hacemos es descargar el código fuente de Apache 2.2 con el comando "wget" (recuerden descargar este archivo en el directorio "/usr/src"):


wget http://apache.mirrors.hoobly.com//httpd/httpd-2.2.17.tar.gz


Para los que no lo descargaron en el directorio indicado, aún pueden corregir esto y una vez que la descarga termine mover el archivo que acabamos de mover al directorio "/usr/src"

mv httpd-2.2.17.tar.gz /usr/src/


Nos cambiamos a este directorio:


cd /usr/src


Descomprimimos el archivo "httpd-2.2.17.tar.gz"


tar -xzf httpd-2.2.17.tar.gz


Y entramos al directorio que se acaba de crear:


cd httpd-2.2.17


Nuevamente configuraremos el código fuente para poder instalar el servidor web. Usaremos el comando "configure", de la siguiente forma.


./configure --prefix=/usr/local/apache-2.2.17 --enable-so --enable-rewrite --enable-dav=shared --enable-dav-fs=shared --enable-authn-dbd=shared --enable-dbd=shared --with-mysql=/usr/src/mysql-5.5.9


*Nota: si están usando la versión 5.1 de MySQL tengan cuidado de modificar la ultima parte del comando

La opción más importante es "prefix" que nos indica en qué directorio será instalado el servidor Apache. "enable-so" habilita el soporte de DSO (Dynamic Shared Object), o sea que los módulos que compilemos como objetos compartidos podrán ser cargados y descargados en tiempo de ejecución (tal vez explique más de esto en un tutorial posterior). Las úlimas dos opciones nos servirán para cuando queramos agregar servicios extra como el subversion, del que hablaré en un próximo tutorial. Si desean ver qué otras opciones pueden usar, pueden verlas en la página de configuración de Apache.

Una vez terminado el proceso de configuración, compilamos el código fuente ejecutando el comando "make" en el directorio en el que nos encontramos:


make


Cuando este proceso termine nos mostrará la línea de comandos, y podremos realizar la instalación con el siguiente comando:


make install clean


Al terminar ya tendremos listo nuestro servidor Apache. Solo realizaremos unos pequeños pasos de configuración.

Creamos un nuevo usuario llamado "apache2", que pertenecerá a los grupos "desarrollo" y "servidores". Creamos al usuario "apache2" con el comando "useradd":


useradd -g servidores -G desarrollo apache2


Dependiendo de su versión y distribución de Linux, tal vez no puedan agregar al usuario a los dos grupos al mismo tiempo, en este caso deberán agregarlo al grupo "servidores" al momento de crearlo, y después a "desarrollo" usando el comando "usermod", de la siguiente forma:


usermod -a -G desarrollo apache2


O modificando directamente el archivo "/etc/group".

Creamos un enlace simbólico del directorio "/usr/local/apache-2.2.17" a "/usr/local/apache2":


ln -s /usr/local/apache-2.2.17 /usr/local/apache2




Asignamos el directorio "/usr/local/apache-2.2.17" al usuario "apache2" y damos al dueño permisos completos, a los usuarios del mismo grupo permisos de lectura y ejecución, y que los otros usuarios no puedan hacer nada:


chown -R apache2:servidores /usr/local/apache-2.2.17
chmod -R 750 /usr/local/apache-2.2.17/


Y hacemos lo mismo para el directorio "/usr/local/apache2":


chown -R apache2:servidores /usr/local/apache2
chmod -R 750 /usr/local/apache2/




Ahora entramos editamos el archivo "/usr/local/apache2/conf/httpd.conf". Buscamos el lugar en el que se declara el modulo "mpm_netware" o "mpm_netware.c" y reemplazamos:


User daemon
Group daemon


Por :


User apache2
Group servidores




Probemos que nuestro servidor funciona correctamente iniciando el servicio, con el siguiente comando:


/usr/local/apache2/bin/apachectl start


Abrimos un navegador y colocamos en la barra de direcciones la IP de nuestro servidor, que en mi caso es: 5.114.168.188:


http://5.114.168.188


Y deberemos ver en nuestro navegador el mensaje "It works!"



*Nota: Si por alguna razón no logran ver esta página de inicio revisen su firewall para ver que su servidor acepte peticiones por el puerto 80.

Aquí les recomiendo que hagan una cosa (a elección del cliente). Para no estar recordando la ip de nuestro servidor, pueden modificar el archivo hosts de su computadora y agregar una entrada para la ip de su servidor, y un nombre que les sea fácil recordar. Este archivo se encuentra en distintas ubicaciones dependiendo de su sistema operativo, en Windows está en "C:\Windows\System32\drivers\etc".

Yo agregaré un mapeo entre la ip de mi servidor y el nombre de miniServer, de esta forma:


5.114.168.188     miniServer




Y ahora podré entrar ingresando a la dirección:


http://miniserver/




Regresemos a nuestro servidor. Ahora realizaremos la configuración para que nuestro servidor Apache inicie de forma automática cada vez que nuestro servidor de desarrollo se levante. Lo primero que haremos es crear una liga simbólica del archivo "/usr/local/apache2/bin/apachectl" a "/etc/init.d/apache2":


ln -s /usr/local/apache2/bin/apachectl /etc/init.d/apache2


Ahora registraremos a nuestro servidor Apache como un servicio. Nuevamente, primero lo eliminamos (si es que ya existe) y luego lo agregamos nuevamente con los siguientes comandos:


update-rc.d -f apache2 remove
update-rc.d -f apache2 defaults


Si están usando una distribución distinta a Debian, tal vez deban usar estos comandos:


chkconfig --add apachectl
chkconfig --level 35 apachectl on


Y ya ha quedado todo configurado. Si lo desean pueden reiniciar su servidor para comprobar que todo funciona correctamente.

Para terminar este post veremos cómo instalar el contenedor de servlets Apache Tomcat en su versión más reciente, 7.


Instalación de Apache Tomcat 7 en Debian

Instalaremos la última versión del contenedor de Servlets y JSPs Apache Tomcat (que en este momento es la 7.0.8). Esta instalación será la más simple de todas, ya que no deberemos compilar el código fuente, sino solamente descomprimir un archivo y realizar una configuración mínima.

Descargamos Tomcat usando el comando "wget" (recuerden descargarla en el directorio "/usr/src"):


cd /usr/src
wget http://download.filehat.com/apache/tomcat/tomcat-7/v7.0.8/bin/apache-tomcat-7.0.8.tar.gz


Una vez terminada la descarga descomprimimos el archivo tar que acabamos de bajar:


tar -xzf apache-tomcat-7.0.8.tar.gz


Copiamos el directorio que se acaba de crear, "apache-tomcat-7.0.8", al subdirectorio "/usr/local":


cp -R apache-tomcat-7.0.8 /usr/local/


Creamos un enlace simbólico del directorio "/usr/local/apache-tomcat-7.0.8" a "/usr/local/tomcat":


ln -s /usr/local/apache-tomcat-7.0.8 /usr/local/tomcat


Creamos un nuevo usuario llamado "tomcat", que pertenecerá a los grupos "desarrollo" y "servidores", usando el comando "useradd":


useradd -g servidores -G desarrollo tomcat


Dependiendo de su versión y distribución de Linux, tal vez no puedan agregar al usuario a los dos grupos al mismo tiempo, en este caso deberán agregarlo al grupo "servidores" al momento de crearlo, y después a "desarrollo" usando el comando "usermod", de la siguiente forma:


usermod -a -G desarrollo tomcat


O modificando directamente el archivo "/etc/group".

Asignamos el directorio "/usr/local/apache-tomcat-7.0.8" al usuario "tomcat" y damos al dueño permisos completos, a los usuarios del mismo grupo permisos de lectura y ejecución, y que los otros usuarios no puedan hacer nada:


chown -R tomcat:servidores /usr/local/apache-tomcat-7.0.8
chmod -R 750 /usr/local/apache-tomcat-7.0.8/


Y hacemos lo mismo para el directorio "/usr/local/tomcat":


chown -R tomcat:servidores /usr/local/tomcat
chmod -R 750 /usr/local/tomcat/




Ahora agregaremos un usuario que será el administrador del servidor Tomcat. Para editamos el archivo "/usr/local/tomcat/conf/tomcat-users.xml". Dentro del elemento "<tomcat-users>" agregamos la siguiente línea:


<user password="su-contraseña" roles="manager-script,admin,manager-gui,admin-gui" username="su-usuario"/>


Por lo que el archivo debe quedar de esta forma:


<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
    <user password="su-contraseña" roles="manager-script,admin,manager-gui,admin-gui" username="su-usuario"/>
</tomcat-users>


Guardamos el archivo y ahora probemos que nuestro servidor funciona correctamente iniciándolo con el siguiente comando:


/usr/local/tomcat/bin/startup.sh




Abrimos un navegador y colocamos en la barra de direcciones la IP de nuestro servidor, pero ahora entrando por el puerto 8080, en mi caso será:


http://miniServer:8080


Si todo funciona bien deberán ver la página principal de Tomcat:



*Nota: Si por alguna razón no logran ver esta página de inicio revisen su firewall para ver que su servidor acepte peticiones por el puerto 8080.

Realicemos la configuración para que nuestro servidor Tomcat inicie de forma automática cada vez que nuestro servidor de desarrollo se levante. Lo primero que haremos es crear un enlace simbólico del archivo "/usr/local/tomcat/bin/startup.sh" a "/etc/init.d/tomcat".


ln -s /usr/local/tomcat/bin/startup.sh /etc/init.d/tomcat


Ahora registraramos nuestro servidor Tomcat como un servicio. Una vez más primero lo eliminaremos, si es que existe, y luego lo agregaremos nuevamente:


update-rc.d -f tomcat remove
update-rc.d -f tomcat defaults


Si están usando una distribución distinta a Debian tal vez deban usar estos comandos:


chkconfig --add tomcat
chkconfig --level 35 tomcat


Y listo, con esto termina la configuración del Tomcat. Si lo desean pueden reiniciar su servidor para ver que todo funciona correctamente.

Como una nota adicional: pueden iniciar estos tres servicios que hemos instalado usando los siguientes comandos:


service mysql start
service apache2 start
service tomcat start


Y detenerlos con los siguientes comandos:


service mysql stop
service apache2 stop
service tomcat stop


Pues es todo en este post, en el que instalamos los que serán 4 de los servicios básicos de nuestro servidor de desarrollo (JDK6, MySQL 5.5, Apache 2.2, y Tomcat 7). En los siguientes tutoriales vernos cómo configurar algunos otros servicios más, y cómo hacer una integración entre algunos de estos servicios, y con nuestro IDE de trabajo.

No olviden dejar sus dudas, comentarios, sugerencias, críticas y mejoras.

Saludos.

Entradas Relacionadas:

1 comentario:

  1. oye excelente tus tutoriales, no sabes porq cuando intento ingresar en la terminal como
    u - java me pide password ?

    ResponderEliminar