20 – mosh

Bienvenidos al episodio 20 de deployandome, el podcast de tecnología para sysadmins y devops. Soy Rodolfo Pilas y estoy grabando el 12 de septiembre de 2017.

Todos nosotros que estamos trabajando con sistemas GNU/Linux y administramos servidores utilizamos SSH, casi que asumo que todos Ustedes, oyentes de este podcast lo utilizan.

No es por nada que un 10% de las ediciones que llevo hechas de deployando.me fueron dedicadas a herramientas vinculadas a OpenSSH o a distintos usos de SSH.

Y en esta edición voy a volver al tema de SSH para presentar MOSH una forma de más eficiente y con más prestaciones para tus conexiones SSH.

A ver, quiero que cada uno de Ustedes piense cuántas veces a tenido alguno de estos problemas al conectarse con sus servidores SSH:

  • PROBLEMA 1: Si no tienes una buena conexión, cuando hay mucha pérdida de paquetes o cuándo la conexión está saturada, que el echo de lo que escribes tiene un lag importante y que debes esperar para confirmar los comandos.
  • PROBLEMA 2: O que pediste hiciste un cat de un archivo de logs enorme y te das cuenta que eso demorará muchísimo en desplegarse en tu pantalla remota y comienzas a apretar Ctrl-C como poseído y sin embargo el buffer de datos esta lleno y el texto sigue pasando por tu pantalla sin que a las decenas de Ctrl-C has presionado les llega el turno de ser atendidas por el servidor.
  • PROBLEMA 3: Tienes abiertas conexiones SSH con uno o varios servidores y cambias el acceso Wifi de tu escritorio de un AP a otro, o cambias de Wifi a red tableada o viceversa, o te mueves dentro de la empresa y cambias de AP o pasas por una zona sin cobertura y cuando vas a ver tus conexiones SSH están todas congeladas, duras.   Que cierras la ventana y las vuelvas a conectar y ves que tu sesión anterior ahí sigue abierta y confías que algún día caducará por timeout.

Estoy seguro que han vivido varias veces alguno de estos problemas, porque estos problemas son normales y responden a la forma en que OpenSSH y el cliente SSH se comunican.

El tráfico del cliente OpenSSH con el servidor se establece mediante una conexión TCP al puerto 22 por defecto, lo que lleva a mantener un estado de CONNECT para el uso del servicio.

Además cada letra que escribimos en nuestro computador viaja a través de esa conexión hasta el servidor que la recibe y devuelve el echo correspondiente que retorna hasta nuestro cliente que lo despliega en nuestra pantalla, es decir hay un ida y vuelta de datos por cada letra, una vez que estamos conectados.

Pero también sabemos que el despliegue de texto en consola enlentece cualquier proceso que se quiera ejecutar y para mejorar la performance, es decir, que el proceso no tenga que esperar por que las letras se dibujen y fluyan por la pantalla,  existen buffers que reciben los datos que van a ser mostrados y permiten que el proceso finalice cuanto antes, a pesar de que el despliegue a pantalla no ha terminado.  Ahora, fíjense que si a esto le adicionamos que el el 100% de ese texto debe ser trasmitido por una conexión remota para desplegarlo en una consola remota, el la demora del proceso total será mayor

Y esto es cómo funciona nuestro querido SSH provocando los problemas que les he planteado que a veces son un verdadero dolor en la entrepierna, mientras esperamos completar un comando, apretamos Ctrl-C como desesperados o resoplamos por tener que volver a levantar nuestras conexiones para seguir trabajando.

Pero, para solucionar estos problemas y volver nuestro trabajo con SSH una maravilla existe MOSH, The Movile Shell.

Arranco a comentarles que MOSH no es un nuevo daemon que hay que tener levantado. Tampoco debemos enfrentarnos a un nuevo sistema de validación. MOSH realiza una conexión y validación utilizando el servidor SSH, para levantar del lado del servidor la utilidad mosh-server, muy semejante a como hace rsync para sincronizar archivos con un servidor remoto.

