Author Image RDCH106

Hidden Console Start (HCS) – Esconde la consola y lanza procesos/aplicaciones en segundo plano

Dicen que no te das cuenta de algo hasta que lo pierdes… Esto es lo que me ha pasado cuando recientemente mi orientación profesional ha cambiado y he tenido  que trabajar con sistemas Windows en vez de GNU-Linux.

Acostumbrado a tener corriendo servicios en distintas máquinas con GNU-Linux acabas echando de menos su shell y la bestialidad de herramientas que hay. Vale sí lo reconozco, al final trabajaba en una máquina Windows, pero porque sigo pensando que las herramientas de desarrollo siguen siendo mejor que las que hay disponibles en GNU-Linux. Hay que reconocer que un Windows lo uso sólo para desarrollar (eso sí multiplataforma) y para jugar, para lo demás GNU-Linux sin duda!!!

Una de las cosas que he echado en falta recientemente es la posibilidad de usar el operador & de background tan potente en GNU-Linux. Este operador permite lanzar un proceso que se sigue ejecutando sin bloquear la shell y si la cerramos, éste sigue en segundo plano. Pues esto tan chulo, no puedes hacerlo en un Windows, porque su comando start no lo permite y la opción /B del comando no impide que al cerrarse la consola de comandos el proceso que has lanzado muera. A no ser que el proceso que has lazando cree su propio hilo no dependiente del proceso de la consola. Y tampoco es posible lanzar un proceso de consola de comandos sin consola, a no ser que esté programado explícitamente que la consola se oculte o no aparezca. Windows en este aspecto se cubre mucho, porque la única forma de crear procesos en background es construyendo servicios de Windows que tienen sus propias reglas a cumplir y por consiguiente hace falta desarrollo específico para que algo corra en segundo plano.

Visto el panorama y teniendo cierto conocimiento e idea, me decidí a generar una herramienta similar que funcionase en Windows como el operador &, o por lo menos a intentarlo. Para ello lo primero pensé en que quizás lo más adecuado fuese hacerlo en multiplataforma y generar una solución que funcionase tanto en Windows como en GNU-Linux. Atendiendo a este requisito, enseguida a mi mente llegó Python, porque además su instalación de paquetes es sencilla y potente a partes iguales, por no decir que es posible generar binarios (por ejemplo un .exe en Windows) si hiciera falta gracias a herramientas como py2exe y PyInstaller.

Con el punto de partida claro y unas horas de desarrollo, consigo lo que bautizo como Hidden Console Start o HCS. El proyecto puedes encontrarlo en Github:

Y su instalación es sencilla si tienes ya Python en tu equipo. En caso de no tener Python, pásate por la web de Python y descárgate la última versión disponible. Una vez instalado Python, solo tienes que ejecutar el siguiente comando en el CMD o PowerShell para instalar HCS:

pip install hcs --upgrade

Una vez instalado puedes ejecutar el proceso o aplicación que se quiera ejecutando HCS de la siguiente forma:

hcs -e "P1" "P2" ... "Pn-1" "Pn"

Pongamos un ejemplo:

hcs -e "ping 127.0.0.1 > log1.txt" "ping 192.168.1.17 > log2.txt"

En el ejemplo se lanzan dos comandos ping a distintas direcciones que son guardados en log1.txt y log2.txt respectivamente. Como se puede ver la consola de comandos no queda bloqueada y la información de los comandos ejecutados se va guardando el los ficheros.

Si por alguna razón tus procesos o aplicaciones no mueren o acaban, puedes finalizarlos en el caso de Windows abriendo el administrador de tareas:

Y en el caso de GNU-Linux con htop:

De esta forma podemos lanzar procesos y aplicaciones en segundo plano en sistemas Windows de una forma más o menos equivalente a como lo haríamos en GNU-Linux. Y obviamente podríamos usar HCS en GNU-Linux porque también funciona, pudiendo usarlo de la misma manera que en Windows.

Aumentar espacio de tu Raspberry Pi usando un dispositivo de almacenamiento USB

Una de las bondades de los sistemas GNU/Linux es la posibilidad de montar una unidad USB y  formatearla convenientemente. La cual puede ser montada a voluntad o meterla en la fstab (File Systems TABle) para que se monte con el arranque del sistema si lo deseamos. Para estas cosas GNU/Linux es la caña y es super flexible!! 😉

