Tag Archives: howto

Montando /usr como read-only

El Filesystem Hierarchy Standard es una especificación que define una pautas y requerimentos para la construcción del árbol de directorios que constituye un sistema operativo tipo-UNIX. Algunas distribuciones GNU/Linux se adhieren a este estándar y otras no, los BSD tampoco. Algunos de los puntos pueden ser bastante discutibles, pero tiene aspectos interesantes.

Al principio me sorprendió que uno de los consejos fuera que el directorio /usr tendría que estar en una partición separada y montada como sólo lectura. Pero el objetivo es que /usr pueda ser compartido entre distintos servidores por red. A mi personalmente me parece más interesante pensando en aspectos de seguridad:  ¿quién es el guapo que mete un rootkit en los ejecutables de un sistema de sólo lectura?

Así que decidí montar en mi sistema el directorio /usr como read-only. Esta es la entrada correspondiente en el fichero /etc/fstab, en mi caso la partición correspondiente a /usr es /dev/sda6.

/dev/sda6    /usr    ext4    ro    0    1

Pero esto supone un problema, ¿cómo actualizo el sistema sin permiso de escritura en /usr? Fácil, el sistema puede remontarse (no hace falta desmontar y volver a montar, con el riesgo que esto supondría para la estabilidad), podemos usar mount con el parámetro remount para aplicar cambios en un sistema de ficheros montado. Ejemplos:

# mount /dev/sda6 /usr -o remount,ro
# mount /dev/sda6 /usr -o remount,rw

Lo que yo hice para facilitar las cosas fué añadir estas dos entradas de alias en /root/.bashrc

alias usrro='mount /dev/sda6 /usr -o remount,ro && mount | grep sda6'
alias usrrw='mount /dev/sda6 /usr -o remount,rw && mount | grep sda6'

Ahora puedo usar los comandos usrrw y usrro antes y después de actualizar el sistema. En estos comandos de alias, la parte que hay a partir de && es puramente informativa, así podemos asegurarnos que los cambios se han aplicado correctamente.

Si se diera el caso de que somos unos paranoicos de la seguridad, no estaría nada mal aplicar el mismo cuento a los directorios /bin y /sbin, aunque hacer particiones expresamente para directorios que ocupan tan poco puede parecer un poco ridículo. Quizás la solución sería que estos dos directorios, donde encontramos los comandos básicos del sistema, no estuviesen montados en una partición sinó en un fichero con la opción loop, aunque hay que tener claro que esto es peligroso, si se corrompiera dicho fichero nos quedaríamos con un sistema inusable.

Se aceptan ideas.

Habilitar el reinicio de X.org con ctrl+alt+backspace

xorg_logoUna de las coas que más me ha gustado siempre de X.org (implementación de X Window System) es su capacidad para reiniciarse con una combinación de teclas.

Es un problema típico tener una aplicación colgada que está molestando al resto del sistema, hasta el punto de no poder hacer nada, pero si esta aplicación corre sobre el entorno gráfico y se nos permite usar el teclado podremos reiniciar todo este entorno sin tener que reiniciar todo el sistema operativo, cosa que es de muy agradecer.

Hasta ahora esto era tan simple como hacer Ctrl + Alt + Backspace, pero alguien ha decidido que esto es peligroso y confuso para el usuario. Y a partir de la versión 1.6.0 del servidor X.org esta función ha sido deshabilitada por defecto, con lo que más de uno ha roto el teclado intentando la maldita combinación.

Para volver a la configuración anterior, hay un montón de formas; al igual que hay un montón de formas de arrancar este software (con .xinitrc o con .xsession, con la configuración en /etc/X11/xorg.conf o al vuelo con HAL, etc). Veremos los casos más típicos:

Generalmente, aunque ahora X.org ya soporta el arranque sin archivo de configuración gracias a HAL, la mayoria de los mortales seguimos usando /etc/X11/xorg.conf para definir cómo queremos que se comporte, por lo tanto este es el caso que explicaré. Si queremos recuperar esa funcionalidad (conocidacomo zap o zapping) podemos añadir a xorg.conf las siguientes líneas:

Section "ServerFlags"
    Option  "DontZap" "false"
