Usos de Git

Utilizaremos como estándar de documentación:
# para referirnos a superusuario (root)
$ para referirnos a un usuario

Generar un patch con Git
$ git format-patch rev
rev: es la revisión desde la cual comenzará el patch.

Suspender a disco

La idea es que al apagar el equipo en el cual estamos trabajando y lo prendamos nuevamente, el mismo quede exactamente en el mismo punto en el cual lo dejamos cuando lo apagamos. De este modo, nos ahorramos, por ej.: loguearnos, iniciar el navegador con las urls consultadas, lanzar las consolas, etc. muy práctico!, aunque nada seguro si otros usuarios tienen acceso al equipo.

Utilizaremos como estándar de documentación:
# para referirnos a superusuario (root)
$ para referirnos a un usuario

1. Establecer una partición/archivo/algo para swap.

2. Instalar paquetes necesarios:

#apt-get install uswsusp 

NOTA: Esta parte puede hacerse más fácilmente con dpkg-reconfigure uswsusp

3. Configuración del archivo

# vi /etc/uswsusp.conf

resume device = /dev/sda5          #Partición swap
compute checksum = y
compress = y
early writeout = y
image size = 484036935             #Al menos, el tamano de la ram.
#RSA key file = /etc/uswsusp.key   #En mi caso, deshabilité la encriptación porque mi filesystem es encriptado
shutdown method = platform

Acelerando el arranque del sistema con RUNIT

Runit es un esquema de servicios supervisados. A diferencia de Sysvinit, runit permite la supervisión de servicios, y en caso de que alguno de ellos caiga, Runit tratará de levantarlo.

Utilizaremos como estándar de documentación:
# para referirnos a superusuario (root)
$ para referirnos a un usuario

1. Instalación de paquetes:

#apt-get install runit-services runit-run runit

Crear configuración de servicio a supervisar

Para que Runit monitoree y supervise un servicio, necesita algunos scripts y links particulares que se encuentran en el directorio /etc/sv (para la distribución STABLE). En caso que no exista la entrada del servicio a supervisar, crearla siguiendo estos pasos:

Suponiendo que "SERVICIO" es el daemon que se quiere instalar.

1. Crear directorio donde se encontrará la configuración de servicios a supervisiar y levantar por Runit.

# mkdir /etc/sv/${SERVICIO}/

# mkdir /etc/sv/${SERVICIO}/log

2. Creo directorio para logs de "mi_servicio"

# mkdir /var/log/${SERVICIO}

3. Creo script que se encarga de lanzar "mi_servicio"

# vi /etc/sv/${SERVICIO}/run

#!/bin/sh

exec 2>&1
# FIXME: poner el nombre adecuado del servicio a lanzar.
# verificar que los parametros que se pasan son adecuados, de acuerdo al init.d
# original.

exec servicio 


4. Creo un ejecutable que se encarga de loguear mi_servicio

#!/bin/sh
set -e

# FIXME: Poner el nombre del servicio adecuado
# Tambien verificar si los logs estaran centralizados
SERVICIO=

LOG=/var/log/${SERVICIO}

test -d "$LOG" || mkdir -p -m0750 "$LOG" && chown log:adm "$LOG"

exec chpst -ulog:adm svlogd -tt "$LOG"

5. Hago los archivos, ejecutables.

# chmod +x /etc/sv/${SERVICIO}/run

# chmod +x /etc/sv/${SERVICIO}/log/run

6. Testear ${SERVICIO}

# cd /etc/sv/${SERVICIO}

# ./run

Poner el servicio bajo el monitoreo de Runit ¶

Luego, para poder poner bajo supervisión un servicio, debemos realizar los siguiente pasos:

1. Detener el servicio, utilizando el método tradicional.

/etc/init.d/${SERVICIO} stop

2. Luego debemos realizar un divert del paquete en el que viene el servicio. Esto es para que cuando apt actualize el paquete, no modifique el script.

Esto se realiza de la siguiente manera:

# dpkg-divert --add --rename /etc/init.d/${SERVICIO}

3. Reemplazamos el script de init del servicio por un enlace simbólico a /usr/bin/sv, para lo que previamente se recomienda realizar un backup del mismo.

# cd /etc/init.d/

# ln -s /usr/bin/sv /etc/init.d/${SERVICIO}

4. Le informamos a RunIt del nuevo servicio.

# ln -s /etc/sv/${SERVICIO} /var/service/

y listo, ya deberíamos tener bajo supervisión nuestro servicio.

5. Para poder chequear que efectivamente todo funcione bien, ejecutamos

# sv status ${SERVICIO}