Un opción que podría ejemplificar fácilmente el uso de este procedimiento, puede ser una Raspberry Pi a la que queráis darle más espacio que el que tenéis disponible en la microSD donde tenéis montado el sistema operativo. Actualmente las memorias USB han bajado mucho su precio y han aumentado los tamaños máximos de las mismas, encontrándonos a precios razonables memorias de 128GB o256GB.

Empecemos con lo básico que es conectar la memoria USB a la Rapsberry Pi (obvio pero por si acaso lo digo 😉 ). Con la memoria USB conectada ejecutamos el siguiente comando:

ls -l /dev/disk/by-uuid/

El comando nos responde identificado las unidades disponibles. Las unidades “mmcblk0p1” y “mmcblk0p2” corresponden a la partición de boot del la Rapsberry Pi y a la de ficheros de Raspbian (Sistema Operativo) respectivamente. La que nos insteresa es la “sda1“. Anota el identificador (UUID) que tiene, en mi ejemplo el mio es “51a4dc12-f769-4286-bdb6-58f40f6a7ce2“.

Ahora vamos a preparar el punto de montaje de la unidad. Para ello ejecuta el siguiente comando para crear la ruta “media/usb” donde montaremos la unidad:

sudo mkdir /media/usb

Puedes usar otra ruta si lo deseas, pero intenta que sea corta, ya que tendrás que escribirla tantas veces como quieras acceder a la unidad.

Ahora hay que asegurarnos que el usuario “pi” es propietario de la nueva carpeta donde montaremos la unidad. Para ello ejecuta:

sudo chown -R pi:pi /media/usb

Para montar la unidad lo haremos con el siguiente comando:

sudo mount /dev/sda1 /media/usb

Si ejecutamos el comando:

df -h -T

Veremos que aparece la unidad en el punto de montaje “media/usb” indicado, así como el tipo de sistema de ficheros. Si has usado otro punto de montaje, aparecerá que el que hayas puesto.

Como usar la memoria USB con el formato FAT32 (aparece como vfat) no es lo más óptimo, formatearemos la unidad a EXT4 mucho más óptimo para nuestro sistema Raspbian. Puedes formatear fácilmente la unidad con el siguiente comando tras desmontar la unidad con:

sudo umount /media/usb
sudo mkfs.ext4 /dev/sda

⚠️ Ten en cuenta que si ejecutas los comandos para formatear la memoria USB, perderás los datos que hubiese dentro. ⚠️ Si estamos conformes con el formateo decimos que sí.

Si quisiéramos que la unidad se montase automáticamente, tendremos que incluir la nueva unidad en fstab. Para ello abriremos primero el fichero de configuración de fstab:

sudo nano /etc/fstab

Y añadiremos tras la última línea esta otra:

UUID=51a4dc12-f769-4286-bdb6-58f40f6a7ce2 /media/usb ext4 auto,nofail,noatime,users,exec,rw 0 0

El parámetro más importante es el “UUID” que anotamos al principio del artículo. Si finalmente optaste por formatear la memoria USB a EXT4, te recomiendo que vuelvas a ejecutar el comando porque el valor habrá cambiado.

Para concer específicamente el significado de cada parámetro te dejo la siguiente referencia:

Si finalmente decidiste NO formatear la memoria USB, la línea cambia un poco y se sustituye “ext4” por “vfat“:

UUID=51a4dc12-f769-4286-bdb6-58f40f6a7ce2 /media/usb ext4 auto,nofail,noatime,users,exec,rw 0 0

Ahora solo nos resta comprobar si efectivamente la unidad se monta sola y para ello ejecutaremos un reinicio:

reboot

Si lo hemos hecho bien deberíamos poder ver la memoria USB en “/media/usb“. Ya tenemos más espacio en nuestra Raspberry Pi!! 😉

Feliz Navidad y Próspero Año 2018

Las vacaciones Navideñas y el fin de año ya están a la vuelta de la esquina y toca cerrar otro año en el que en lo personal y profesional no me puedo quejar.

Mascando Bits ha mejorado su número de visitantes y la recurrencia de los mismos. ¡Gracias a todos los que leéis y compartís! 😉 Este blog lo puse en marcha como sistema de información personal de dominio público, sin ninguna pretensión más allá de la de devolver algo de conocimiento y pasión de lo que es mi hobby y mi profesión.

Este año tengo cambios profesionales y espero seguir manteniendo mi actividad de publicación y el desarrollo de mis proyectos en GitHub.

