El mundo en bits: trucos

Mostrando entradas con la etiqueta trucos. Mostrar todas las entradas

Mostrando entradas con la etiqueta trucos. Mostrar todas las entradas

Bash: Control de errores y debug

Recientemente hablamos acerca de las diferencias de usar /bin/bash o /usr/bin/env bash. No suele ser algo muy habitual, pero puede resultar de gran ayuda.

Hoy vamos a ver otro de esos pequeños trucos de bash, pero que puede resultar de gran ayuda. Estamos hablando del control de errores y de habilitar el modo debug.

Como suele ser habitual es los script en bash, tras inicializar el entorno, se suele poner el comando 'set -e', abreviatura de 'set -o errexit'.

#!/usr/bin/env bash
set -e

# Código bash a ejecutar...

En caso de que durante la ejecución del script aparezca algún error, inmediatamente detendrá la ejecución del script.

El método antes comentando suele ser útil para scripts de producción, donde se presupone que no van a existir errores y por lo tanto no es necesario saber exactamente lo que pasa. Sin embargo, cuando estamos escribiendo código, sí puede resultar muy útil tener habilitado el modo debug. Para eso, 'set -x' es la solución.

#!/usr/bin/env bash
set -x

# Código bash a ejecutar...

Nota: 'set -x' en el script es lo mismo que 'bash -x tu_script'.

/bin/bash vs. /usr/bin/env bash

Cuando estamos programando un script en bash siempre solemos inicializarlo con la línea que indica que es eso, un script en bash. Esta línea a mayores nos indica el path del intérprete. Por norma general, suele ser siempre /bin/bash o /usr/bin/bash. Este "o" es el que puede causarnos algunos problemas. Para evitarlo, podemos emplear el siguiente truco: llamar a la función de enviroment. Es decir, pasamos de comenzar el script típico,

#!/bin/bash

# Código bash a ejecutar...

A usar las variables de entorno, para que sea ésta la que localice el path exacto donde está bash.

#!/usr/bin/env bash

# Código bash a ejecutar...

Con esto lo que conseguimos es hacer el script más flexible y adaptable a otros entornos donde quizás bash no esté en la misma ruta.

Backups incrementales con tar

Sí, es cierto, hacía tiempo que no escribía nada en el blog y eso no puede ser. Después de un tiempo de parón, espero volver a ser más constante en las entradas.

En este caso, vamos a ver un método de hacer un backup incremental, pero sin ningún software adicional, sino empleando el comando tar.

La importancia de realizar backups no hace falta que la comente, pues es un tema muy sabido por todos. El método típico de hacer backup con tar, es comprimir todos los ficheros que así desees en un contenedor y darle un nombre, por ejemplo, una fecha. Si todos los finales de día lo hacemos, tenemos un backup bastante consistente y ante posibles fallos. El único problema, que ocupará mucho espacio! Para resolver este problema está el backup incremental y tar, como no podía ser de otra manera, también lo soporta. A continuación, dejo un ejemplo de cómo se debería de emplear tar para la realización de un backup incremental.

Crear el entorno de pruebas

shell> mkdir -p test/aa test/bb test/cc
shell> touch test/aa/a test/bb/b test/cc/c

Realizar el primer backup
Importante aquí, la opción que le pasamos --listed-incremental file.
```
shell> tar --listed-incremental test.metadata \
           -czf test.tar.gz test
```

Borrar y cambiar ficheros

shell> rm test/aa/a
shell> touch test/aa/aa
shell> echo "hola" > test/bb/b

Volver a lanzar el backup incremental
Cada incremental lo vamos añadiendo a un nuevo contenedor.
```
shell> tar --listed-incremental test.metadata \
           -czf test.inc1.tar.gz test
```

Restaurar ficheros
Para ello, necesitamos el fichero de backup completo y también los incrementales

shell> mkdir restore
shell> tar xzf test.tar.gz -C restore
shell> tar --incremental \
           -xzf test.inc1.tar.gz -C restore

Como podemos apreciar que ha añadido el fichero creado pero también borrado el fichero eliminado en el momento de hacer el incremental. Espero que os haya resultado útil.

Como ya sabréis, realizar backups al mismo disco no es una buena idea, por lo que si no lo conoces, te recomiendo la lectura del tag bacula, que quizás te ayude a tener un backup más seguro.

Grabación de sesiones de consola

No fui el primero, ni seré el último en preguntarse cómo grabar todo lo que estás haciendo en la consola de tu equipo Linux, par a continuación poder dejarlo a libre disposición.
hasta que conocí el software del que os voy a hablar hoy, la forma que tenía de hacerlo no era más que la de grabar toda la pantalla (o una región) y dejar luego el vídeo, por ejemplo en Youtube.
Pues bien, ahora ya no podrás decir que no conoces ttyrec, con el que podrás grabar todo el comportamiento de tu consola de una forma más limpia y rápida.

Instalación

