Echando un vistazo a la ayuda del comando vemos claramente la función de cada uno de los parámetros:

$ chage --help
Modo de uso: chage [opciones] [USUARIO]

Opciones:
  -d, --lastday ULTIMO_DÍA      establece el último cambio de clave a
                                ULTIMO_DÍA
  -E, --expiredate FECHA_EXP    establece la fecha de caducidad de la
                                cuenta a FECHA_EXP
  -h, --help                    muestra este mensaje de ayuda y termina
  -I, --inactive INACTIV        desactiva la cuenta después de INACTIV
                                días desde la fecha de expiración
  -l, --list                    muestra la información de envejecimiento
                                de la cuenta
  -m, --mindays DÍAS_MIN        establece el número mínimo de días antes
                                de cambiar la clave a DÍAS_MIN
  -M, --maxdays DÍAS_MAX        establece el número máximo de días antes
                                de cambiar la clave a DÍAS_MAX
  -W, --warndays DÍAS_AVISO     establece el número de días de aviso
                                a DÍAS_AVISO

Como podéis ver, se puede especifica la fecha exacta en la que expirará la clave de acceso, los días permitidos tras la expiración de la cuenta hasta que se desactiva por completo, los días de aviso, etc. Vamos a ver unos ejemplos:

Cambiar la fecha de expiración de la cuenta al día 2011-9-28 al usuario foo

# chage -E 2011-9-28 foo

Listamos los atributos de caducidad especificados para esta cuenta:

# chage -l foo
Último cambio de contraseña					: sep 07, 2011
La contraseña caduca					: nunca
Contraseña inactiva					: nunca
La cuenta caduca						: sep 28, 2011
Mínimo número de días entre cambios de contraseña		: 0
Máximo número de días entre cambios de contraseña		: 99999
Número de días de aviso antes de que caduque la contraseña	: 7

Cambiar número de días entre cambios de clave (15) y la caducidad por inactividad de la clave (150)

# chage -m 15 -M 15 -I 150 foo
# chage -l foo
Último cambio de contraseña					: sep 07, 2011
La contraseña caduca					: sep 22, 2011
Contraseña inactiva					: feb 19, 2012
La cuenta caduca						: sep 28, 2011
Mínimo número de días entre cambios de contraseña		: 15
Máximo número de días entre cambios de contraseña		: 15
Número de días de aviso antes de que caduque la contraseña	: 7

Obligar a cambiar la clave en el próximo intento de acceso

# chage -d 0 foo

También te puede interesar:

• Configurar la caducidad de claves en Linux
• Permisos especiales (setuid, setgid, sticky bit)
• Securizando y optimizando Linux
• Bucle de password expirado en ldap nativo RHEL contra Sun LDAP

Vamos a continuar donde lo dejamos, omitimos el paso de fdisk porque está explicado en ese artículo. Partimos de la base entonces de que tenemos ya creada una partición Linux LVM, en nuestro caso /dev/sda3:

# fdisk -l | grep sda3
/dev/sda3               1        3232    25961008+  8e  Linux LVM

Crear los volúmenes físicos (PV – pvcreate)

Lo primero que debemos hacer cuando trabajamos con LVM es crear los volúmenes físicos (PV) de las particiones con las que queramos crear volúmenes lógicos. Esto lo hacemos con el comando pvcreate. Esto hay que hacerlo en todas las particiones que queramos usar con LVM. En nuestro caso de momento únicamente /dev/sda3:

# pvcreate /dev/sda3
  Physical volume "/dev/sda3" successfully created

Si quisieramos añadir más particiones, simplemente sería ejecutar ese comando con cada una de ellas.

Nota: Hay que tener el paquete lvm2 instalado para poder usar LVM. En Debian:

# apt-get install lvm2

Crear el grupo de volúmen (VG – vgcreate)

Ahora que ya tenemos configuradas las particiones que queremos usar como LVM, podemos añadir el primer grupo de volumen, que contendrá ya nuestros volúmenes lógicos finales. Lo haremos con el comando vgcreate. En nuestro caso sólo tenemos una partición, pero si quisiéramos añadir varias al grupo lo haríamos así:

vgcreate volgroup_01 /dev/sda3 /dev/sda4 /dev/sda5

Bien, voy a añadirlo entonces con mi partición /dev/sda3 que es con la que estamos trabajando de momento:

# vgcreate volgroup_01 /dev/sda3
  Volume group "volgroup_01" successfully created

Con el comando vgscan podemos consultar los grupos creados, con el comando pvscan los volúmenes físicos:

# vgscan
  Reading all physical volumes.  This may take a while...
  Found volume group "volgroup_01" using metadata type lvm2