y deberiamos obtener algo como:

run: cron: (pid 19833) 3s

o sino, por medio del viejo método:

# /etc/init.d/${SERVICIO} status

# run: mi_servicio: (pid 19833) 4s

Es importante destacar que no todos los servicios son posible poner bajo supervisión de Runit. Debido a que Runit requiere que el nuevo servicio a supervisar funcione en FOREGROUND, u opcionalmente en modo DEBUG. Aquellos que funcionen únicamente en FOREGROUND no será posible que runit lo supervise.
Cuando un servicio corre en background, el mismo se desprende del terminal, por ejemplo: iceweasel & devolviéndonos el control y uso del terminal nuevamente, en el cual se lanzó anteriormente el navegador. En cambio cuando un servicio corre en foreground, por ejemplo: iceweasel, el terminal sigue teniendo el control del mismo, por lo cual la misma queda inutilizable, salvo por el navegador antes lanzado.

Instalación de Debian con filesystem encriptado (LUKS) en una EeePc

Mi idea es instalar Debian con particiones LVM y con filesystem encriptado (LUKS) en una Eeepc

El instalador destinado a la EeePc es muy reducido y no es posible instalar Luks desde el mismo, aunque permite instalar Debian al modo clásico. Sólo en este caso realizar los sgts. pasos.

Utilizaremos como estándar de documentación:
# para referirnos a superusuario (root)
$ para referirnos a un usuario

1. dd if=debian-eeepc_20080907.img oflag=direct of=/dev/sdb

Saltar al item .5 y llevar adelante una instalación clásica de Debian.

1. Descargar la imagen iso y comprobar su integridad vía md5sum.
http://www.debian.org/devel/debian-installer/

2. Descargar "boot.img.gz" de /debian/dists/lenny/main/installer-i386/current/images/hd-media del mirror que prefieras.

3. Copiar "boot.img.gz" a tu pendrive, donde X es el dispositvo que tu pendrive está utilizando.

# zcat boot.img.gz > /dev/sdX

4. Montar el pendrive y copiar la imágen ISO allí.

5. Colocar el pendrive en el puerto usb izquierdo de la EeePC, configurar Bios para que booteo primero vía USB, reiniciar y esperar...

Aparecerá la interfaz de instalación de Debian!

A continuación es posible generar las particiones LVM y encriptarlas con LUKS, a través del instalador de Debian. En mi caso, hice un particionado clásico y luego configuré LVM con LUKS vía una terminal.

1. Instalar paquetes

   # apt-get install cryptsetup   

   Cryptsetup es una herramienta que facilita el uso de dm-crypt y se encargará de crear los dispositivos de mapeo.

2. Crear en LVM LVs para almacenar los datos encriptados. Si es necesario, crear el/los VGs también.

   # vgcreate crypto /dev/sda2
   

   # lvcreate -n home --size 40g crypto
   

3. Crear el logical volume encriptado

   # cryptsetup luksFormat /dev/mapper/crypto-home
   

4. Abrir el device y mapearlo en el mapper. Mapper es una interfaz uniforme de acceso a los discos.
   

   #cryptsetup luksOpen /dev/mapper/crypto-home home
   

   Cryptofs va a montar la partición desencriptada y se creará una entrada directa en:

   /dev/mapper/home

5. Formatear las particiones

   mkfs.ext3 -L homefs /dev/mapper/home
   

6. Editar el /etc/crypttab (para que cryptosetup los abra al inicio)

   home   /dev/mapper/crypto-home  none luks
   swap   /dev/mapper/crypto-swap  none luks,swap
   

7. Agregar las entradas en el /etc/fstab

   # Cryptofs
   /dev/mapper/home /home           ext3    defaults,noatime        0       2
   /dev/mapper/swap none            swap    sw              0       0
   

8. Agregar los datos necesarios al ramdisk

   update-initramfs -u -k all
   

Sshfs (Ssh filesystem)

Es un sistema de archivos que opera sobre un host remoto, de modo seguro (a través de SSH) y el modulo del kernel local FUSE.
La idea es interactuar con un servidor remoto ssh, pero de modo transparente, es decir, como si estuvieras en la misma máquina.


Configuración inicial

Utilizaremos como estándar de documentación:
# para referirnos a superusuario (root)
$ para referirnos a un usuario


La configuración que sigue a continuación, debe realizarce, en el host en el cual se requiere montar los datos.

1. Paquetes requeridos para Debian.
#apt-get update && apt-get install fuse-utils sshfs;

2. Se crea directorio de montado.
#mkdir /mnt/sshfs