ttyrec está disponible en prácticamente todos los repositorios oficiales de las principales distribuciones, así que para instalarlo,

shell> apt-get install ttyrec

Grabar

Comenzar una nueva sesión o grabación es muy sencillo. Únicamente tendremos que saber el nombre que le vamos a querer dar y a continuación,

shell> ttyrec -a git_usage.tty

Para pararla, emplearemos Control + c.

Reproducir

Una vez tengamos la grabación finalizada, tendremos un fichero que podemos reproducir las veces que queramos, únicamente tendremos que tener instalado ttyplay, que viene con el paquete ttyrec.

shell> ttyplay git_usage.tty

Por suerte, este tipo de ficheros, al almacenar texto plano ocupan muy poco, por lo que pasárselos a alguien es sencillo y no debería de darnos problema. De todas formas existen webs, como playterm.org que nos permiten subir el fichero e incrustarlo en una web o dejarlo público.

Referencias

Opciones de privacidad en Firefox

Hoy os quiero enseñar unos pequeños trucos para Firefox que nos permitirán gestionar un poco mejor nuestra privacidad en Internet. Aunque vas a dejar rastro por donde pases, cuanto menos dejes mejor. Si eres usuario de Firefox esta es tu entrada y si conoces a alguien que lo sea, comparte la entrada.

Por supuesto, todo lo que vamos a ver se gestiona desde las variables de configuración, y para acceder a ellas nada mejor que visitar about:config. Aparecerá un aviso como el que sigue, pero no os asustéis, no sois manazas ;-)

Cuando hayáis accedido, tener presente que vamos a hablar mucho acerca de variables, por lo que fijaros que en la parte de arriba hay un buscador que os simplificará la vida. Así que vamos a ello.

Desactivar restauración de sesión
Una de las cosas más peligrosas que tiene el navegador es que está guardando la sesión cada 10 segundos aproximadamente. Aparte de la carga de I/O que supone, también implica que en caso de que el ordenador se reinicie y no seas tú el que vuelva a abrir el navegador, éste restaurará tu sesión, pestañas, cookies, etc.

Puesto que no nos interesa que nadie sepa dónde anduvimos navegando ni entre en nuestro correo, lo desactivamos estableciendo a false la variable
```
browser.sessionstore.resume_from_crash
```
Eliminar useragent
Todos los navegadores dejan una huella en todos los servidores identificándose y dando información que no tienen por qué dejar. Para evitarlo, editamos (o creamos la variable)
```
general.useragent.override
```
Y establecemos el valor que más nos guste para dejar nuestra "huella" en la web.
Desactivar autocompletado de URLs
No queremos que el navegador nos ayude a "recordar" las páginas que hemos visitado, por razones obvias de privacidad, así que desactivamos (valor false) el autocompletado de URLs.
```
browser.urlbar.autofill
browser.urlbar.autofill.typed
```
Desactivar autocompletado de búsquedas
Cuando buscamos, todo esto se queda almacenado en el navegador y cuando comenzamos a escribir una nueva búsqueda no autocompleta con cosas que ya hemos buscado. Puesto que no nos interesa que nadie sepa lo que buscamos, establecemos el valor -1 a la variable,
```
browser.urlbar.maxRichResults
```

Recuperar contraseña de root

Aunque es una práctica que únicamente hay que llevar a cabo en casos extremos, hoy voy a explicar de forma sencilla cómo poder resetear la contraseña de root de prácticamente cualquier distribución GNU/Linux con tener únicamente acceso directo al equipo físico.

Lo primero es reiniciar la máquina y esperar a que salga el Grub. En cuanto lo tengamos delante, nos movemos para que no arranque con la opción por defecto, ya que vamos a querer introducirle una opción para que nos permita trabajar. Para hacerlo, únicamente debemos de presionar la tecla "e" sobre la línea del sistema que vayamos a arrancar. A continuación posicionarnos sobre la línea que pone algo referente al kernel y volver a presionar "e". Ahí ya nos dejará modificar la línea de arranque del sistema, con lo que podemos hacer cosas.

Lo primero es borrar las palabras quiet y splash (si aparecen) y añadir lo siguiente,

init=/bin/bash

Quedando la línea como se muestra en la siguiente imagen, en capas los pasos que se han mencionado. Ahora ya estamos listos para arrancar el sistema, así que únicamente presionamos ENTER y a continuación "b".

Esto nos llevará a una shell básica del sistema GNU/Linux en la que tendremos a nuestra disposición pocos comandos, pero en realidad los necesarios. Si os dais cuenta, tenemos una shell como root, pero sin que nos haya pedido la contraseña, en un sistema de sólo lectura, eso sí.

Como bien hemos dicho, no hay posibilidad de escritura, así que vamos a conseguirla, para ello,

shell> mount -o remount,rw /

Nota: Si el sistema al que estáis accediendo tiene la carpeta /etc en una partición diferente a /, hay que efectuar la misma operación sobre /etc.