Entonces, tengo que tener instalado mosh tanto en el cliente como en el servidor.  En el cliente inicio la conexión con el comando mosh en lugar del comando ssh; con una sintaxis muy parecida:

mosh usuario@servidor

El cliente mosh se va a conectar al servidor SSH utilizando toda la configuración de conexión y validación que utilizaría el cliente ssh; es decir, es una conexión ssh TCP al puerto 22.

Una vez que la conexión se establece y se valida, va a ejecutar del lado del servidor mosh-server a nivel de usuario, va a abrir el puerto UDP 60004 para comenzar el intercambio de todo el resto del tráfico mientras dura nuestra sesión.

De esta forma, el uso de UDP permite que entre el cliente y servidor mosh se pueda definir una administración del flujo de paquetes propia. Entonces, cada paquete tiene un identificador incremental y tanto del servidor como el cliente arma su propia lista de paquetes conocidos y retransmiten si fuera necesario.

Esta característica hace que el cliente pueda hacer roaming entre distintas IP, inclusive entre IPv4 e IPv6, volviendo a reconectar automáticamente.  Mientras que el servidor quedará esperando hasta que continúe el tráfico de paquetes.

En términos prácticos, si lo usas desde un dispositivo móvil, como yo que lo uso desde el iPad, puedes conectar trabajar conectado, cerrar el iPad, trasladarte a otro local, volverlo a abrir y ahí seguirás conectado como si no te hubieras movido de lugar.

¿te gusta? Pero las ventajas de MOSH siguen:

El cliente MOSH maneja su propio flujo de escritura que sincronizará con el servidor; es decir que cuando tu escribes una letra, esta letra será mostrada en tu pantalla inmediatamente por el propio cliente que verá cómo hacer llegar al servidor.

Supongamos también que tu escribes realmente rápido y estás en con una conexión que tiene perdida de paquetes, tu no notarás que tus textos se trancan y escribirás fluidamente. En algún momento el texto se sincronizará con el servidor.  El servidor, por su parte hará lo mismo con la respuesta a la ejecución de tu comando, llegará a ti, como un diferencial de pantalla.

Pero si en ese entorno regresas con las flechitas y cambias un caracter, MOSH solo trasmitirá el caracter cambiado y mosh-server se encargará de re-armar la línea del lado del servidor, para esperar tu enter.

Y ¿cómo se resuelven los despliegues enormes de texto del lado del servidor?  ¿recuerdas? Esos que trancan tu pantalla por un rato con el cliente SSH.

MOSH obviamente tratará de hacerte llegar el despliegue a tu pantalla, pero estará escuchando tus órdenes por teclado y, si recibe un Ctrl-C, lo trasmitirá al comando y dejará de sincronizar la pantalla aunque aún queden unos cientos de líneas que deban ser trasmitidas.

¿Parece muy básico no?  Pues es la idea que me enamoró de MOSH, es sencillo y corrige esos momentos incómodos que tenemos con OpenSSH cliente/servidor.

El sitio web de MOSH cuyo enlace queda en el artículo de esta edición en el blog deployando.me lo resume como:

Una aplicación de terminal remota que permite roaming, soporta conectividad intermitente y ofrece un echo local inteligente y edición de la linea para lo que escribe el usuario.

Mosh es un software libre licenciado mediante GPL v.3, creado originalmente por Keith Winstein en 2012. Está disponible para GNU/Linux, BSD, macOS, Solaris, Android, Chrome, and iOS.

Les recuerdo que en el blog deployando.me siempre pongo la transcripción total del contenido del podcast, que también suelo ilustrar con algún enlace o material extra.

Soy Rodolfo Pilas, en twitter me siguen por @pilasguru y les dejo un saludo a todos, confiando en que este podcast les haya aportado para mejorar y, como siempre, espero sus inquietudes y sugerencias comentando en deployando.me

Hasta la próxima edición.

Referencias

  • Fermin Barboza

    Muy bueno !