Compiladores Intel

Parallel Studio es una suite de compiladores y bibliotecas, entre las que se encuentran MKL (Math Kernel Library).

Por defecto, la opción de instalar las bibliotecas paralelas Blacs y Scalapack (para MPI) está desactivada. Para activarla, hay que ir a “Component Selection” / “Intel Math Library for C++” (o Fortran, según el lenguaje que vayamos a usar) / “Cluster support for C/C++”

SSL Reverse proxy con Apache

Un ejemplo que sirve para Meteor:


SSLProxyEngine On
# snake oil certs in proxyied service -> skip checks
SSLProxyVerify none
SSLProxyCheckPeerCN off
SSLProxyCheckPeerName off

ProxyRequests Off
ProxyPreserveHost On

ProxyPass /websocket ws://localhost:3000/websocket
ProxyPassMatch ^/sockjs/(.*)/websocket ws://localhost:3000/sockjs/$1/websocket

ProxyPass / http://localhost:3000/
ProxyPassReverse / http://localhost:3000/
ProxyPassReverseCookiePath / /
ProxyPassReverseCookieDomain 127.0.0.1 52.211.154.50
RequestHeader set X-Forwarded-Proto "https"

Parece que en nginx la configuración análoga es trivial. Quizá sea un buen argumento para convertirse…

Secure cookies over reverse proxy with https

Discos virtuales en Xen Server

Con el comando vhd-util podemos obtener un listado de los VDI/VHD de un Storage Repository (SR) de Xen Server:

vhd-util scan -f -a -c -m “VHD-*” -l nombre_VG

(el nombre del vg de Xen lo podemos averiguar con vgs. Normalmente empieza con VG_XenStorage)

vhd-util scan muestra una jerarquía de VHD, con su tamaño virtual y real. Esto es útil para hacer un seguimiento de los snapshots. Cada VHD es un volumen lógico en el VG, con lo cual a partir del identificador de VHD podemos obtener información adicional (por ejemplo, cuando se creó) buscándolo en la salida del comando lvdisplay

Para averiguar a qué VM corresponde un VDI…

xe vbd-list vdi-uuid=UUID

(el UUID es el que aparece en vhd-util scan, pero sin VHD-)

Otro comando para obtener información sobre los VDI es

xe vdi-list

Para empezar es cómodo, pero sólo muestra el tamaño virtual del disco.

Lista de instantáneas:

xe snapshot-list

Desde el interfaz de Xen Server es fácil eliminar un snapshot. Generalmente, en el interfaz desaparece al instante, pero en función de las dependencias en la cadena de snapshots puede tardar un rato en eliminarse del almacenamiento (cada vez que se elimina un snapshot, por detrás se lleva a cabo un “online coalescencing”). Se puede hacer un seguimiento más detallado del proceso en el log de Xen Server /var/log/SMlog

Repartir espacio disco NVME entre Windows y Linux

Arrancar Linux desde pendrive (por ejemplo, Ubuntu live)

Gparted. Reducir tamaño partición Windows. Mover comienzo partición Linux (para aprovechar el espacio liberado). Al cambiar el sector de inicio de la partición de sistema de Linux, puede ser que Grub no sea capaz de arrancar Linux. Con lo cual lo más simple es volver a reinstalar grub.

En Gparted podemos ver los nombres de dispositivo del disco nvme. Normalmente, el disco se denomina nvme0n1, y las particiones nvme0n1p1, p2…

Reinstalar Grub:

Montar sistema de ficheros raíz de Linux en /mnt/os
bind-mount sistemas de ficheros dev, proc, sys en /mnt/os
chroot /mnt/os
mount /boot/efi
grub-install /dev/nvme0n1

OpenGL en remoto (ssh) y Nvidia

Para el rendering OpenGL en un ordenador remoto se recurre (por defecto) a “indirect rendering” (los comandos Open GL pasan por el protocolo GLX). El “direct rendering” permite acceder directamente a la GPU del ordenador donde se ejecuta la aplicación. Este es el modo que usa por defecto el controlador nativo de Nvidia, que de hecho por defecto rechaza el uso del “indirect rendering” (se puede rehabilitar con la opción “AllowIndirectGLX” de la sección “ServerFlags” de xorg.con).