Ahora ya sólo nos queda cambiar la contraseña del usuario que nos interese, en este caso, root. Para ello, simplemente ejecutamos passwd y metemos la nueva contraseña. Contraseña que esta vez evitaremos olvidarnos.

Una vez finalizado todo el proceso, ejecutamos sync y tras ello reiniciamos la máquina. El comando reboot no está disponible, por lo que podemos hacerlo presionando Control + Alt + Supr.

Postfix con restricción de dominios salientes

Aunque en la mayoría de los casos cuando montamos un servidor de correo es para que éste pueda enviar correos a todo el mundo, es cierto que nunca está demás delimitar en ciertos equipos aquellos dominios a los que mandar información.

Dicho de otra forma, si estás manejando equipos, pongámosle en una DMZ, y quieres que todos ellos envíen mails a cualquier lado, la mejor solución es poner en todos tu servidor principal como relay. Así todos los correos que salgan de la red pasarán por un mismo punto y desde ahí los podrás controlar.

Si esta idea te parece compleja, pero quieres aun así controlar "un poco" aquello que puede salir por correo de tus equipos, entonces una forma de hacerlo es configurar un pequeño transport especialmente diseñado para que únicamente deje enviar correos a determinados dominios, descartando el resto de forma automática.

Para ello, lo primero es crear el fichero /etc/postfix/transport con el siguiente contenido:

net.domain.com         :
domai.com              :
example.com            :
*              discard :

Y a continuación crear el correspondiente .db con postmap, tal que así:

shell> postmap /etc/postfix/transport

Y ya por último, añadir esta nueva configuración al servidor postfix (/etc/postfix/main.cf) y hacer un restart del mismo.

transport_maps = hash:/etc/postfix/transport

Si todo fue correcto, todos aquellos correos que lleven de destino un dominio diferente al de los aceptados, tendrán un discard automático.

shell> tail -f /var/log/mail.log
Jun 07 18:37:08 server postfix/discard[65384]: AF7634BC35:
to=xyzgmail.com,
relay=none, delay=0.07, delays=0.07/0.01/0/0, dsn=2.0.0, status=sent (gmail.com)

GeoIP desde bash

GeoIP es una base de datos de consulta de localizaciones IP, que dispone de múltiples lenguajes de programación para el acceso a los datos, desde php a python y como no iba a ser menos, también desde la shell de Linux se permiten las preguntas acerca de dónde es una IP concreta.

Lo primero que necesitamos, teniendo en cuenta que partimos de un sistema con geoip-database instalado, es instalar el binario para poder consultar los datos del fichero. Esto nos ofrecerá ya el software que vamos a emplear, geoiplookup y geoiplookup6, por si empleamos IPv6. Tanto la instalación como el uso es bastante sencillo e intuitivo. El paquete está en los repositorios de las principales distribuciones y el uso, simplemente necesitamos la IP de la que deseamos obtener la información.

shell> apt-get install geoip-bin
shell> geoiplookup 77.226.X.Y
GeoIP Country Edition: ES, Spain

Esta base de datos enorme de localizaciones está creada y mantenida por MaxMind, empresa que ofrece una versión "lite" (libre) y otra de pago.
En el caso de Debian Wheezy o la última Ubuntu (14.04), la versión de base de datos que trae es del 2013-08-27. Si por el contrario tenemos una Debian Squeeze, la versión es mucho más antigua, 2010-07-14, por lo que los datos que ahí aparecen pueden no ser del todo correctos. Por lo tanto, antes de ponernos a trabajar, debemos de actualizar las bases de datos. Para ello, recurrimos a la página oficial. Descargamos el fichero GeoLite Country y GeoLite City. El primero para actualizar el que ya tenemos y el segundo, para tener una mayor definición. Tras descargar ambos ficheros, los descomprimimos y los colocamos en el sitio oficial.

shell> cd ~/Descargas
shell> wget http://geolite.maxmind.com/GeoLiteCountry/GeoIP.dat.gz
shell> wget http://geolite.maxmind.com/GeoLiteCity.dat.gz
shell> gunzip GeoIP.dat.gz
shell> gunzip GeoLiteCity.dat.gz
shell> mv ~/Descargas/GeoIP.dat /usr/share/GeoIP/GeoIP.dat
shell> mv ~/Descargas/GeoLiteCity.dat /usr/share/GeoIP/GeoLiteCity.dat

Ahora ya tenemos una base de datos más completa y actualizada. Aunque nos faltarán datos, puesto que no pagamos la suscripción, sí es más moderna que la que trae el paquete.

Si ahora hacemos la misma prueba que antes, pero indicándole que emplee el fichero de localización por ciudad, tenemos lo siguiente,

shell> geoiplookup -f /usr/share/GeoIP/GeoLiteCity.dat 77.226.X.Y
GeoIP City Edition, Rev 1: ES, 58, Galicia, Orense, N/A...