Con mis mejores deseos ¡Felices Fiestas! (para los agnósticos y atéos), ¡Feliz Navidad! (para los creyentes) y ¡Feliz Año 2018! (para TODOS 😉 ). ¡Nos vemos a la vuelta!

 

 

Configurar servidor DNS caché con tu Raspberry Pi para mejorar la velocidad del Tráfico de tu Red Local

Un de las piezas claves hoy en día de nuestro Internet que permite que funcione, son las Domain Name System o mayormente conocido como DNS. Este sistema de servidores DNS es el encargado de traducir los nombres de dominio que manejamos habitualmente, como mascandobits.es, en la dirección IP del ordenador donde está alojado ese dominio, que en el momento de escribir esta entrada es 31.220.20.199 .

 

Contextualización


Cada ordenador en Internet tiene una dirección IP que es única para ese ordenador (por lo menos en la red que pertenece). La IP está formada por cuatro números enteros de 0 a 255, separados por puntos. 127.0.0.1 es un ejemplo de dirección IP que además es especial porque hace referencia a nuestra propia máquina. Cada vez que te conectas a Internet, a tu ordenador se le asigna una dirección IP, puede ser siempre la misma o puede variar, lo normal es que cada vez que reinicies el router o al cabo de un tiempo obtengas una IP diferente.

Esta IP que tiene tu equipo, y que te proporciona tu router, es privada y solo funciona en el rango de tu red local (dispositivos conectados a tu router). Existe un conjunto de rangos de IP que son usados como IPs privadas:

  • 192.168.0.0 – 192.168.255.255 (65,536 direcciones IP)
  • 172.16.0.0 – 172.31.255.255 (1,048,576 direcciones IP)
  • 10.0.0.0 – 10.255.255.255 (16,777,216 direcciones IP)

El primer grupo de IPs lo puedes ver en la red local de tu casa o empresa (si es pequeña), el segundo grupo en empresas algo más grandes y el último grupo es común verlo para equipos conectados mediante VPN.

A su vez existe una segunda IP denominada pública que es la que tu ISP o proveedor de servicios te asigna al router y que sirve para poder acceder a Internet. Esta IP pública suele ser dinámica en la mayor parte de los casos y tu ISP se la asigna a tu router, normalmente reiniciando el router puede cambiar esta IP.

La conversión de una IP privada a una pública y viceversa se hace gracias a la Network Address Translation o NAT del router. Esto permite hacer peticiones a IPs publicas de servicios de Internet y devolver el tráfico de respuesta a la IP privada de la máquina que hizo las peticiones.

Un vez aclarado esta parte que es básica avancemos….

Los ordenadores donde están alojadas las páginas web o servicios tienen siempre la misma dirección IP, esto permite acceder dichos recursos siempre igual con la misma IP (a no ser que se cambie…). Sin embargo, cuando buscas una determinada página o servicios, en tu navegador no introduces la IP del ordenador donde está alojada, sino algo más sencillo de recordar, introduces un nombre de dominio, como mascandobits.es. Adicionalmente he dicho que normalmente no se cambia la IP de la web o servicio, pero puede darse el caso por ejemplo de que se quiera mover la web o servicio a otra máquina que muy seguramente tenga otra IP pública.  Gracias a las DNS este problema queda cubierto, ya que simplemente basta con asociar el dominio con la nueva IP pública.

Cuando escribes en tu navegador el nombre de una web o servicio, lo que hace tu ordenador es preguntar a tu servidor local DNS (el que te indica tu router por DCHP) por la dirección IP del ordenador donde está alojada esa página o servicio. El servidor DNS es una gran base de datos con infinidad de traducciones de nombres de dominio a dirección IP. Esa base de datos es distribuida y compartida con otros proveedores y sus respectivos servidores DNS. Si el nombre de dominio que estás buscando no está en tu DNS local, éste realizará una petición a otros DNS de la red hasta encontrar la traducción adecuada. Estas bases de datos guardan en caché durante unos días esas traducciones de nombre de dominio a IP, por eso a veces sucede que si una web o servicio cambia de servidor, puede que desde algunos lugares del planeta se acceda a la web o servicio y desde otros no, porque hay ordenadores que cuando preguntan por la página, el servidor DNS los envía a la antigua dirección IP y no a la nueva.