EndSection

Entonces buscamos la sección InputDevice y añadimos:

Option  "XkbOptions" "terminate:ctrl_alt_bksp"

Ahora, cuando hagamos iniciado Xorg de nuevo, podemos reiniciarlo con la famosa combinación de teclas.

Buscar archivos duplicados en nuestro sistema

Recientemente me he encontrado con el problema de tener un desorden brutal en mis archivos, y la necesidad de encontrar cuáles tengo duplicados y en qué sitios. El problema se complica, y mucho, cuando estamos hablando de un servidor que comparte discos en red y en el que acceden más de 100 usuarios todos los dias. El espacio usado en disco ha crecido rápidamente y tenemos sospechas de que hay cosas repetidas por todas partes… ¿cómo localizar las consecuencias del desorden colectivo?

Solución para BSD, GNU/Linux y otros UNIX

Descargamos la aplicación fdupes, que se autodefine como un programa para identificar o eliminar archivos duplicados que residen en los directorios especificados. Podemos compilarlo nosotros mismos o, como siempre, descargarlo de los repositorios de software de nuestro sistema operativo. El uso es así de simple:

$ fdupes <directorio>

Este comando compara el tamaño de cada archivo, su MD5 y finalmente hace una comparación byte a byte. Podemos añadir el parámetro -d para que nos vaya peguntando si queremos eliminar los repetidos. También tenemos opciones para seguir los directorios symlink e incluso para tratar archivos con hardlink.

Solución para MS Windows

Descargamos la aplicación findrepe, la descomprimimos en el directorio Archivos de Programa y luego, desde línea de comandos ejecutamos:

C:\Archivos de Programa> java -jar findrepe-0.5.1/FindRepe.jar --install

Ahora tenemos instalado el ejecutable findrepe.bat en el directorio de nuestro sistema, esto es sólo un script que llama a la aplicación Java pasándole los parámetros que nosotros deseemos, por esto es importante no eliminar los archivos descomprimidos al finalizar el paso anterior.

Ahora ya podemos usar el programa del siguiente modo:

C:\> findrepe c:\<directorio>

…y nos devolverá una lista de todos los archivos repetidos en dicho directorio. Además podemos pasarle más de un directorio o unidad como parámetros.

Papelera de reciclaje en Samba

Este ha sido uno de mis últimos descubrimientos, Samba (implementación libre de SMB/CIFS para UNIX) puede proporcionar papelera de reciclaje para poder recuperar los archivos después de eliminarlos.

El hecho está en que Samba 3 proporciona un sistema de módulos llamado VFS (Virtual File System) para su servidor de ficheros que amplia sus posibilidades. Uno de esos módulos es recycle, aunque hay otros como audit, default_quota, extd_audit, fake_perms, netatalk y shadow_copy que en general se autoexplican por sus nombres. Además de estos, que vienen incorporadas en el código de Samba, hay módulos de terceros como databasefs, vscan o vscan-clamav. En este artículo sólo voy a comentar como configurar un recurso de red con papelera de reciclaje gracias al módulo recycle.

Vemos un ejemplo simple, en el que los usuarios pueden acceder al recurso compartido DATOS que está situado en /mnt/datos y que contiene una papelera de reciclaje en /mnt/datos/.papelera que se muestra como un directorio oculto tanto desde Windows como desde el servidor Samba.

[DATOS]
  comment = Recurso de Datos
  path = /mnt/datos
  writeable = yes
  vfs object = recycle
    recycle:repository = .papelera

Como vemos, el directorio que va a hacer la función de papelera se define como una ruta relativa al recurso que estamos compartiendo en la red. ¿Pinta bien, eh? Pues se puede mejorar, y mucho.

Por ejemplo si queremos que los archivos eliminados se guarden en su propia estructura de directorios dentro de la papelera, tenemos que añadir:

recycle:keeptree = yes

Si queremos que ciertos tipos de archivo se eliminen directamente sin pasar por la papelera, por ejemplo archivos temporales y de backup que crean las aplicaciones y que en el momento de restaurar no nos van a servir de nada, añadimos:

recycle:exclude = *.tmp,*.bak