Vemos que esta información ya es mucho más útil. No es lo mismo saber que alguien está en España, que que ese alguien está de Orense.

Aunque la integración con php, páginas web o cms no la voy a comentar, sí es bueno comentar la utilidad práctica de este comando, por ejemplo, para comprobar las IPs que consultan una determinada página web. Leyendo los logs de apache, ante un eventual ataque, podemos saber rápidamente de dónde provienen dichas peticiones. Así que con un poco de magia de scripting, tenemos algo tal que así,

for ip in `cat /var/log/apache/access.log | awk '{print $1}' | sort -n | uniq`
do
   echo -ne "$ip\t"
   geoiplookup -f /usr/share/GeoIP/GeoLiteCity.dat $ip
done

Donde el resultado es similar al que sigue,

222.77.229.X GeoIP City Edition, Rev 1: CN, 22, Beijing, Beijing, N/A...
222.77.242.X GeoIP City Edition, Rev 1: CN, 07, Fujian, Fuzhou, N/A...
222.79.153.X GeoIP City Edition, Rev 1: CN, 07, Fujian, Fuzhou, N/A...
222.87.129.X GeoIP City Edition, Rev 1: CN, 18, Guizhou, Guiyang, N/A...
223.219.152.X GeoIP City Edition, Rev 1: JP, 40, Tokyo, Tokyo, N/A...
223.240.142.X GeoIP City Edition, Rev 1: CN, 01, Anhui, Hefei, N/A...
223.27.200.X GeoIP City Edition, Rev 1: TH, 60, Surat Thani, Vibhavadi...

Puesto que estamos trabajando con la versión "lite", algunas de las IPs no están incluidas o actualizadas, pero para hacernos una idea general nos sirve.

Si esto te pareció útil, quizás te interesa saber cómo filtrar países con IPTables.

vim sin fichero de backup o temporal temporal

Tanto vi como vim por defecto vienen configurados para que creen una copia de seguridad del fichero que estás a editar. Este fichero, suele tener el mismo nombre que el fichero original, pero terminado en ~, y suele localizarse, también por defecto en la misma carpeta que se edita el fichero. Un ejemplo de fichero de backup podía ser file~, my.cnf~, etc.

Si por el motivo que sea no te interesa que vim genere automáticamente ese fichero de backup, puedes deshabilitarlo de forma muy sencilla escribiendo las siguientes opciones en ~/.vimrc.

set nobackup
set nowritebackup

Antes de guardar el fichero, es necesario comprobar que no haya ninguna ocurrencia de "set backup", ya que sino, vim no funcionará.

Si ahora, por el contrario, estás interesado en tener los ficheros de respaldo, pero mejor organizados, también es posible si en vez de lo anterior, escribes la siguiente configuración en el fichero ~/.vimrc.

set backupdir=~/.vim/backup

Antes de emplear nuevamente vim, asegúrate de que el directorio ahí especificado exista, sino créalo o vim no arrancará.

vi: Resaltado de sintaxis en archivos no reconocidos

vi o vim, para los no tan puristas, trae como ventaja el resaltado automático de sintaxis de aquellos ficheros que reconoce. Ya bien sea por extensión o bien por que se indica el intérprete que emplea, al abrirlos nos ofrece colores que supuestamente deben ser favorables al trabajo.

Por supuesto, no todo el mundo está a favor de emplear dichos colores, por lo que se pueden habilitar o deshabilitar en cualquier momento con,

:syntax [on|off]

Pero si estamos delante de un fichero para el cual nuestro editar de ficheros no es capaz de detectar el lenguaje en el que está escrito, deberemos de forzar el resaltado de sintaxis. Para ello emplearemos la orden set, pasándole como parámetro el tipo de resaltado que deseamos (perl, php, xml, etc.).

:set filetype=php

Un pequeño y sencillo truco para vi que te puedo simplificar la vida y hacerte más productivo.

Manejar extensiones Libre Office desde terminal

Siempre que trabajamos con sistemas de administración centralizada como Puppet o SaltStack, tenemos que tener presente que todos los procesos que ejecutemos deben ser desde consola, que el concepto "interfaz gráfico" ya no está disponible. Esto en Linux no suele ser un problema, pero hay ciertas acciones que sí que pueden hacer que tengamos que replantearnos cómo hacerlas.

Este es el caso de las extensiones de OpenOffice/LibreOffice. La instalación de la suite ofimática en el sistema es sencilla, puesto que está en los repositorios, únicamente hay que hacer que esté presente en los sistemas. El problema está en las extensiones, que son pequeños ficheros que nos descargamos de la web y que tenemos que instalar en cada una de las máquinas. La forma de hacerlo es desde el propio interfaz, pero claro, si pensamos en hacerlo en 50 equipos, por ejemplo, la cosa ya cambia.