Así pues, ejecutando la instalación por defecto del driver nativo de Nvidia, se sustituye la biblioteca del sistema libGL. Con lo cual, se pierde el “indirect rendering” y las aplicaciones OpenGL dejan de funcionar en remoto (X11 sobre SSH)

Por otro lado, la biblioteca libGL que Nvidia instala puede ser necesaria para otras aplicaciones (por ejemplo, CUDA)

Una posibilidad es rescatar la biblioteca libGL original (del paquete libgl1-mesa-glx, o equivalente) y recurrir a ella para uso remoto, anteponiendo LD_PRELOAD=/ruta/a/libGLoriginal.so al programa a utilizar.

Si MESA recurre a swrast_dri.so para hacer el rendering (render por software), es probable que haya conflictos con bibliotecas como libstdc++.so.6 o libgcc_s.so (como suele suceder con UCSF Chimera, que tiene sus propias copias de esas bibliotecas en su directorio lib). En este caso se puede usar el mismo “truco” de LD_PRELOAD, pero con esas bibliotecas:

LD_PRELOAD=/usr/lib/gcc/x86_64-linux-gnu/4.9/libgcc_s.so:/usr/lib/x86_64-linux-gnu/libstdc++.so.6 chimera

Combinar correspondencia con Inkscape

Una de las muchas ventajas de Inkscape es que el formato de fichero que utiliza es el estándar SVG, que a su vez se basa en XML. Al ser texto plano, se puede procesar fácilmente. Por ejemplo, se diseña un formulario con Inkscape en el que los campos (nombre, dirección…) se rellenan con identificadores únicos. Esos identificadores únicos se pueden sustituir luego con información de un fichero o una base de datos. El SVG resultante se puede imprimir y reutilizar con un nuevo registro.

Conectar ratón bluetooth en Archlinux

Habilitar bluetooth en Thinkpad:

echo 1 > /sys/devices/platform/thinkpad_acpi/bluetooth_enable

Instalar bluez y bluez-utils

Cargar el módulo btusb. Arrancar el servicio bluetooth

modprobe btusb
systemctl start bluetooth.service

Hacer el emparejado y conexión con la herramienta bluetoothctl

bluetoothctl
[bluetooth]# list
[bluetooth]# select <controller mac>
[bluetooth]# power on
[bluetooth]# scan on
[bluetooth]# agent on
[bluetooth]# devices
[bluetooth]# pair <mouse mac>
[bluetooth]# trust <mouse mac>
[bluetooth]# connect <mouse mac>

GTX vs Quadro

El rendimiento no sólo depende del hardware puro y duro: también influye qué flujo tiene nuestra aplicación y lo optimizado de las capas intermedias (bibliotecas y drivers). Esto es particularmente importante en el caso de las GPU.

Normalmente, para GPU uno suele recurrir a CUDA. En cuyo caso, parece que lo más importante es cuantos núcleos CUDA tiene la tarjeta gráfica que vamos a usar (suponiendo que nuestro programa sea realmente capaz de exprimirlos todos…) Normalmente, el número de cores por euro suele favorecer más a la serie GTX.

Pero claro, hay que justificar el precio de las gamas profesionales (Quadro y Tesla). Las Quadro consiguen un 50% de rendimiento en doble precisión (frente a precisión simple). Las GTX están “capadas” para que sólo ofrezcan un 12% del rendimiento. Con lo cual, si tu algoritmo necesita o se beneficia de doble precisión, seguramente te convenga una Quadro.

Otra costosa diferencia entre GTX y Quadro es la cantidad y tipo de memoria. Las tarjetas “pro” suelen integrar proporcionalmente más memoria, y además suele ser memoria con corrección de errores (ECC)

También, las gamas Pro las supervisa directamente Nvidia, con lo cual las tarjetas suelen ser más robustas y fiables. Las GTX pueden venir “overclockeadas” de serie, lo cual puede producir sospechosos cuelgues al darles cera (típico de cálculo GPU)

