Introducción a Linux/Screen
Introducción a Screen editar
Screen, al más puro estilo de la filosofía Unix "haz sólo una tarea y hazla bien" se trata de una pequeña herramienta/utilidad cuyo cometido no es otro que crear terminales virtuales.
A pesar de su simplicidad su potencia es enorme. El manejo de screen requiere un cierto entrenamiento (posiblemente 1 a 3 horas) El entrenamiento consistirá en memorizar los comandos típicos de screen hasta automatizarlos sin pensar. El esfuerzo merece la pena ya que una vez aprendido su uso, será una de las herramientas que siempre tengamos a nuestro lado y nos ayudará en cualquier otra tarea que queramos realizar en nuestro sistema, ya sea administrar un servidor apache, una base de datos como postrgresql o Mysql, un servidor de correo, una centralita telefónica Asterisk, o cualquier otra aplicación que nos venga a la memoria.
Lo mejor es verlo mediante ejemplos. Para empezar, ejecutamos una terminal como xterm, gnome-terminal, terminator o Kconsole y dentro de la misma iniciamos nuestra primera sesión de screen:
~$ screen
Screen version 4.00.03jw4 (FAU) 2-May-06
Copyright (c) 1993-2002 Juergen Weigert, Michael Schroeder
Copyright (c) 1987 Oliver Laumann
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 2, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program (see the file COPYING); if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Send bugreports, fixes, enhancements, t-shirts, money, beer & pizza to
screen@uni-erlangen.de
[Press Space for next page; Return to end.]
Pulsamos enter(=return) y a continuación volvemos a un prompt similar al que teníamos antes de ejecutar screen:
~$
Aparentemente no ha sucedido nada extraordinario. Sin embargo acabamos de crear una sesión de screen. Ejecutamos un comando:
~$ echo "shell 0" shell 0 ~$ _
y a continuación salimos de screen. Para ello pulsamos simultaneamente "Ctrl+a" y seguido "d" (a minúscula y d minúscula).
~$ screen [detached]
La combinación de "Ctrl+a" es la forma de indicar a screen que queremos enviarle un comando. Seguidamente enviamos el comando que queramos. En este caso "d" (detach/desliguar), que le indica que queremos desligarnos de la sesión de screen. A continuación cerramos la terminal xterm(o gnome-terminal, kconsole,...) y volvemos a ejecutar una nueva terminal. En la misma escribimos el comando:
~$ screen -r
Nuestra primera y agradable sorpresa. La pantalla mostrará:
~$ echo "shell 0" shell 0 ~$ _
Vemos que a pesar de haber cerrado la terminal nuestra sesión screen sigue intacta. La sesión se guarda en memoria y mientra no se reinicie la máquina o explicitamente le indiquemos a screen que queremos acabar la sesión seguirá allí "para siempre". Una sesión de screen no muere si la red se desconecta. Al volver la red y volver a conectar nuestra sesión de screen seguirá allí. Una sesión de screen puede durar una hora, lo que tardemos en realizar una tarea. O varios meses, si así lo deseamos. Ejecutamos un segundo comando screen, "Ctrl+a" y seguido "S" (mayúscula). Segunda sorpresa, nuestra terminal se ha divido en dos pantallas virtuales apiladas una encima de la otra.
~$ echo "shell 0"
shell 0
~$ _
<-- pantalla 0
*0 bash*********************************
<-- pantalla 1
*--*************************************
El cursor estará parpadeando en la pantalla superior. Para saltar a la segunda pantalla utilizamos "Ctrl+a" "Tab" (Tabulador) y el cursor parpadeante se mostrará ahora en la pantalla inferior indicando que es la ventana activa. Esta pantalla inferior inicialmente no tiene nada. Para darle vida, utilizamos el comando screen "Ctrl+a" "c" (minúscula). Esto ejecutará una shell nueva en la misma.
~$ echo "shell 0"
shell 0
~$ _
<-- pantalla 0
*0 bash*********************************
~$
<-- pantalla 1
*--*************************************
Ahora nuestra sesión screen se compone de 2 pantallas y 2 shells. Las shells y las pantallas son independientes en screen. Podemos tener una sóla pantalla y 3 shells o 3 pantallas y una sóla shell (aunque este último caso no es muy útil). Para no liar primero veremos cómo listar las shells activas. Pulsando "Ctr+a" "comillas" (comillas dobles) veremos algo similar a:
~$ echo "shell 0"
shell 0
~$ _
<-- pantalla 0
*0 bash*********************************
Num Name Flags
0 bash
*1 bash********************************* <-- pantalla 1
*--*************************************
"Ctr+a" comillas muestra el listado de shells creadas (recordemos mediante el comando "Ctrl+a" "c") y en negrita la shell activa en la pantalla. De momento pulsamos enter que selecciona la shell 1 en la pantalla 1 y a continuación ejecutamos el comando echo "shell 1":
~$ echo "shell 0"
shell 0
~$ _
<-- pantalla 0
*0 bash*********************************
~$ echo "shell 1"
shell 1
<-- pantalla 1
*--*************************************
Si a continuación creamos una tercera shell mediante "Ctrl+a" "c" nos encontramos con:
~$ echo "shell 0"
shell 0
~$ _
<-- pantalla 0
*0 bash*********************************
~$
<-- pantalla 1
*--*************************************
Para no perdernos volvemos a listar las shells creadas mediante "Ctrl+a" "comillas" (comillas dobles):
~$ echo "shell 0"
echo "shell 0"
~$ _
<-- pantalla 0
*0 bash*********************************
Num Name Flags
0 bash
1 bash
*2 bash********************************* <-- pantalla 1
*--*************************************
Vemos que lo que ha ocurrido es que ahora en la pantalla 1 se visualiza la shell 2. Si queremos volver a mostrar la shell 1 en la pantalla 1, mediante las flechas del cursor seleccionamos la shell 1 y pulsamos enter volviendo a la pantalla:
~$ echo "shell 0"
shell 0
~$ _
<-- pantalla 0
*0 bash*********************************
~$ echo "shell 1"
shell 1
<-- pantalla 1
*--*************************************
Por el momento nos olvidamos de las pantallas. Finalizamos la pantalla activa 1 mediante "Ctr+a" "X" y volvemos a tener una única pantalla que ocupa toda la ventana de nuestra terminal X:
~$ echo "shell 0" shell 0 ~$ _
Recordemos que las pantallas y las shells son totalmente independientes para Screen. Ahora podemos visualizar la shell 1 o 2 seleccionandolas en el listado de shells con "Ctrl+a" Comillas (dobles):
Num Name Flags *0 bash********************************* 1 bash 2 bash
Vamos a la shell 1 seleccionando con el cursor:
~$ echo "shell 1" shell 1
Hora de comer. Nos desligamos de la sesión screen ("Ctrl+a" "d") volviendo al momento en que nos reconectamos:
~$ screen -r [detached] ~$ _
Cerramos la terminal X y nuestro entorno gráfico (GNOME/KDE/Xfce/...) hasta más adelante.
Preguntas frecuentes editar
P:¿Cómo terminar una sesión de screen?
R: La sesión termina cuando salimos de la última shell. Es decir basta hacer un "exit" sobre cada shell activa.
P:¿Puede compartirse una sesión de screen entre varios usuarios?
R: Sí. El primero de ellos crea la sesión o se reconecta mediante "screen -r". El resto de usuarios utilizará "screen -x". En ese momentos cada usuario podrá ver y editar lo que hacen los demás usuarios (siempre y cuando visualicen la misma shell dentro de la sesión).
P:¿Existe la opción de dividir la pantalla verticalmente en vez de horizontalmente?
R: Sí, utilizando "Ctrl+a" | (tubería -Alt+1 en teclados en Español-), aunque dependiendo de la configuración de emulación de terminal falla en determinados entornos, al menos en el momento de escribir estas líneas (Enero de 2010).
Problemas típicos editar
- Algunas versiones antiguas de screen incluye un comando para bloquear la pantalla. Si bloqueamos por error la misma no funcionará nada. La forma de solucionarlo es pulsar "Ctrl+a" "q".
- En ocasiones la terminal X o la sesión de red muere de forma abrupta y screen no se entera de que nos hemos desligado de la sesión. Al intentar reconectar nos indicará que ya hay una sesión de screen pendiente de reconexión. Entonces forzamos la reconexión mediante la opción D. En vez de utilizar "screen -r" utilizamos "screen -rD" que le indica a screen que se olvide de otras sesiones activas.
- La sesión de screen muere si apagamos el pc/servidor donde se ejecuta. Es decir no guarda el estado de screen en disco de forma milagrosa.
Buenas prácticas editar
- En nuestros ejemplos creábamos una sesión mediante el comando "screen" y reconectabamos mediante "screen -r". En la práctica es conveniente asignar un nombre a la sesión mediante el comando "-S nombreDeSesion" de forma que creamos una sesión mediante "screen -S nombreSesion" y reconectamos mediante "screen -r -S nombreSesion". Si conectamos a un servidor compartido por varios usuarios es conveniente añadir nuestro nombre de usuario al nombre de la sesión de screen. Por ejemplo podemos crear una sesión screen para compilación y otra para monitorización. La sesión de compilación puede durar lo que dure la compilación, mientras que la sesión de monitorización puede permanecer activa indefinidamente.
- Por ser más pedagógicos se utiliza el comando "Ctrl+a" comillas (dobles) para seleccionar la shell asociada a la ventana, pero en la práctica es más rápido utilizar "Ctrl+a" N, donde N es un número entre 0 y el número de shells activas como atajo de teclado rápido para saltar de una terminal a otra.
- "Ctrl+a" "A" permite asignar un título a cada shell de la sesión. Cuando listemos las shells activas se mostrará el título en vez de la sesión. P.ej, una shell puede titularse "config" indicando que en la misma estamos editando los ficheros de configuración, una segunda "compiling" inidicando que estamos haciendo un make y una tercera "logs" indicando que en la misma estamos viendo los logs con salida/errores.
- Unix/GNU/Linux son criticados frecuentemente por utilizar comandos de texto difíciles de memorizar. Sin embargo una vez que dominamos screen este problema se minimiza. Basta con guardar un resumen de las opciones útiles y editar los ficheros mediante una sesión de screen. En una pantalla superior tenemos siempre visible el resumen con las órdenes y en la pantalla inferior podemos editar el fichero de forma cómoda. No hay que olvidar que la configuración mediante comandos/ficheros de texto es mucho más versátil, segura y rápida que la configuración gráfica. P.ej, podemos colgar ejemplos de ficheros de configuración en wikibooks para compartirlos en internet y que otros puedan aprender o mejorar nuestro trabajo.
Sobre tmux editar
tmux es un software similar a screen y más moderno. En general el manejo es similar a screen con la diferencia de que utiliza las teclas de escape Ctrl+b en vez de Ctrl+a para introducir comandos. Su diseño es del año 2007, (las primeras versiones de screen datan de los años 80) y fué realizado con el propósito de mejorar las carencias de screen. Probablemente es una opción preferible a screen siempre y cuando tmux esté disponible en nuestro sistema.