Por suerte, para simplificar este proceso, existe el comando unopkg, que sirve para instalar o desinstalar extensiones en el sistema, pero desde línea de comandos. Así que, tras descargar la extensión que nos haga falta desde la web oficial, es.libreoffice.org/extensiones, únicamente tendremos que ejecutar lo siguiente,

shell> unopkg add --shared pager.oxt

En caso de que la extensión a instalar ofrezca un menú con licencia para aceptar, lo más sencillo es aceptar la licencia de base y que no se muestre, sino no se podrá instalar. Para ello, habrá que hacer lo mismo, pero con la opción -s, tal que así,

shell> unopkg add -s --shared pager.oxt

Espero que os sea útil si tenéis que mantener un cierto número de suites ofimáticas, en las que a mayores del paquete Office hay que manejar extensiones.

Restaurar permisos originales de un fichero

¿A quién no lo pasó alguna vez que cambió los permisos de un fichero o directorio completo sin querer y luego no sabía volver a los preestablecidos por el desarrollador?

Supongo que alguna vez ésto nos pasó a todos y no es una buena experiencia. Así que para intentar subsanar este tipo de fallos, hoy os presento un truco muy simple, para sistemas Red Hat y derivados, que permite restablecer los valores originales de forma muy sencilla. Ya bien sea para un fichero concreto o para todo un directorio, gracias a rpm --setperms volver a poner los permisos originales nunca fue tan sencillo.
Vamos a ver el comando en funcionamiento, que es la mejor forma de entender de lo que hablamos.

Partimos de estos permisos originales de un fichero cualquiera.

shell> ls -l /etc/ssh/ssh_config
  -rw-r--r--. 1 root root 2047 may 15  2012 /etc/ssh/ssh_config

y se los cambiamos por estos otros,

shell> chmod 777 /etc/ssh/ssh_config
shell> ls -l /etc/ssh/ssh_config
  -rwxrwxrwx. 1 root root   2047 may 15  2012 /etc/ssh/ssh_config

Como vemos, una equivocación no muy común, pero que en ese fichero puede traer consecuencias inesperadas. Aunque en el ejemplo es muy sencillo volver a los permisos originales, entre otras cosas por que sabemos a que volver, imagina que esto mismo se hiciera recursivo y afectase a todo /etc.
Lo que nos interesa es ver cómo volver a los valores originales del paquete sin tener que hacerlo manualmente. Para ello,

shell> rpm --setperms openssh-clients-5.3p1-81.el6.x86_64
shell> ls -l /etc/ssh/ssh_config
  -rw-r--r--. 1 root root   2047 may 15  2012 /etc/ssh/ssh_config

Y lo único que necesitas saber es el nombre del paquete que contiene el fichero o ficheros que has modificado, para lo cual,

shell> rpm -qf /etc/ssh/ssh_config
  openssh-clients-5.3p1-81.el6.x86_64

La entrada Restaurar permisos originales de un fichero la puedes leer el El mundo en bits.

Borrar memoria swap (Pagefile.sys) al apagar sistema

Hacía tiempo que no escribía ningún truco acerca de Windows. Y como no hay que ser radical, pues ahí va. Vamos a ver cómo forzar a Windows a borrar el archivo de paginación en el apagado.

Antes de nada, aclarar que Windows también emplea un sistema de paginación, o memoria swap, al más puro estilo Linux. Si bien es cierto que bajo sistemas Linux suele localizarse en una partición separada, en sistemas Windows, ésta está ubicada como un fichero dentro de la partición principal (C:\, generalmente). Aquí se guardan de forma temporal todos aquellos datos que no cogen en la RAM y son necesarios para el trabajo. Puesto que algunos de los datos que aquí se pueden almacenar son, por ejemplo, contraseñas, URLs, etc. no está demás forzar el borrado de dicho fichero al apagar el equipo.

Vamos por lo tanto a ver cómo borrar el fichero Pagefile.sys con los medio que Windows nos ofrece.

Ejecutar regedit.exe

Buscar la clave

HKEY_LOCAL_MACHINE
 + SYSTEM
   |
   + CurrentControlSet
     |
     + Control
       |
       + Session Manager
         |
         + Memory Management

Editar la clave ClearPageFileAtShutdown y establecer su valor a 1, dejando el tipo REG_DWORD.

El cambio es inmediato y la próxima vez que apaguéis el equipo, veréis que tras activar esto, el disco tiene mucha actividad instantes antes de apagarse completamente. El proceso de apagado es un poco más lento, puesto que borra el fichero del disco, pero compensa con el extra de seguridad que nos puede ofrecer.

Más información acerca del proceso en el soporte oficial de Microsoft.

La entrada Borrar memoria swap (Pagefile.sys) al apagar sistema la puedes leer en El mundo en bits.

Chrome: Deshabilitar el buscador en la pantalla de inicio

