Hace un tiempo vimos como establecer la caducidad de claves en Linux con el comando passwd. Hoy vamos a aprender otra forma de hacerlo, en este caso con el comando chage, con el que además podemos especificar la caducidad de la cuenta de un usuario concreto, no sólo de su clave.

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

Hace ya casi un par de años vimos en una entrada cómo crear un Linux Logical Volume Manager (LVM) usando fdisk. En ese post cubrimos la primera parte necesaria para gestionar volúmenes lógicos en GNU/Linux además de hacer una introducción a LVM.

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.

Me ha parecido curioso este emulador que he encontrado en nixCraft, hecho en Javascript, que permite arrancar un kernel Linux directamente en el navegador. Pinchad en la imagen para acceder al sitio web:

Hoy vamos a tratar de comprender las diferencias que existen en Unix / Linux entre los enlaces simbólicos (soft o symbolic links) y los enlaces duros (hard links).

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.

En Unix existen tres bits de permisos especiales que pueden ser asignados a directorios y/o ficheros ejecutables, setuid (set user information), setgid (set group information) y sticky.

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.

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.

El comando nice en Linux nos permite modificar la prioridad de un proceso frente al resto dentro del sistema. El kernel Linux es el encargado de planificar y asignar tiempo de CPU a cada uno de los procesos que corren en el sistema. El rango de asignación de prioridad disponible es de -20 a 20 , siendo -20 la mayor prioridad y 20 la menor. Gracias a nice podemos asegurarnos que en momentos de usos elevados de CPU los procesos adecuados reciban el mayor % de la misma.

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

Hoy vamos a ver el modo de gestionar trabajos, procesos o aplicaciones que corren dentro de un sistema Linux/Unix. El objetivo es aprender a poner un proceso que se está ejecutando en segundo plano, suspenderlo, volver a ponerlo en primer plano, reactivarlo, etc.

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.