En estos momentos los usuarios que entren en la papelera no podrán acceder a los archivos de otros usuarios ya que por defecto todo allí se crea con permisos 700. Si queremos acceso total a la papelera podemos modificar los permisos a nuestro gusto. En el siguiente ejemplo damos acceso total:

recycle:directory_mode = 0777

Si en nuestro sistema acceden muchos usuarios, podemos diferenciar lo que ha eliminado cada uno creando subpapeleras específicas dentro de la papelera principal, esto es muy fácil, sólo tenemos que modificar la linea recycle:repository que hemos visto antes para que ponga:

recycle:repository = .papelera/%U

Esto creará directorios con el nombre de cada usuario dentro de la papelera de reciclaje y así cada uno podrá recuperar sus archivos sabiendo cuáles son los que ha eliminado el. Además hay más opciones todavía, como recycle:versions para que se guarden múltiples versiones de un fichero eliminado varias veces, recycle:maxsize para limitar el tamaño máximo de los archivos que gardamos en la papelera o recycle:exclude_dir para definir en qué directorios no se aplicará ninguna regla de estas.

¿Y si la papelera de reciclaje crece tanto de tamaño que esto termina afectando al espacio libre en el disco del servidor? Pues podemos aplicar una solución bastante simple. Con el uso de cron y find eliminaremos los archivos que lleven en la papelera más de 7 dias. Pero la fecha de los archivos puede que sea anterior al momento en que se movieron a la papelera, por lo que tenemos que añadir una opción final al módulo recycle de Samba:

recycle:touch = yes

Ahora los archivos llevan la fecha y hora del momento en que fueron eliminados, por lo que ya estamos en disposición de eliminar los que llevan más de una semana gracias al comando:

find /mnt/datos/.papelera -mtime +7 -exec rm -f {} \;

Si queremos automatizar este proceso, abrimos el crontab para editar:

# crontab -e

Y añadimos la línea:

00 00 * * * find /mnt/datos/.papelera -mtime +7 -exec rm -f {} \;

Salimos guardando con <ESC>, <:>, <wq>, <ENTER> y a partir de este momento, todos los dias a las doce de la noche se eliminarán los archivos antiguos que se encuentren dentro de la papelera de reciclaje.

Usar cat como editor de texto

Esto lo aprendí la primera vez que instalé LFS y me parece bastante gracioso. cat es un comando clásico de UNIX que sirve para imprimir en pantalla el contenido de un archivo, y podemos usarlo también para concatenar archivos mediante los símbolos > y >>.

¡Pero puede usarse incluso como editor de texto! Creamos un archivo desde cero:

$ cat > /ruta/archivo.txt << "EOF"
Escribimos el texto <enter>
de tantas líneas como <enter>
queramos, y finalmente... <enter>
EOF

Ahora podemos comprobar si ha funcionado:

$ cat /ruta/archivo.txt
Escribimos el texto
de tantas líneas como
queramos, y finalmente...

Vemos que ha funcionado, hemos creado un archivo sin usar un editor de texto. Como aclaración, la palabra EOF significa End Of File, y podríamos usar cualquier otro indicador de fin de archivo, por ejemplo FIN o un punto.

Reiniciar Linux automáticamente en caso de un kernel Panic

Un Kernel Panic es un error del núcleo del sistema operativo (o de uno de sus módulos) que muestra un dump con información de depuración, esto puede ser útil a desarrolladores del sistema operativo para esclarecer las causas del error. Pero a la mayoría de los mortales no les va a servir de nada esa información casi críptica. Además, en caso que la máquina sea un servidor, lo último que queremos es que deje de dar servicio, entonces la solución pasa por programar un reinicio automático en caso de Kernel Panic. Para conseguir esto haremos lo siguiente, abrimos el archivo /etc/sysctl.conf y añadimos la siguiente línea:

kernel.panic = 10

Si ahora nuestro servidor decide morir, resucitará al cabo de 10 segundos, iniciando el arranque desde cero. El problema que esto supone es que podemos tener un servidor en problemas constantes y ni siquiera darnos cuenta.