El caso de los controladores también es relevante. Por ejemplo, programas como Autodesk Maya están muy optimizados para Quadro, con lo cual seguramente te compense tirar de Quadro para este caso.

Más detalles en esta pregunta en Superuser

Inkscape: exportar en PDF multipágina

Inkscape no soporta per-se múltiples páginas (por el rechazo del estándar SVG).

Sin embargo, pueden simularse como capas, guardarlas por separado (“Layers as separate SVG, .tar”). Extraer esos svg del tar, y luego convertirlos a PDF (con algún comando como cairosvg, o el propio inkscape)

# con cairosvg
cairosvg page1.svg -o page1.pdf
# con inkscape
inkscape page1.svg --export-pdf=page1.pdf

Por último, se pueden combinar todos esos PDF sueltos en un único PDF.

Compilar gcc

Varias recetas para compilar el compilador C/C++ de GNU (valga la redundancia :-p)

Receta simple

Receta “complicada” (estática)

Si tienes N cores/CPU, puedes añadir “-j N” al make para acelerar el proceso.

Igualmente, si sólo necesitas (por ejemplo) C, C++ y Fortran, puedes indicarlo con “–enable-languages=c,c++,fortran”

cd gcc
./contrib/download_prerequisites
cd ..
mkdir objdir
cd objdir
../gcc-4.7.2/configure --prefix=~/gcc --enable-languages=c,c++,fortran
make -j 8
make install

Introducción a la seguridad de servidores

El artículo “Security Guide: How to Protect Your Infrastructure Against the Basic Attacker” de las gentes de Mailgun es exhaustivo a la par que claro, por lo que resulta una estupenda forma de iniciarse en los misterios de la “securización de servidores”. Incluye ejemplos de cortafuegos, restricción de recursos, monitorización…

Algunos puntos particularmente interesantes:

  • “demonización”: (systemd / initd) + monit, supervisord, skarnet s6, daemontools
  • capabilities” en lugar de setuid/sudo
  • Usar ProxyCommand en vez de ssh-agent (cuando hay pasarelas/bastión por medio)
  • balanceo de carga (apache / nginx / haproxy / vulcand) que separe el servidor de aplicaciones (privado) del servidor web público

La charla “Simple but Effective Server Hardening”, de Kyle Rankin, va bastante más al grano. Pero también merece la pena echarle un ojo.

A destacar:

  • evitar fail2ban
  • SSH: impedir login como Ruth :-p, o el uso de “claves tecleadas”. Usar opciones de cifrado seguras (aes256-gcm@openssh.com, curve25519-sha256@libssh.org, hmac-sha2-512-etm@openssh.com …)
  • Usar pares de claves seguros (ver abajo)
  • Two factor authentication. como Google Authenticator
  • Control de versiones de los ficheros de configuración de los servidores
  • Acceso remoto por pasarela (“bastión”)
# pares de claves "seguros" (en 2015...)
ssh-keygen -t rsa -b 4096
ssh-keygen -t ed25519

El servidor cayó – hora del postmortem

Antes de la muerte súbita, uno puede plantearse muchas cosas. A toro pasado, poco más que hacer un análisis forense…

Si tienes programadas alertas para posibles fallos, tu nagios (o equivalente) te habrá avisado con antelación para prevenir la catástrofe. Si además tienes montado algo más o menos altamente disponible, el impacto no suele ser tan grave (incluso aunque se caiga el servidor)

No obstante, en este artículo nos centraremos en la pregunta que se suelen hacer los usuarios en estos casos: “¿y por qué se ha caido?”. El administrador suele preguntarse algo más práctico: “¿cómo evitar que se repita?” (en ese servidor, y en el resto, por si acaso).

Si la consola permanece visible, los mensajes que aparecen pueden ser un buen punto de partida para el análisis forense.

Por defecto, los logs que suelen estar disponibles son kernel.log y auth.log. En ellos puede encontrarse alguna pista.