3. Se conceden permisos de acceso al directorio de montado.
3.1 #chown usuario:grupo /mnt/sshfs
3.2 #chmod 755 /mnt/sshfs

usuario es el usuario que desea montar el filesystem.
grupo es el grupo del cual forma parte "usuario" con permisos de montado del filesystem.

4. Agregar usuario al grupo fuse
# adduser usuario fuse

5. Comprobar permisos para fuse. No deberíamos cambiarlos.
$ ls -l /dev/fuse
crw-rw---- 1 root fuse 10, 229 ago 27 17:00 /dev/fuse

Cómo usarlo
1. Para montarlo
$sshfs user@host-remoto:/musica /mnt/sshfs

2. Para desmontarlo
$fusermount -u /mnt/sshfs



Sshs tiene varios parámetros opcionales, los cuales lo hacen bastante nice :)
A saber:
-o reconnect
reconnect to server

-o sshfs_sync
synchronous writes

-o no_readahead
synchronous reads (no speculative readahead)

-o sshfs_debug
print some debugging information

-o cache=YESNO
enable caching {yes,no} (default: yes)

-o cache_timeout=N
sets timeout for caches in seconds (default: 20)

-o cache_X_timeout=N
sets timeout for {stat,dir,link} cache

En mi caso, hice un script lanzado desde mi .xsession, el cual se encarga de montar un directorio de musica desde otra pc. Para el cual me fueron super útiles algunos de los parámetros antes mencionados.

Montar dispositivo USB

Si bien montar dispositivos extraíbles en Debian no tiene mayores complejidades, requiere llevar adelante una serie de pasos hasta lograrlo.

Existen otros métodos más sencillos, como pueden ser: mountd, automount, etc., que se encargan de hacer estas cosas automágicamente, pero lo dejaré para otro post ;)

Linux asigna a cada dispositivo un identificador dentro de los devices (/dev/) que suele ser secuencial para cada uno de su tipo. Los dispositivos USB son identificados en el grupo periféricos SCSI (sd por "SCSI disk") y por lo tanto se ven como /dev/sdXn, donde “X” es la letra que representa el orden de los dispositivos y “n” el numero de partición en dicho dispositivo. En este ejemplo, el device se ve como segundo disco SCSI y por lo tanto lo muestra como "/dev/sdb". A su vez, tiene una sola partición que se ve como "/dev/sdb1".

Utilizaremos como estándar de documentación:
# para referirnos a superusuario (root)
$ para referirnos a un usuario

Para "levantar" un pen-drive, entonces:

1. Conectar físicamente el dispositivo al conector USB.
2. Identificar el nombre de dispositivo el cual reconoce el sistema operativo. Para ésto, nada más práctico que colgarse a un dmesg:

# watch dmesg

En caso de que el sistema operativo no reconozca el dispositivo USB, es posible que falte cargar el modulo "usb_storage" al kernel.

2.1 Comprobar si el modulo está cargado:
# lsmod | grep usb_storage

2.2 En caso de que no esté cargado, hacemos:
# modprobe usb_storage

2.3 Si deseamos que el módulo se cargue siempre en forma forzada al iniciar la PC:
# echo usb_storage > /etc/modules

3. Agregar entrada en el fichero "/etc/fstab". El mismo es leído por el S.O para identificar permisos de montado y tipo de filesystem del mismo.

# echo /dev/sdb1 /media/usb vfat rw,user,noauto 0 0 > /etc/fstab

/dev/sdb es el dispositivo físico identificado por el S.O.
mount /media/usb es el directorio donde se montará el dispositivo extraíble.
vfat es el sistema de archivos FAT32. Puede ser otro.
rw dispositivo accesible en modo de lectura y escritura.
noauto el dispositivo no se montará automáticamente.
user para que un usuario diferente de root lo puede montar.
0 no verificará el sistema de archivos al levantar la PC, con 1 si lo hace. Como el pendrive no siempre estará montado al iniciar la PC, no tiene sentido forzar la verificación.
0 no montará automáticamente el dispositivo al prender la PC. 1 es para que lo haga, pero no tiene sentido para un dispositivo USB removible.

4. Permisos al directorio en el cual se montará la dispositivo.
#chown usuario:grupo /media/usb
#chmod 755 /media/usb

usuario es el usuario permitido para montar dispositvo USB.
grupo es el grupo al cual pertenece el usuario permitido para montar dispositivo USB

5.1 Montar el dispositivo. Como usuario:
$mount /media/usb

5.2 Montar el dispositivo. Como root:
#mount -t vfat /dev/sdb1 /media/usb