Una posible solución sería hacer que la máquina envíe un correo electrónico (ver mi anterior arículo Enviar e-mail desde la consola) al administrador avisándole que se ha reiniciado, este correo electrónico puede incluir el contenido de /var/log/messages para entender qué es lo que estaba pasando justo antes del reinicio.

Enviar e-mail desde la consola

Si queremos que nuestro sistema pueda enviar correos electrónicos, debemos asegurarnos de que sendmail o algún otro MTA (Mail Transport Agent) esté configurado. O sea que empezamos ejecutando /etc/init.d/sendmail start, o /etc/rc.d/sendmail start, o service sendmail start, o lo que se corresponda a nuestra distribución GNU/Linux o sistema UNIX que estemos usando. Ahora ya podemos empezar.

Supongamos que estamos delante de una terminal y queremos enviar un mensaje a usuario@dominio.com, la forma más simple es la siguiente, ejecutamos

$ mail usuario@domunio.com

Ahora nos sale lo siguiente:

Subject: Título del mensaje <enter>
Empieza el texto del mensaje, y <enter>
sigue el texto hasta que <enter>
finalmente terminamos y <enter>
escribimos un punto <enter>
. <enter>
Cc: <enter>

Y el mensaje ya se ha enviado a usuario@dominio.com con el título indicado y el mensaje que hemos escrito. Como véis podemos añadir destinatarios adicionales en el campo Cc (Carbon Copy).

Pero, ¿y si queremos mandar un correo sin tener que interactuar en tiempo de envío, por ejemplo para mandar correos desde nuestros propios scripts? Pues todo lo que hemos visto se puede hacer por parámetros:

$ mail -s "Título del mensaje" usuario@dominio.com < /ruta/archivodetexto.txt

En el caso que hemos visto, el texto del mensaje lo recuperamos de un archivo de texto plano ASCII que se llama archivodetexto.txt y se encuentra en /ruta/, pero también podríamos incluir el propio cuerpo del correo en el comando si usamos una tubería:

$ echo "contenido del mensaje" | mail -s "Título del mensaje" usuario@dominio.com usuario4@dominio.com

Además vemos que podemos enviar el mensaje a distintos destinatarios. Pero ¿y si queremos enviar documentos adjuntos? El comando mail, que yo sepa, no puede hacerlo. Para ello podemos recurrir a mutt, un cliente de correo electrónico muy capaz y que posee una interface TUI (Text User Interface). Sin aprofundir en las capacidades de mutt, que son muchas, en este caso podríamos hacer lo siguiente:

$ mutt -s "Título del mensaje" -a /ruta/documento.pdf usuario@dominio.com < /ruta/archivodetexto.txt

En este caso, el usuario que posee el correo electrónico usuario@dominio.com recibirá un correo titulado “Título del mensaje”, el texto de este correo será el contenido de archivodetexto.txt, y se incluirá un PDF, documendo.pdf como archivo adjunto.

Voilà.

Seguimiento de un proceso con watch

Me parece increíble descubrir un comando tan útil y sencillo como watch a estas alturas. Y me pregunto seriamente: ¿cómo es posible que haya estado usando sistemas tipo UNIX durante 4 o 5 años sin conocerlo?

El comando watch ejecuta repetidamente el comando que le pasemos por parámetro, mostrando su salida en pantalla (salida estándar).

Esta mañana he estado moviendo archivos entre servidores, hablamos de mucha información, gigas y gigas. El servidor origen se ha quedado obsoleto y con el disco lleno, el servidor destino tiene 4 discos de 300 GB. Pero al pasar información, puedes llenar un disco sin darte cuenta, por lo que yo estaba ejecutando repetidamente

$ df -h

o más bien [flecha arriba + intro] hasta que watch se ha crucado en mi camino. Entonces he descubiertoque escribiendo

$ watch df -h

se nos muestra esta información (la salida de df -h) por pantalla:

Every 2,0s: df -h             Mon Jan  5 11:21:06 2009

S.ficheros          Tamao Usado  Disp Uso% Montado en
/dev/hda1              15G  2,8G   11G  21% /
/dev/hda3             274G  104G  156G  40% /mnt/disc1
/dev/hdb1             294G  191M  279G   1% /mnt/disc2
/dev/hdc1             294G  191M  279G   1% /mnt/disc3
/dev/hdd1             294G  191M  279G   1% /mnt/disc4
tmpfs                 379M     0  379M   0% /dev/shm