Desde la versión 29 de Google Chrome, éste trae una ~~atractiva~~ nueva página de inicio como la que encabeza esta entrada. Realmente tiene la misma información que siempre y a mayores está integrado el buscador de Google.
No es que me importe demasiado ni me moleste, pero en equipos no muy potentes, todavía no encuentro la explicación, dicha página es complicada de procesar. Esto hace que tarde en arrancar el navegador más de lo deseado. En el otro lado, está la idea de quiero sacarla por que no me apetece tenerla ahí, perfectamente respetable.
Así que ya sea sacarla para aligerar un poco el navegador o por que no te gusta, vamos a ver cómo hacerlo.

Lo primero que necesitamos hacer es abrir una nueva pestaña e ir a la URL chrome://flags/. En esta página, hay que tener cuidado, ya que vamos a tocar parámetros de configuración muy primitivos del navegador, por lo que ten cuidado con lo que tocas. Desde aquí no nos hacemos responsables.

Si eres de los que sigue, entonces busca la entrada "Habilitar la API ampliada de Instant Mac, Windows, Chrome OS" y cambia el valor por defecto que trae e Inhabilitado, tal como se muestra en la imagen lateral.

Tras modificarlo, reinicia el navegador y ya podrás comprobar que ya no está el navegador integrado y vuelves a tener la vista de las páginas más visitadas.

Por cierto, si eres de los que tiene el navegador en inglés, no te preocupes, el procedimiento es el mismo y la clave a buscar es "Enable Instant Extended API Mac, Windows, Chrome OS".

Los usuario de GNU/Linux estamos de enhorabuena, no tenemos que hacer nada, esta actualización no nos afectó :-)

Actualización: Desde la versión 33 de Google Chrome los usuarios de GNU/Linux también tenemos esta nueva pantalla de inicio por defecto.

Actualización: En truco para deshabilitar la visualización de dicha pantalla, desde la versión 33 deja de funcionar y todo el mundo debe verlo (ver comunicado oficial de Google aquí).

La entrada Chrome: Deshabilitar el buscador en la pantalla de inicio la puedes leer en El mundo en bits.

MySQL FULL PROCESSLIST

Fijo que muchos de vosotros os habéis preguntado alguna vez cómo obtener el proceso completo que se está ejecutando un MySQL. Por defecto, esto se consigue con 'show processlist', pero este comando, si el proceso ocupa más de un límite corta la línea, evitando así que veamos query's completas si éstas son muy grandes.

Por poner un ejemplo,

mysql> SHOW PROCESSLIST;
+----+------+-----------+-----+---------+------+-------+-----------------
| Id | User | Host      | db  | Command | Time | State | Info            
+----+------+-----------+-----+---------+------+-------+-----------------
| 10 | web  | localhost | web | Sleep   |  118 |       | NULL            
| 14 | web  | localhost | web | Query   |    0 | NULL  | SHOW PROCESSLIST
+----+------+-----------+-----+---------+------+-------+-----------------
2 rows in set (0.01 sec)

Como podemos observar, ahora que no hay ninguna query compleja, la salida es correcta y completa. Sin embargo, si ejecutamos alguna query grande y volvemos a ver los procesos, el resultado cambia sustancialmente.

mysql> SHOW PROCESSLIST;
+----+------+-----------+-----+---------+------+---------+---------------
| Id | User | Host      | db  | Command | Time | State   | Info          
+----+------+-----------+-----+---------+------+---------+---------------
| 10 | web  | localhost | web | Sleep   |  118 |         | NULL            
| 14 | web  | localhost | web | Query   |    0 | NULL    | SHOW PROCESSLIST
| 17 | webb | localhost | web | Query   |    0 | Sending | SELECT t.*,i.hostid FROM triggers t,items i,ho |
+----+------+-----------+-----+---------+------+--------------+----------
3 rows in set (0.01 sec)

En este caso, el proceso con Id: 17, un "SELECT" no está completo y por lo tanto no sabemos qué query es la que se está lanzando. Puede que esta información no sea necesaria, o puede que sí. En caso de que sí la necesites ver, el comando 'show' tiene la posibilidad de decirle que se ejecute con la salida completa y por lo tanto nos mostrará las query's. Para ello,

mysql> SHOW FULL PROCESSLIST;
+----+------+-----------+-----+---------+------+--------------+----------
| Id | User | Host      | db  | Command | Time | State        | Info     
+----+------+-----------+-----+---------+------+--------------+----------
| 10 | web  | localhost | web | Sleep   |  118 |              | NULL     
| 14 | web  | localhost | web | Query   |    0 | NULL         | SHOW PROCESSLIST
| 17 | webb | localhost | web | Query   |    0 | Sending data | SELECT t.*,i.hostid FROM triggers t,items i,hosts h WHERE h.hostid=t.hostid AND h.hostid=i.hostid AND h.hostid="15" h.status="0"
+----+------+-----------+-----+---------+------+--------------+----------
3 rows in set (0.01 sec)