Además de los servidores DNS, nuestro ordenador también guarda un caché de las DNS, y si hemos visitado recientemente una página web, nuestro ordenador ya no preguntará al servidor cuál es la dirección IP de la página, sino que se dirigirá a la que ya tiene almacenada. Esta caché puede borrarse.

Para borrarla desde Windows:

ipconfig /flushdns

Para borrarla desde GNU-Linux:

sudo /etc/init.d/nscd restart  //si usas nscd dns cache
sudo /etc/init.d/dnsmasq restart  //si usas dnsmasq dns cache
sudo /etc/init.d/named restart  //si usas bind dns cache
sudo /etc/init.d/bind9 restart  //(alternativa) si usas bind dns cache

 

Configurar servidor DNS caché


Las DNS constituyen la columna vertebral del funcionamiento de Internet y dado su función constituye un riesgo una mala gestión de los DNS globales que son gestionados por la ICANN, una asociación sin ánimo de lucro. Existen 7 llaves que dan acceso físico a los DNS y que se reparten entre 14 personas, 7 titulares y 7 suplentes. Son los garantes de que los DNS no sean atacadoso o modifcados de manera no deseada:

Como puedes deducir el acceso a la resolución de DNS es algo que puede ser muy crítico. La ICANN sólo constituye el registro de una parte de Internet, aunque habitualmente se suelen usar sus DNS como referencia, ya que a su vez las operadoras que dan acceso a Internet (ISP) tienen sus propio DNS que van configurados en nuestro router y los cuales podemos cambiar por otros que sean de nuestro agrado.

Controlar las DNS y cómo se resuelven es algo que puede ser ventajoso, sobre todo si tenemos dentro de nuestra red local el servidor DNS y la resolución de dominios tiene una menor latencia. Para crear nuestro DNS caché lo podemos hacer con una Raspberry Pi conectada a nuestra red local de casa. Una Raspberry Pi consume como un móvil cargando y puede servirnos perfectamente para este cometido de acelerar las peticiones de resolución de DNS.

Accedemos a nuestra Raspberry Pi por SSH e introducimos el siguiente comando:

sudo apt-get install bind9 dnsutils

Con esto instalamos bind y además instalamos la herramienta dig (con el paquete dnsutil) que más adelante ya veréis para qué sirve.

Un vez instalado vamos a /etc/bind/named.conf.options, puedes configurarlo con el siguiente comando:

sudo nano /etc/bind/named.conf.options

Lo puedes configurar con la siguiente información:

    forwarders {
         208.67.222.222;
         208.67.220.220;
    };

Es posible que tengas que quitar la // para que tenga efecto. Todo lo que va precedido con // se trata como un comentario. Yo he usado como forwarders las DNS de OpenDNS, pero puedes usar las que quieras o añadir otras.

Ahora recargamos las configuraciones con el siguiente comando:

rndc reload

Ya tenemos funcionando nuestro servidor DNS cacche. Para comprobar la diferencia de tiempos de resolución vamos a hacer la siguiente prueba. Vamos a resolver las peticiones contra las DNS de Google (8.8.8.8) (se asume que son de lo mejorcito 😉 ) y contra nuestro nuevo servidor DNS caché en la Raspberry Pi.

Introducimos el siguiente comando para comprobar el tiempo de respuesta para la resolución del dominio mascandobits.es con las DNS de Google:

dig mascandobits.es  @8.8.8.8

; <<>> DiG 9.9.5-9+deb8u13-Raspbian <<>> mascandobits.es @8.8.8.8
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 28184
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;mascandobits.es.               IN      A

;; ANSWER SECTION:
mascandobits.es.        2684    IN      A       31.220.20.199

;; Query time: 42 msec
;; SERVER: 8.8.8.8#53(8.8.8.8)
;; WHEN: Thu Oct 26 19:11:51 CEST 2017
;; MSG SIZE  rcvd: 60

Nos devuelve 42 msec, que no está anda mal, pero vamos a ejecutar lo mismo usando nuestro DNS de la Raspberry Pi. Lo haremos dos veces, ya que la primera vez le costará un tiempo similar, o algo mayor, ya que deberá ir a buscar la resolución del dominio a los forwarders que configuramos la primera vez, en mi caso a los DNS de OPenDNS. Para la segunda ejecución os debería salir algo así:

dig mascandobits.es  @127.0.0.1