# pvscan
  PV /dev/sda3   VG volgroup_01   lvm2 [24,76 GB / 24,76 GB free]
  Total: 1 [24,76 GB] / in use: 1 [24,76 GB] / in no VG: 0 [0   ]

Crear los volúmenes lógicos (LV – lvcreate)

Llegados a este punto, únicamente nos falta crear el volúmen lógico, sobre el que ya añadiremos el sistema de ficheros deseado. Vamos a crear un volúmen lógico de 2G de espacio sobre el grupo creado anteriormente (volgroup_01):

# lvcreate -L2G -n volumen_01 volgroup_01
  Logical volume "volumen_01" created

Y con el comando lvscan vemos el estado de los volúmenes:

# lvscan
  ACTIVE            '/dev/volgroup_01/volumen_01' [2,00 GB] inherit

Ahora ya sólo faltaría darle formato y montarlo como una partición normal:

# mkfs.ext4 /dev/volgroup_01/volumen_01
mke2fs 1.41.4 (27-Jan-2009)
Etiqueta del sistema de ficheros=
Tipo de SO: Linux
Tamaño del bloque=4096 (bitácora=2)
Tamaño del fragmento=4096 (bitácora=2)
131072 nodos-i, 524288 bloques...
...
...
...

# mount /dev/volgroup_01/volumen_01 /temporal/
# df -h | grep temporal
                      2,0G   67M  1,9G   4% /temporal

Añadir nuevas particiones a un grupo volumen (vgextend)

La gracia de LVM es que si disponemos de nuevos discos o particiones podemos añadirlas al grupo de volúmen de forma sencilla. Primero tenemos que crear los volúmenes físicos de esas nuevas particiones (recordad, con pvcreate) y luego asignarlas al grupo de volúmen deseado. Vamos a añadir /dev/sda5 a nuestro grupo volgroup_01:

# pvcreate /dev/sda5
# vgextend volgroup_01 /dev/sda5

Aumentar o reducir el tamaño de nuestro volúmen lógico y sistema de ficheros (lvextend – resize2fs)

Ahora podríamos ampliar si quisiéramos el tamaño de nuestro volumen lógico creado anteriormente porque disponemos de más espacio gracias a las nuevas particiones añadidas al grupo de volúmen. VAmos a añadirle 2G más con el comando lvextend:

# lvextend -L +2G /dev/volgroup_01/volumen_01
  Extending logical volume volumen_01 to 4,00 GB
  Logical volume volumen_01 successfully resized

Finalmente tendríamos que ampliar la última capa, el sistema de ficheros, en nuestro caso es ext4 así que usamos resize2fs. Tened cuidado con este último paso ya que tiene su riesgo y si se hace mal se pueden perder datos:

# resize2fs /dev/volgroup_01/volumen_01 4G
resize2fs 1.41.4 (27-Jan-2009)
Filesystem at /dev/volgroup_01/volumen_01 is mounted on /temporal; on-line resizing required
old desc_blocks = 1, new_desc_blocks = 1
Performing an on-line resize of /dev/volgroup_01/volumen_01 to 1048576 (4k) blocks.
El sistema de ficheros en /dev/volgroup_01/volumen_01 tiene ahora 1048576 bloques.

Y el nuevo tamaño ya queda reflejado:

# df -h | grep temporal
                      4,0G   68M  3,7G   2% /temporal

Espero que os haya sido de utilidad esta introducción a LVM (logical volume manager) en GNU/Linux.

También te puede interesar:

• Cómo crear un Linux Logical Volume Manager (LVM) usando fdisk
• Clustered Logical Volume Manager (CLVM) y GFS2
• Comando chage: tiempo de vida de claves y usuarios en GNU/Linux
• Convertir a ext4 en un sistema de ficheros ext3

También te puede interesar:

• Comando chage: tiempo de vida de claves y usuarios en GNU/Linux
• Gestión de LVM en Linux (Logical Volume Manager)
• Diferencias entre soft (symbolic) y hard links
• Permisos especiales (setuid, setgid, sticky bit)

Enlaces simbólicos (soft / symbolic links)

La manera más sencilla de comprender que es un enlace simbólico en Linux es compararlo con el “enlace directo” o “shortcut” en Windows. El fichero o directorio se encuentra en un único punto del disco y los enlaces son un puntero contra él. Cada enlace simbólico tiene su propio número de inodo lo que permite hacer enlaces simbólicos entre distintos sistemas de ficheros.

Para crear enlaces (tanto simbólicos como duros) usamos el comando ln. En este caso vamos a crear un enlace simbólico (parámetro

) del fichero test:

$ ln -s test enlace-a-test

Si listamos ambos veremos que el enlace tiene el carácter

que lo identifica como enlace simbólico:

$ ls -l
lrwxrwxrwx 1 alex alex 4 2011-04-27 18:59 enlace-a-test -> test
-rw-r--r-- 1 alex alex 0 2011-04-27 18:58 test

Para confirmar que el enlace simbólico tiene un inodo distinto usamos el comando stat:

$ stat test
  File: «test»
  Size: 0         	Blocks: 0          IO Block: 4096   archivo regular vacío
Device: 804h/2052d	Inode: 73793       Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 1000/    alex)   Gid: ( 1000/    alex)
Access: 2011-04-27 18:58:53.124142406 +0200
Modify: 2011-04-27 18:58:53.124142406 +0200
Change: 2011-04-27 18:58:53.124142406 +0200

$ stat enlace-a-test
  File: «enlace-a-test» -> «test»
  Size: 4         	Blocks: 0          IO Block: 4096   vínculo simbólico
Device: 804h/2052d	Inode: 77212       Links: 1
Access: (0777/lrwxrwxrwx)  Uid: ( 1000/    alex)   Gid: ( 1000/    alex)
Access: 2011-04-27 18:59:07.812139890 +0200
Modify: 2011-04-27 18:59:06.460112888 +0200
Change: 2011-04-27 18:59:06.460112888 +0200

También lo podemos verificar sacando el inodo en el ls (

):

$ ls -li
77212 lrwxrwxrwx 1 alex alex 4 2011-04-27 18:59 enlace-a-test -> test
73793 -rw-r--r-- 1 alex alex 0 2011-04-27 18:58 test

Hay que tener en cuenta, que en Linux / Unix (al igual que con los accesos directos de Windows), si borramos el fichero o directorio origen, el enlace simbólico permanece pero los datos desaparecen para siempre.
 

Enlaces duros (hard links)

Los enlaces duros lo que hacen es asociar dos o más ficheros compartiendo el mismo inodo. Esto hace que cada enlace duro es una copia exacta del resto de ficheros asociados, tanto de datos como de permisos, propietario, etc. Esto implica también que cuando se realicen cambios en uno de los enlaces o en el fichero este también se realizará en el resto de enlaces.

Los enlaces duros no pueden hacerse contra directorios y tampoco fuera del propio sistema de ficheros.

Vamos a crear un hard link contra el fichero “test” de antes y veremos que efectivamente comparten inodo y que los datos se sincronizan entre ambos:

$ ln test enlace-duro-test
$ ls -li
73793 -rw-r--r-- 2 alex alex 5 2011-04-27 19:09 enlace-duro-test
73793 -rw-r--r-- 2 alex alex 5 2011-04-27 19:09 test

En la primera columna verificamos que tienen el mismo número de inodo y en la tercera se especifica cuando enlaces duros tiene el fichero. Si hacéis cambios en uno de ellos veréis que también se hacen en el resto. Si por ejemplo cambiamos los permisos al fichero test:

$ chmod 0755 test
$ ls -li
73793 -rwxr-xr-x 2 alex alex 5 2011-04-27 19:09 enlace-duro-test
73793 -rwxr-xr-x 2 alex alex 5 2011-04-27 19:09 test

Y finalmente el stat de cada uno verifica todo lo que comentamos:

$ stat test
  File: «test»
  Size: 5         	Blocks: 8          IO Block: 4096   archivo regular
Device: 804h/2052d	Inode: 73793       Links: 2
Access: (0755/-rwxr-xr-x)  Uid: ( 1000/    alex)   Gid: ( 1000/    alex)
Access: 2011-04-27 19:09:51.528132995 +0200
Modify: 2011-04-27 19:09:53.640114896 +0200
Change: 2011-04-27 19:11:42.516138726 +0200

$ stat enlace-duro-test
  File: «enlace-duro-test»
  Size: 5         	Blocks: 8          IO Block: 4096   archivo regular
Device: 804h/2052d	Inode: 73793       Links: 2
Access: (0755/-rwxr-xr-x)  Uid: ( 1000/    alex)   Gid: ( 1000/    alex)
Access: 2011-04-27 19:09:51.528132995 +0200
Modify: 2011-04-27 19:09:53.640114896 +0200
Change: 2011-04-27 19:11:42.516138726 +0200

Diferencias entre soft y hard links

• Los enlaces simbólicos se pueden hacer con ficheros y directorios mientras que los duros solo entre ficheros.
• Los enlaces simbólicos se pueden hacer entre distintos sistemas de ficheros, los duros no.
• Los enlaces duros comparten el número de inodo, los simbólicos no.
• En los enlaces simbólicos si se borra el fichero o directorio original, la información se pierde, en los duros no.
• Los enlaces duros son copias exactas del fichero mientras que los simbólicos son meros punteros o “accesos directos”.