Como vemos ahora el comando ya está al completo, que era justamente lo que buscábamos.

La entrada MySQL FULL PROCESSLIST la puedes leer en Puppet Linux.

sudo timeout

Si bien el otro día hablábamos de las diferencias entre sudo y su, hoy quiero aclarar un tema que puede significar un problema de seguridad a corto plazo. Por defecto muchos de los sistemas traen en su configuración de sudo un, llamémosle "tiempo de gracia" desde la primera vez que has introducido tu contraseña para ejecutar un comando sudo hasta que ésta se te vuelve a pedir. Durante este tiempo, siempre que emplees sudo no se te pedirá la contraseña del usuario. Esto, que puede parecer una facility del sistema, en sistemas de producción puede provocar un gran caos si una sesión "en tiempo de gracia" queda abierta y un usuario mal intencionado ejecuta un comando.

Para evitar esto, podemos agregar en el fichero de configuración (/etc/sudoers) la siguiente línea,

Defaults: ALL timestamp_timeout=0

que garantiza que siempre se pida la contraseña.

La entrada sudo timeout la puedes leer en Puppet Linux.

Recuperación de GRUB sin Live-CD

Hace ya un tiempo hablamos de cómo poder recuperar grub en caso de que éste haya desaparecido. La forma que vimos en aquel caso era la de arrancar con una Live-CD y entrar en nuestro sistema para restaurar el grub. Esa forma está muy bien, pero tiene el problema de que cuando lo necesitamos, a lo mejor no tenemos una Live a mano. En ese caso, ¿cómo hacemos para restaurar el sistema de arranque?

Pues bien, por suerte, grub tiene un pequeño prompt que permite, entre otras muchas cosas, arrancar el sistema en caso de emergencia. Así que vamos a ver cómo hacerlo.

Listamos las particiones disponibles
Esta es la parte más complicada, puesto que es necesario saber donde está la partición /boot. Si no os acordáis, no pasa nada, en dicho prompt existe en comando ls, que lista las particiones del disco y a la vez, el contenido del mismo. En mi caso tengo esto,
```
grub> ls
(hd0) (hd0,msdos5) (hd0,msdos1)
```
De las particiones disponibles, tenemos que saber cual es la de arranque. En mi caso, yo sabía que era la (hd0,msdos1), sino, lo que tenemos que hacer es listar los ficheros de cada una, para descubrir dónde está /boot
```
grub> ls (hd0,msdos1)/
/etc  /media /boot /usr /var ...
```
Es MUY importante la barra final y que el nombre sea exacto, sin espacio ni nada.
Configuramos dinámicamente grub
Una vez sepamos la partición en cuestión, debemos de añadir todos los datos que grub no sabe de forma dinámica. En caso de que alguno de estos datos no lo sepamos, simplemente empleamos ls para listar el contenido que deseemos.
```
grub> set prefix=(hd0,msdos1)/boot/grub¹
grub> set root=(hd0,msdos1)
grub> linux /boot/vmlinuz-3.2.0-29-generic-pae² root=/dev/sda1³
grub> initrd /initrd.img
```
Arrancamos
Finalmente, cuando ya todo esté configurado, simplemente arrancamos el sistema.
```
grub> boot
```

Una vez dentro, simplemente debemos de corregir el fallo del grub que impidió que arrancase el sistema correctamente y volver a instalarlo como es debido. Este método de arranque no es para todos los días ;-)

¹Debemos de encontrar la carpeta donde está localizado el grub. Por defecto está bajo /boot, así que ésta sería una buena configuración.

²Aquí tenemos que poner el kernel de nuestro sistema! Si no lo sabemos, podemos optar por emplear, en mi caso, ls (hd0,msdos1)/boot y nos listará los disponibles y ya copiamos el nombre.

³También debemos en este caso poner el disco. Puesto que en mi caso, es (hd0,msdos1), hd0, significa /dev/sda y el msdos1, la primera partición, de ahí /dev/sda1. Debéis ajustar esto a vuestro sistema, aunque esto es lo más habitual

La entrada Recuperación de GRUB sin Live-CD la puedes leer en Puppet Linux.

Matar procesos por usuario

En post anteriores vimos cómo poder matar los procesos SSH de un usuario y ahí hicimos ya uso del comando pkill. Hoy vamos a ver otro truco de dicho comando, que no es otro que poder matar todos los procesos de un usuario.

Sí, efectivamente, si un usuario está haciendo un uso muy abusivo de CPU o memoria y queremos matar todos sus procesos de forma rápida y eficaz lo podemos hacer tal que así,

shell> pkill -u user

Aunque ojo! Matará TODOS los procesos de dicho usuario, sin contemplaciones y sin previo aviso, así que antes de hacerlo, pensar en qué vais a hacer ;-)

Optimizar base de datos MySQL