Por defecto se ejecuta cada 2 segundos, pero esto puede modificarse con el parámetro -n:

$ watch -n <número de segundos> <comando a ejecutar>

Otro parámetro curioso es -d, que remarca visualmente las modificaciones (con negrita o color de fondo) para que el seguimiento sea mas fácil.

Extraer parte de un archivo tar

Llevo años usando TAR (junto con Gzip o con Bzip2) para empaquetar y comprimir directorios, pero de repente empiezo a usarlo para crear copias de seguridad de forma manual y me doy cuenta de que no sé como extraer sólo parte de los archivos que he empaquetado.

No escribiré aquí como comprimir y descomprimir en *.tar.gz o en *.tar.bz2 (aunque tampoco tiene mucho secreto). Supongamos que tenemos esta estructura de directorios y archivos:

directorio/
|-- subdirectorio-1
|   |-- archivo-11.txt
|   `-- archivo-12.dat
|-- subdirectorio-2
|   `-- archivo-20.ogg
`-- subdirectorio-3

Hemos creado un archivo TAR que contiene este árbol, y lo hemos guardado con el nombre directorio.tar, Posteriormente queremos mostrar el contenido de ese archivo *.tar, lo hacemos de la siguiente forma:

$ tar tvf directorio.tar
drwxr-xr-x usuario/grupo   0 2008-12-05 16:51 directorio/
drwxr-xr-x usuario/grupo   0 2008-12-05 16:51 directorio/subdirectorio-3/
drwxr-xr-x usuario/grupo   0 2008-12-05 16:52 directorio/subdirectorio-1/
-rw-r--r-- usuario/grupo   0 2008-12-05 16:51 directorio/subdirectorio-1/archivo-11.txt
-rw-r--r-- usuario/grupo   0 2008-12-05 16:51 directorio/subdirectorio-1/archivo-12.dat
drwxr-xr-x usuario/grupo   0 2008-12-05 16:52 directorio/subdirectorio-2/
-rw-r--r-- usuario/grupo   0 2008-12-05 16:52 directorio/subdirectorio-2/archivo-20.ogg

Y finalmente, si lo que queremos realmente es extraer sólo uno de los subdirectorios, haremos lo siguiente:

$ tar xvf directorio.tar directorio/subdirectorio-1
directorio/subdirectorio-1/
directorio/subdirectorio-1/archivo-11.txt
directorio/subdirectorio-1/archivo-12.dat

En este caso hemos extraido un subdirectorio entero, pero podemos extraer archivos concretos, además podemos usar wildcards como * o ? en el comando.

¿Y que pasa con los archivos comprimidos con Gzip o con Bzip2? Pues los comandos son prácticamente los mismos, sólo tenemos que añadir la letra z en caso de *.tar.gz o la letra j en el caso de *.tar.bz2.

Trucos básicos usando el editor Vim

vim logoPersonalmente uso kate o kwrite como editor simple, para tomar pequeñas notas, etc. Pero para programar o editar ficheros de configuración del sistema no dudo en usar VIM. No voy a profundizar en el uso de este editor, si no te suena de nada el nombre probablemente este artículo no te interese en absoluto. El hecho es que VIM, o cualquiera de los clones de vi, es un editor muy potente. Al contario de lo que parece a simple vista.

Mucha gente usa vi sólo cuando es estrictamente necesario, y de hecho es comprensible, tener un editor que funcione en modo texto puede ser de mucha utilidad si no funciona el entorno gráfico, o si editas ficheros de otro ordenador remotamente. Este artículo va destinado a aquella gente que ya usa VIM, pero no se ha leido la documentación ni la ayuda. Quiero insistir en que esto que voy a describir es MUY BÁSICO, este editor puede hacer muchísimo más. Avisados estáis… empezamos:

Cambiar de modo

Pulsando la tecla <i> entramos en el modo de inserción (para editar el texto), pulsando la tecla <ESC> entramos en el modo comandos, si estando en modo comandos escrivimos <:> (dos puntos), entramos en el modo línea de comandos de VIM, en él podemos hacer cosas más complejas.

Guardar, Salir, etc

Vamos a guardar el archivo:

:w

Como véis, la orden empieza por <:>, por lo tanto, primero hemos pulsado <ESC> para entrar en modo comandos. Si queremos darle otro nombre al archivo:

:w nuevo_nombre.txt

Para salir del editor:

:q

Si hemos hecho cambios no nos deja salir, aquí tenemos dos opciones, la primera es salir sin guardar:

:q!

La segunda es guardar, antes lo hemos hecho con <:w>, pero podríamos guardar y salir en un solo comando:

:wq

E incluso hay otro comando que hace lo mismo, pero no sobreescribe el archivo si no hay cambios, este es el más comodo para salir guardando cambios:

 :x 

Borrar en modo comando:

Ahora estamos en modo comando (tecla <ESC>), sin usar los dos puntos <:>. Si queremos eliminar el siguiente carácter debajo del cursor podemos pulsar x, con X eliminaríamos en anterior. Si pulsamos dd eliminamos la línea actual entera. Con dw eliminamos todos los caracteres hasta el final de la palabra actual, si estamos en un espacio en blanco, hemos eliminado la siguiente palabra del texto. ¿Con d3w que hacemos? El propio comando lo dice: delete 3 words. Con 5dd eliminamos 5 líneas enteras. Y por aquí va el asunto, la gracia está en aprender a combinar los comandos entre ellos.

Deshacer:

Si pulsamos la letra u deshacemos lo último que hemos hecho. Si pulsamos u repetidamente vamos retrocediendo. Con U afectaría solo a la línea actual.

Repetir:

Con el carácter . (punto) se repite el último comando realizado, sea cual sea.

Copiar, Cortar y Pegar:

¿He dicho que d elimina? Pues es completamente falso. Todo lo que eliminamos con d, dd, dw, etc se guarda en un buffer. Esto sirve, por ejemplo, para que usemos u para deshacer como acabo de explicar, pero también nos permite pegar el contenido eliminado, lo que popularmente se conoce como Cortar y Pegar. El comando y funciona igual que d, pero a diferencia de este último, guarda el contenido en el buffer sin eliminarlo, por lo que es un qeuivalente al típico Copiar: yy copia la línea actual, yw copia una palabra, 10yy copia un bloque de 5 líneas de texto, etc.

Ahora que hemos puesto información en el buffer, ya sea eliminada con d o copiada con y, sólo tenemos que pulsar p para Pegar.

Buscar cadenas de texto:

Si en modo comando (tecla <ESC>) escribimos:

/palabra

Y pulsamos enter, el editor buscará palabra en el texto y lo marcará para que lo veamos. Con la letra n se repite la búsqueda hacia adelante, con la letra N se repite hacia atrás.

Además, si pulsamos el asterisco * en modo comando en cualquier momento, se remarcarán todas las coincidencias con la palabra actual debajo del cursor.

Para programadores:

La función de autocompletado es quizás la más destacada, todos los IDEs de programación lo soportan, pues VIM también. Empezamos a escribir una función y pulsamos Control + n, se despliega una lista de todas las funciones que empiezan igual.

Otro truco muy útil es el salto hacia adelante y hacia atrás entre bloques de programación. Si nuestro lenguaje define estos bloques con { … } o ( … ) por ejemplo, nos podemos situar encima de un inicio de bloque, el carácter {, luego pulsamos % y nuestro cursor salta directamente hacia el carácter } más cercano. Si volvemos a pulsar % haremos lógicamente el salto hacia atrás.

Si en modo comandos escribimos ! (exclamación), podemos ejecutar comandos de shell dentro de VIM, al terminar la ejecución en shell volvemos al estado de editor.

El comando definitivo:

Espero que este artículo le sea útil a alguien, de todas formas hay un comando que supera a todos los demás. Por eso lo he reservado hasta el final:

:help

Con el comando <:help> entramos en la ayuda de VIM, que consta de un tutorial muy completo, de estos de seguir paso a paso. Esto es la mejor forma de aprender a usar este magnífico editor de texto.