Si se os ocurre alguna diferencia o apunte más no dudéis en comentarlo.

También te puede interesar:

• Cómo montar un sistema de ficheros NFS (Cliente Linux)
• Permisos especiales (setuid, setgid, sticky bit)
• Gestión de trabajos en BASH (jobs, fg, bg, &…)
• redirigir stdin, stdout y stderr en Unix/Linux

setuid

EL bit setuid es asignable a ficheros ejecutables, y permite que cuando un usuario ejecute dicho fichero, el proceso adquiera los permisos del propietario del fichero ejecutado. El ejemplo más claro de fichero ejecutable y con el bit setuid el

.

sirve para ejecutar una shell con identificadores de grupo y de usuario distintos al nuestro, por ello ha de tener este bit y así permitir adquirir al usuario temporalmente permisos administrativos para poder hacer el cambio de usuario.

Podemos ver que el bit está asignado (s) haciendo un ls:

$ ls -l /bin/su
-rwsr-xr-x 1 root root 31012 2009-04-04 07:49 /bin/su

Para asignar este bit a un fichero:

# chmod u+s /bin/su

Y para quitarlo:

# chmod u-s /bin/su

Lógicamente, conviene utilizar este bit con extremo cuidado ya que puede provocar una escalada de privilegios en situaciones inseguras. Para que veáis un ejemplo de lo que se podría hacer.

El usuario “alex” no tiene permisos para ejecutar correctamente un fdisk -l:

alex@linux:~$ fdisk -l

La salida es 0, pero si asignamos el bit setuid al binario de fdisk…

# ls -l /sbin/fdisk
-rwsr-xr-x 1 root root 93048 2009-02-18 20:43 /sbin/fdisk

Probamos de nuevo a ejecutar fdisk con el usuario “alex” y conseguimos privilegios de root:

alex@linux:~$ fdisk -l

Disco /dev/sda: 160.0 GB, 160041885696 bytes
255 cabezas, 63 sectores/pista, 19457 cilindros
Unidades = cilindros de 16065 * 512 = 8225280 bytes
Identificador de disco: 0x000c3c51

Dispositivo Inicio    Comienzo      Fin      Bloques  Id  Sistema
/dev/sda1   *           1        3232    25959424    7  HPFS/NTFS
/dev/sda2            3233        9683    51817657+  83  Linux
/dev/sda3            9684        9855     1381590   82  Linux swap / Solaris
/dev/sda4            9856       19457    77128065   83  Linux

Luego nos acordamos de volver a quitarlo:

# chmod u-s /sbin/fdisk

setgid

Si el bit setuid permitía que el proceso adquiriera los permisos del propietario del fichero ejecutado, setgid hace lo mismo pero adquiriendo los privilegios del grupo asignado al fichero, también es asignable a directorios. Este bit entonces será muy útil cuando varios usuarios de un mismo grupo necesiten trabajar con recursos dentro de un mismo directorio.

En el siguiente ejemplo asignamos el bit setgid la carpeta /compartido, le asignamos permisos totales para el propietario y el grupo (770) y el bit segid (2):

$ mkdir compartido && chmod 2770 /compartido

Si hacemos un ls veremos el bit asignado:

$ ls -l
drwxrws--- 2 alex alex      4096 2011-04-24 21:27 compartido

Ahora vamos a hacer la prueba de crear un fichero dentro del directorio. Lo vamos a crear estando autenticados como root, pero al tener el bit setgid le asignará el grupo “alex” en lugar de root.

$ su
# touch test
root@sistemas:/home/alex/compartido# ls -l
total 0
-rw-r--r-- 1 root alex 0 2011-04-24 21:28 test
# whoami
root

En lugar de modo octal podéis asignar también los permisos setgid del siguiente modo:

$ chmog g+s /compartido

Y quitarlo:

$ chmog g-s /compartido

sticky

Este bit suele asignarse en directorios a los que todos los usuarios tienen acceso, y permite evitar que un usuario pueda borrar ficheros/directorios de otro usuario dentro de ese directorio, ya que todos tienen permiso de escritura. Seguro que lo estáis pensando, este bit se asigna siempre en /tmp y /var/tmp.

tmp tiene permisos 777, el bit sticky se asignaría del siguiente modo:

# chmod 1777 /tmp

También así:

chmod o+t /tmp

Y para quitarlo:

chmod o-t /tmp

Si hacemos un ls veremos la “t” asignada:

drwxrwxrwt  13 root root  4096 2011-04-24 20:55 tmp

Esta es una visión general de estos tres bits especiales asignables a ficheros ejecutables y directorios en Unix/Linux.

También te puede interesar:

• El comando umask
• Comando chage: tiempo de vida de claves y usuarios en GNU/Linux
• Diferencias entre soft (symbolic) y hard links
• Gestión de trabajos en BASH (jobs, fg, bg, &…)

Desde hace unos días está disponible  la versión 5.6 de CentOS (derivada de Red Hat Enterprise Linux 5.6). Esta versión probablemente sea la predecesora del esperado CentOS 6. Las principales novedades que encontramos son interesantes, entre ellas el soporte del sistema de ficheros ext4:

• Soporte completo al sistema de ficheros ext4.
• libvirt actualizada a 0.8.2
• Bind actualizado a to 9.7 y con soporte  NSEC3.
• Añadido ebtables.
• PHP 5.3.
• Añadido Security Services Daemon (SSSD).
• Actualizaciones de drivers, Samba3x, ghostscript, LVM, mod_nss, subversion, gcc, etc.

Para sistemas dentro de la rama 5 actualizar es tan sencillo como lo siguiente, eso sí, conviene revisar si nuestro sistema es compatible con estas actualizaciones:

# yum update

Podéis descargar los distintos instaladores a través de los mirrors en el sitio web de CentOS. También podéis revisar la guía de instalación de CentOS.

También te puede interesar:

• Cómo montar un servidor DHCP
• Instalar y configurar vnc-server en CentOS/RHEL/Fedora
• Cómo añadir IP virtual en Linux
• DM-Multipath en RedHat y CentOS

La sintaxis del comando nice es la siguiente:

# nice -n<PRIORIDAD> COMANDO

Así pues, si quisiéramos ejecutar un proceso con la mayor prioridad disponible (en este caso el script prueba.pl) haríamos lo siguiente:

# nice -n-20 ./prueba.pl

Nota: es necesario ser superusuario para poder utilizar el comando nice

Ejecutando el comando ps observaremos como efectivamente la prioridad ha sido asignada correctamente:

# ps al
F   UID   PID  PPID PRI  NI    VSZ   RSS WCHAN  STAT TTY        TIME COMMAND

4     0  4204  3985   0 -20   1872   504 n_tty_ S<+  pts/0      0:00 /bin/sh ./prueba.pl

Nota: hay que pasar el parámetro

para visualizar la columna de nice.

Si en cambio quisieramos que tuviera la mínima prioridad pues haríamos todo lo contrario:

# nice -n20 ./prueba.pl

Si ejecutamos el comando nice sin parámetros nos indicará el valor asignado actualmente para nice:

# nice
0

También te puede interesar:

• Linux: Listar procesos por % cpu o uso de memoria
• Linux: Mostrar información de CPU
• El comando ps: Listar y manejar procesos
• Debug de procesos en Solaris con Truss

Ejecutar un trabajo/proceso en segundo plano

Para ejecutar algo en segundo plano, debemos utilizar el carácter & y colocarlo tras el comando o proceso a ejecutar:

$ top &

Os recomiendo también revisar esta entrada sobre el comando nohup.

Visualizar los procesos que se encuentran en segundo plano

Para obtener un listado de los procesos que están ejecutándose en segundo plano utilizaremos el comando

(background). La salida del mismo nos indicará cada uno de los procesos con su número de trabajo asignado entre corchetes.

$ bg
[1]+ top &

Traer a primer plano los procesos que se encuentran en segundo plano

Para ello utilizaremos el comando

(foreground) junto con el ID del trabajo anteponiéndole %:

$ fg %1

Suspender un proceso que tenemos corriendo en primer plano

Si estamos ejecutando un trabajo en pantalla/terminal y queremos suspenderlo colocarlo en segundo plano utilizaremos la combinación de teclas Ctrl + Z. Automáticamente nos asignará el ID de trabajo para poder gestionarlo posteriormente:

top - 21:20:57 up 33 min,  2 users,  load average: 0.99, 0.98, 0.81
Tasks: 112 total,   1 running, 111 sleeping,   0 stopped,   0 zombie
Cpu(s): 23.0%us,  4.7%sy,  0.0%ni, 70.5%id,  1.6%wa,  0.1%hi,  0.0%si,  0.0%st
Mem:   2052640k total,   948528k used,  1104112k free,    55876k buffers
Swap:  1951888k total,        0k used,  1951888k free,   461444k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                                                                                  

  776 root      15  -5     0    0    0 S    0  0.0   0:00.02 kjournald2                                                                                                               

[1]+  Stopped                 top

Para volver a arrancarlo en primer plano después:

$ fg %1

Y para ponerlo en segundo plano:

$ bg %1

Esto es realmente útil en casos como por ejemplo, estamos ejecutando un script que se demora más de lo esperado y necesitamos ejecutarlo sin necesidad de una terminal, lo dejamos en segundo plano y seguirá corriendo sin necesidad de ningún entorno visual. También si solo disponemos de una única terminal y necesitamos realizar varias tareas simultaneamente.