; <<>> DiG 9.9.5-9+deb8u13-Raspbian <<>> mascandobits.es @127.0.0.1
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 59435
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 7, ADDITIONAL: 14

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;mascandobits.es.               IN      A

;; ANSWER SECTION:
mascandobits.es.        2575    IN      A       31.220.20.199

;; AUTHORITY SECTION:
es.                     146250  IN      NS      a.nic.es.
es.                     146250  IN      NS      ns-ext.nic.cl.
es.                     146250  IN      NS      ns1.cesca.es.
es.                     146250  IN      NS      f.nic.es.
es.                     146250  IN      NS      ns3.nic.fr.
es.                     146250  IN      NS      sns-pb.isc.org.
es.                     146250  IN      NS      g.nic.es.

;; ADDITIONAL SECTION:
a.nic.es.               146250  IN      A       194.69.254.1
a.nic.es.               146250  IN      AAAA    2001:67c:21cc:2000::64:41
f.nic.es.               146250  IN      A       130.206.1.7
f.nic.es.               146250  IN      AAAA    2001:720:418:caf1::7
g.nic.es.               146250  IN      A       204.61.217.1
g.nic.es.               146250  IN      AAAA    2001:500:14:7001:ad::1
ns1.cesca.es.           146250  IN      A       84.88.0.3
ns1.cesca.es.           146250  IN      AAAA    2001:40b0:1:1122:ce5c:a000:0:3
ns3.nic.fr.             146250  IN      A       192.134.0.49
ns3.nic.fr.             146250  IN      AAAA    2001:660:3006:1::1:1
ns-ext.nic.cl.          146250  IN      A       200.1.123.14
sns-pb.isc.org.         146250  IN      A       192.5.4.1
sns-pb.isc.org.         146250  IN      AAAA    2001:500:2e::1

;; Query time: 1 msec
;; SERVER: 127.0.0.1#53(127.0.0.1)
;; WHEN: Thu Oct 26 19:11:40 CEST 2017
;; MSG SIZE  rcvd: 495

Hemos bajado a 1 msec, que es bastante mejor que el tiempo de las DNS de Google. Además esto nos demuestra que se consigue bastante velocidad, en mi caso 42 veces más rápido para un dominio cacheado previamente por el servidor DNS de la Raspberry Pi.

Ahora para que todos los dispositivos de tu red usen estas nuevas DNS, lo más fácil es configurarlo en el router. Yo tengo un router de TP-Link, pero la configuración suele ser similar en todos los routers. Lo que nos interesa suele estar en la sección “DCHP”:

En el DNS Server he añadido la IP de la Raspberry Pi donde está el servidor DNS, es recomendable para ello que asignes IP estática a la Raspberry Pi. Hoy en día lo puedes hacer fácil desde el propio router asociando una IP privada a la MAC de la Raspberry Pi. El Secondary DNS Server lo he dejado con 0.0.0.0 para que lo resuelva contra el modem-router de proveedor de servicio a Internet (ISP). Esto hace que si la Raspberry Pi deja de funcionar, la red puede seguir resolviendo los dominios contra las DNS que me proporciona el router de mi ISP. Hay que cubrirse siempre 😉 !.

Con esto ya estaría listo, pero para dejarlo todo bien atado vamos a volver a la consola SSH de la Raspberry Pi para comprobar si bind arrancará al inicio si la apagas y enciendes. Para ello vamos a introducir el siguiente comando:

service bind9 status
● bind9.service - BIND Domain Name Server
   Loaded: loaded (/lib/systemd/system/bind9.service; enabled)
  Drop-In: /run/systemd/generator/bind9.service.d
           └─50-insserv.conf-$named.conf
   Active: active (running) since jue 2017-10-26 10:25:49 CEST; 5h 18min ago
     Docs: man:named(8)
 Main PID: 17478 (named)
   CGroup: /system.slice/bind9.service
           └─17478 /usr/sbin/named -f -u bind

Si en la línea de “Loaded” vemos al final “enabled”es que está activado como servicio al arranque. Si no fuera así bastaría con ejecutar el siguiente comando:

sudo systemctl enable bind9

Si quieres ver de manera general todos los servicios que tienes corriendo puedes ejecutar:

service --status-all

Podremos ver los servicios que existen y si están arrancados o no.

Con esto ya queda tu red perfectamente configurada para usar tu propio servidor DNS caché alojado en tu Rapsberry Pi para toda tu red local y mejorar los tiempos de respuesta de la resolución de dominios.