Si tienes instalado atop y/o snoopy, tendrás algo más de información.

Con kdump se puede obtener un volcado del núcleo de Linux. Para ello hace falta que el kernel en uso esté preparado (“After successfully loading the dump-capture kernel as previously described, the system will reboot into the dump-capture kernel if a system crash is triggered”)

La preparación de kdump no es trivial. En Debian, el paquete kdump-tools ayuda con el proceso. Con netdump, se puede hacer el volcado en otro ordenador (via ssh)

No se puede descartar la posibilidad de que el fallo se deba al hardware (la memoria, la placa base y todo lo que integra…), a un calentamiento (que sería delatado por los registros de temperatura), fallos en servicios privilegiados (o en controladores)…

Las tarjetas gráficas y las X pueden ser también causa de conflicto, pero normalmente en los servidores no se instalan.

Más información:

Determining the cause of a kernel panic

Common kernel problems (Fedora)

Tutorial sobre analisis de volcados de kernel, por Eugene Teo

Tutorial sobre LKCD, por Norman Patten (¿el primer tutorial oficial sobre la materia?)

Configure netdump (IBM)

“DevOps Troubleshooting: Linux Server Best Practices”, de Kyle Rankin.

ATI y la convivencia con la tarjeta integrada

ATI ofrece una forma sencilla de cambiar entre la tarjeta integrada (menor rendimiento, bajo consumo) y la tarjeta con aceleración 3D (mayor rendimiento, consumo energético más alto):

# comprobar qué tarjeta se está usando
aticonfig --pxl

# usar GPU
sudo aticonfig --px-dgpu

# usar tarjeta integrada
sudo aticonfig --px-igpu

Después del cambio, hay que reiniciar el servidor X. Lo más sencillo para ello es cerrar sesión y volver a entrar (login)

systemtap

systemtap es una completa herramienta que permite cotillear lo que se cuece en el kernel (en la línea del ínclito dtrace). En la documentación (/usr/share/doc/systemtap-doc/examples) hay multitud de ejemplos interesantes de sus posibilidades. Algunos ejemplos:

  • general/watchdog.stp: procesos de usuario relacionados con una llamada que tarda más de lo esperado
  • interrupt/interrupts-by-dev.stp: interrupciones por dispositivo
  • io/disktop.stp: procesos con entrada/salida más intensa
  • process/sigkill.stp: señales de terminación

La única “pega” es que necesita la versión debug del kernel…

auditd

auditd es una herramienta que pemite registrar llamadas a sistema y cambios en ficheros. Por ejemplo…

  • señales de terminación (auditctl -a exit,always -F arch=b64 -S kill)
  • cambios en pemisos de fichers (auditctl -w /etc/shadow -p wr -k private-shadow
  • ejecución de programas de un usuario concreto (auditctl -a exit,always -F arch=b64 -F uid=1001 -S execve)

Por defecto, el registro se guarda en /var/log/audit/audit.log

El comando ausearch permite buscar en dicho registro.

Cómo comprimir en paralelo en Debian

Paralelismo en el compresor

De momento, la opción -T de xz no está activa, con lo cual hay que recurrir a las versiones paralelas de los clásicos: pigz o pbzip2.

Una vez instalado, basta con especificar el compresor en los parámetros de tar (normalmente, estos comandos paralelos detectan los cores disponibles, con lo cual no hace falta especificar nada):

tar cf test.tar.bz2 -I pbzip2 test

Paralelismo en los trabajos

Para comprimir muchos ficheros, una solución obvia es comprimir varios a la vez. Esto sólo requiere alguna herramienta que reparta los ficheros entre los compresores. Gnu parallel viene como anillo al dedo:

# 2 ejemplos del manual
# comprimir todos los ficheros "*.html"
parallel gzip ::: *.html
# convertir todos los "*.wav" en mp3 con LAME
parallel lame {} -o {.}.mp3 ::: *.wav

# comprimir con xz todos los ficheros del listado "files",
# usando un máximo de 4 cores:
parallel -P 4 xz < files