Visualizar los trabajos en primer plano, suspendidos, en segundo plano

El comando

nos permite visualizar un listado de los trabajos en el sistema junto con su estado e identificador:

$ jobs
[1]   Stopped                 top
[2]-  Stopped                 top
[3]+  Stopped                 vim

Un resumen práctico sería el siguiente. Arrancamos un programa (por ejemplo thunderbird) desde línea de comandos:

$ thunderbird

Ocurre que necesitamos pararlo temporalmente. En la terminal desde la que lo hemos lanzado presionamos Ctrl + Z.

Ahora el programa está parado a la espera de ser reactivado cuando queramos:

$ thunderbird
^Z
[1]+  Stopped                 thunderbird
$ jobs
[1]+  Stopped                 thunderbird

Podemos arrancarlo de nuevo pero en segundo plano:

$ bg %1
[1]+ thunderbird &

O en primer plano:

$ fg %1

Recordad que es interesante revisar la ayuda (páginas man y –help) de los comandos para obtener información sobre su utilización y las posibilidades que nos ofrece.

También te puede interesar:

• Automatizar tareas FTP dentro de un script en BASH
• Colección definitiva de chuletas Linux-Unix
• Diferencias entre soft (symbolic) y hard links
• Permisos especiales (setuid, setgid, sticky bit)

Lo primero que tenemos que comprobar es que tengamos instalados los compiladores necesarios (C / C++…) para poder empezar a trabajar, en RHEL y CentOS podemos instalarlos por yum, y en Debian y similar por apt:

# yum install gcc gcc-c++ autoconf make automake

Compilar Apache

Para compilar Apache lo primero que debemos hacer es bajarnos las fuentes de la versión que queramos instalar. En este caso vamos a bajar la última versión estable de la rama 2.2, la 2.2.17:

# wget http://apache.rediris.es//httpd/httpd-2.2.17.tar.gz

Descomprimimos (podéis hacerlo en el directorio /usr/src/ destinado a las fuentes o en donde más rabia os dé):

#  tar -xzvf httpd-2.2.17.tar.gz

Nos ubicamos en la ruta donde hayamos descomprimido las fuentes:

# cd /usr/src/httpd-2.2.17

Ya estamos listos para comenzar a configurar nuestra instalación. El primer paso de toda compilación es el script configure, básicamente es el momento en el que podemos personalizar como queramos nuestra instalación (lugar donde instalar apache, módulos a compilar, cómo cargar esos módulos, etc) también se realizan ciertos chequeos para verificar que la compilación se puede realizar correctamente.

Para ver todas las posibilidades que nos ofrece la configuración, siempre tendremos que ejecutar la ayuda, resultaría tedioso explicar aquí todas las opciones de compilación así que nos vamos a centrar en una instalación básica, para personalizar vuestras instalaciones:

# ./configure --help

Bien, en nuestro caso la línea de configure va a ser la siguiente:

# ./configure --prefix=/usr/local/apache --enable-headers --enable-rewrite --enable-expires --enable-so --disable-authz-default

• –prefix=<ruta> será la ruta en la que vamos a instalar Apache, en este caso /usr/local/apache.
• –enable-MODULO: para la activación de módulos utilizamos este parámetro. En la línea de configuración vemos que hemos activado mod_rewrite, mod_headers y mod_expires. Si no especificamos nada, los módulos se cargan de forma estática, para cargarlos de forma dinámica (DSO, explicado en el siguiente punto) utilizamos –enable-MODULO=shared.
• –enable-so Permitimos a Apache cargar módulos compartidos (Dynamic Shared Object (DSO)), php será uno de ellos. Esta opción también nos permitirá añadir nuevos módulos sin necesidad de recompilar y de forma dinámica (añadiendo simplemente el módulo mediante “Load Module” en la configuración). Los modulos que añadamos a través de esta línea de compilación, y sin especificar shared se instalarán de forma estática.
• –disable-MODULO: He puesto un ejemplo de deshabilitar un módulo en la línea de compilación para que veáis que se pueden deshabilitar módulos (por defecto Apache carga algunos módulos que quizás no te interesen), en el ejemplo desactivamos authz-default

Una vez que tengamos claro que queremos y que no queremos instalar, podemos construir nuestra compilación, para ello simplemente ejecutamos make (según la cantidad de módulos que hayas configurado le puede costar un rato, puedes ir a tomar un café mientras ;) ):

# make

Y una vez que haya terminado, finalizamos la compilación e instalamos apache:

# make install

Cuando haya terminado ya podemos probar nuestra instalación de apache, lo arrancamos:

# /usr/local/apache/bin/apachectl start

Si accedemos vía web, por ejemplo desde la IP del servidor o el host que tenga configurado, deberíamos visualizar lo siguiente:

It works!

Cómo actualizar Apache

La actualización por compilación de fuentes es bastante sencilla. Simplemente tendríamos que seguir este mismo proceso, pero en el punto del configure apache nos lo pone más fácil. En la ruta /usr/local/apache/build encontraréis un fichero llamado config.nice que guarda vuestros parámetros de compilación, con lo que podéis usar dicho fichero en lugar de crear un nuevo configure. El proceso sería entonces, bajar las fuentes de la nueva versión y:

# ./config.nice
# make
# make install

Nota: Los ficheros de configuración, logs y documentos no se sobreescribirán durante la actualización.

Compilar PHP

Ahora que ya tenemos Apache funcionando, es hora de instalar PHP. Vamos a seguir el mismo procedimiento que para compilar Apache. En este caso vamos a instalar PHP con soporte para MySQL y algún otro módulo que veremos más adelante.

Empezamos descargando las fuentes desde el sitio web de PHP. En este caso la última versión estable de la rama 5.3, la 5.3.6. De nuevo nos colocamos en el directorio src o donde queráis trabajar mientras instalamos:

# cd /usr/sr
# wget http://es2.php.net/get/php-5.3.6.tar.gz/from/es.php.net/mirror

Descomprimimos y nos colocamos dentro del directorio:

# tar -xzvf php-5.3.6.tar.gz
# cd php-5.3.6

Ahora, al igual que con Apache llega el momento de crear la línea de configuración, el configure. Del mismo modo podemos seleccionar la ruta de instalación, los módulos y una buena cantidad de parámetros para personalizar nuestra instalación. Es imprescindible pues revisar la ayuda:

# ./configure --help

Una vez que tenemos claro que y como queremos instalar, comenzamos con el configure:

# ./configure --prefix=/usr/local/php --with-config-file-path=/usr/local/php --with-apxs2=/usr/local/apache/bin/apxs --with-mysql --enable-ftp --disable-pdo --disable-ctype

Pasamos a explicar esta línea de configure:

• –prefix: al igual que con Apache especificamos la ruta en la que instalaremos php.
• –with-config-file-path: especificamos la ruta donde se encontrará el fichero de configuración php.ini.
• –with-apxs2: como vamos a compilar php como módulo dinámico (DSO) updatede apache especificamos la ruta a apxs.
• –with-libxml2: para evitar el error provocado porque la compilación no encuentra xml2-config necesitaremos tener instalado libxml2-devel (yum install libxml2-devel. El error es configure: error: xml2-config not found. Please check your libxml2 installation.
• –with-mysql: habilitamos soporte para MySQL. Por supuesto, antes de habilitar cualquier extensión, si depende de algún programa hay que instalarlo antes, en este caso el cliente MySQL y las headers (paquete devel):

  yum install mysql mysql-devel

• –enable-ftp: habilitamos soporte para FTP. Podemos habilitar cualquier otro módulo con –enable-MODULO
• –disable-pdo: deshabilitamos el soporte para PDO. Podemos deshabilitar cualquier otro módulo con –disable-MODULO

Una vez seleccionados los módulos a instalar y las opciones correspondientes podemos comenzar a compilar (puede tardar un rato):

# make

Si todo ha ido bien y no hemos recibido errores podemos finalizar la instalación:

# make install

Una vez instalado automáticamente habrá añadido la carga del módulo en nuestra configuración de apache (fichero httpd.conf):

LoadModule php5_module modules/libphp5.so

Ahora solo nos queda indicar a Apache como tiene que interpretar los ficheros php, tenemos que añadir la siguiente línea dentro del fichero httpd.conf. Podemos añadirla junto a los demás AddType, buscadlos y colocadla debajo:

AddType application/x-httpd-php .php

Ahora solo queda reiniciar apache y verificar el funcionamiento de php. Antes comprobamos que la sintaxis del fichero de configuración httpd.conf es correcta:

# /usr/local/apache/bin/apachectl configtest
Syntax OK

Reiniciamos apache:

# /usr/local/apache/bin/apachectl restart

Podemos crear un fichero de pruebas en php para verificar todos los parámetros y módulos de la instalación de php, el contenido es el siguiente:

<? phpinfo(); ?>

Lo colocamos en el DocumentRoot por defecto, en nuestro caso es /usr/local/apache/htdocs y lo ejecutamos desde el navegador, el resultado es el siguiente, ya tenemos Apache y php operativo:

También te puede interesar:

• pecl: configure: error: cannot run C compiled programs
• configure: error: libpng.(a|so) not found (compilando PHP con 64 bits)
• Activar pcntl para PHP en cPanel (easyapache)
• suPHP: “Premature end of script headers” en el error_log

• standard input (stdin)
• standard output (stdout)
• standard error (stderr)

Vamos a explicar los usos que podemos dar estos tres canales para enviar y recoger los datos que surgen de la ejecución de un script, comando o aplicación.

standard input (stdin)

Stdin, o standard input son los datos que son enviados al programa, quizás cara al usuario de terminal sea el menos utilizado ya que lo normal suele ser interpretar los datos que el programa o comando envía, y no al revés. Normalmente stdin es texto enviado por el usuario, vamos a ver un ejemplo.

En un script en perl, podemos solicitar la interacción del usuario mediante STDIN, por ejemplo en este caso recogemos mediante STDIN el valor de dos variables que el usuario escribe:

#!/usr/bin/perl
print "Introduce tu nombre:\n";
my $nombre = <STDIN>;
print "Introduce tu apellido:\n";
my $apellido = <STDIN>;

Otro ejemplo que se me ocurre es el que puse en la entrada de automatizar comandos FTP, en este caso a la conexión FTP le pasamos de antemano los comandos a ejecutar:

ftp -inv direccion_ip<<FINFTP
comando1
comando2
comando3
FINFTP

standard output (stdout)

A través de la salida estándar, “stdout” se reciben los datos que vuelca el comando o programa durante su ejecución, ejemplos sencillos de stdout serían por ejemplo el resultado de un “ls”,”cat” o cualquier otro comando de terminal. En cambio, hay otros comandos o programas que no muestran salida (a no ser que se especifique), como por ejemplo mover o copiar ficheros. Como ya sabemos cualquiera de estos flujos de datos se puede manipular, vamos a ver un ejemplo  para comprender sus posibilidades.

Si hicieramos un “ls” a una carpeta, la salida de datos (stdout) se muestra en nuestra terminal:

$ ls
backups  cpq    games  local  log   opt  spool  www
cache    crash  lib    lock   mail  run  tmp

Para manipular la salida estándar, utilizaremos el símbolo “>”. Si por ejemplo quisieramos que stdout fuera redirigido a un fichero de texto, haríamos así:

$ ls > fichero.txt

Como podréis comprobar, por pantalla no aparece el resultado del comando, sino que se ha almacenado en el fichero indicado:

$ cat fichero.txt
backups  cpq    games  local  log   opt  spool  www
cache    crash  lib    lock   mail  run  tmp

standard error (stderr)

A través del canal stderr los programas o comandos suelen enviar el informe de error de la ejecución de un comando en caso de fallar. En nuestros scripts o comandos podemos combinar el uso de stdout y stderr para separar la salida estándar de los errores, almacenarlos en registros independientes o manipularlos por separado.

En el siguiente ejemplo vamos a ejecutar un “ls” con parámetros incorrectos, por defecto la salida de errores se volcará en pantalla (terminal):

$ ls -7
ls: opción incorrecta -- '7'
Pruebe `ls --help' para más información.

Si quisieramos almacenar los errores de la ejecución del comando en caso de suceder, podemos volcarlos usando en lugar del símbolo “>” el número 2 seguido de “>”, “2>”:

$ ls -7 2> errores.log

Como podéis ver los errores ya no aparecen por pantalla, pero si abrimos el fichero de log tenemos el registro del fallo:

$ cat errores.log
ls: opción incorrecta -- '7'
Pruebe `ls --help' para más información.

Si quisieramos redirigir tanto el stdout como stderr al mismo sitio, en lugar de especificar dos veces el destino podemos hacerlo del siguiente modo “2>&1″. Vamos a ver un ejemplo

Stdout y stderr a un fichero de log:

$ ls -3 > fichero.log 2>&1

Vamos a ver un ejemplo práctico de mysql. El comando mysqldump vuelca a stdout el dump de una base de datos, seguro que nos es más útil en un fichero que por pantalla, así mismo, si surge algún error nos conviene revisarlo así que lo volcamos a otro fichero distinto de log:

$ mysqldump test > test.sql 2> error.log

Otra opción es querer que tanto stdout como stderr vayan directamente a la basura (/dev/null):

$ ls -l > /dev/null 2>&1

Este es el uso más básico que podemos dar a estos tres importantes flujos estandar Unix, si tenéis cualquier duda podéis consultarla a través de los comentarios.

También te puede interesar:

• Diferencias entre soft (symbolic) y hard links
• Permisos especiales (setuid, setgid, sticky bit)
• Gestión de trabajos en BASH (jobs, fg, bg, &…)
• Automatizar tareas FTP dentro de un script en BASH