MySQL es el motor de base de datos por defecto de numerosas aplicaciones, entre ellas Bacula. Y como otros muchos motores de bases de datos, tiene su parte buena y su parte mala. La parte buena es la flexibilidad y potencia que nos ofrece. La parte mala es que en aplicaciones muy dinámicas, hablando de datos, MySQL tiende a fragmentar las tablas y por lo tanto, espacio en disco ocupado y rapidez de acceso a datos aumentan. Aunque este post lo relacionamos directamente con Bacula, este pequeño truco sirve para cualquier otras aplicación que emplee MySQL. Lo que vamos a explicar aquí, es como optimizar un poco las tablas, es decir, que tras realizar muchas escrituras y borrados y también updates, hacer que la estructura de la tabla vuelva a ser la óptima. Existen dos formas, la primera es la clausulo OPTIMIZE de mysql, y la segunda, un pequeño script, que aparece en la documentación de bacula. Ambas estrategias van a realizar algo parecido, desfragmentar la tabla, repararla y ordenar los índices. Vamos a ver cómo funcionan.

OPTIMIZE

Es una clausula de MySQL y sobre tablas MyISAM da muy buenos resultados. Por lo tanto, para aplicarlo a bacula, simplemente tendremos que ejecutar dicha clausula sobre todas las tablas, una a una.

mysql> OPTIMIZE LOCAL TABLE bacula.BaseFiles;
+------------------+----------+----------+----------+
| Table            | Op       | Msg_type | Msg_text |
+------------------+----------+----------+----------+
| bacula.BaseFiles | optimize | status   | OK       |
+------------------+----------+----------+----------+
1 row in set (0.00 sec)

mysql> OPTIMIZE LOCAL TABLE bacula.CDImages;
+-----------------+----------+----------+----------+
| Table           | Op       | Msg_type | Msg_text |
+-----------------+----------+----------+----------+
| bacula.CDImages | optimize | status   | OK       |
+-----------------+----------+----------+----------+
1 row in set (0.00 sec)

Según el grado de fragmentación que presente, el proceso puede llevar más o menos tiempo.

script

Esta forma es algo más elaborada y requiere escribir un poco de código, pero el resultado es mucho más óptimo y queda más logrado. Realizamos el siguiente script,

#!/bin/bash

inMB=$(du -ms $DIR | awk '{print $1}')
echo "DB Bacula size: $inMB MB"
echo "Optimize MySQL Database (I): dump"
mysqldump -f -uroot -p --opt bacula > /tmp/bacula.sql
echo "Optimize MySQL Database (II): write"
mysql -u root -p bacula < /tmp/bacula.sql
echo "Delete security copy"
rm -f /tmp/bacula.sql
newInMB=$(du -ms $DIR | awk '{print $1}')
echo "New DB Bacula size: $newInMB MB"
RATIO=`echo "scale=2; ($inMB-$newInMB)/$inMB*100" | bc`
echo "$RATIO % compress ratio"

Antes de ejecutarlo, intentamos comprender un poco lo que hace, que no es más que realizar un dump de la base de datos bacula para luego volver a insertarla. Al insertarla, genera el schema y borra los datos actuales para volver a meterlos, sacando toda fragmentación y ordenando los índices.

Un ejemplo de ejecución sería,

DB Bacula size: 1577 MB
Optimize MySQL Database (I): dump
Optimize MySQL Database (II): write
Delete security copy
New DB Bacula size: 897 MB
43.00% compress ratio

Cualquier de las dos opciones es buena, y es aconsejable según el uso que se haga de bacula ejecutarla cada 3 o 6 meses. Si el equipo realiza muchas copias de seguridad, ejecutarlo una vez al mes, tampoco sobra. Realmente, lo importante es el porcentaje de espacio que se le gana. En esta ejecución, fue de un 43%, efectivamente lo necesitaba. Si la mejora es de un 3%, obviamente, no ;-)

SSH sólo para túneles

Ya hablamos de cómo crear un túnel SSH y también cómo hacer un túnel SSH inverso. Estas dos opciones son muy interesantes, especialmente la primera, a la hora del trabajo diario, sin embargo puede darse el caso de que nos interese establecer un túnel SSH contra una máquina, por ejemplo, para acceder a una tercera, pero que no nos interese (por el motivos que sea) dejar una conexión SSH "abierta", es decir, una consola. Si no vamos a realizar ningún trabajo en esa máquina, sino que únicamente la vamos a emplear de puente, para qué tener una conexión establecida. Para evitar esta consola innecesaria, SSH permite establecer un túnel no interactivo. Para lograrlo, únicamente debemos de emplear la opción -N, que evita que se abra una conexión interactiva (una consola) y la opción -f, que hace que el cliente SSH pase a segundo plano. Luego únicamente debemos de crear el túnel como siempre.

shell> ssh -N -f -L 1025:remote-desktop:443 server-ssh

La entrada SSH sólo para túneles la puedes leer en Puppet Linux.

Suscribirse a: Entradas ( Atom )