tutorial - ¿Cómo iniciar automáticamente tmux en la sesión SSH?

para que se usa elastic search

Question

Tengo aproximadamente diez servidores a los que me conecto con SSH de forma regular. Cada uno tiene una entrada en el archivo ~/.ssh/config mi computadora local.

Para evitar perder el control de mi proceso de ejecución cuando mi conexión a Internet se cae inevitablemente, siempre trabajo dentro de una sesión tmux . Me gustaría una manera de hacer que tmux se conecte automáticamente cada vez que se inicia una conexión SSH, por lo que no tengo que escribir siempre tmux attach || tmux new tmux attach || tmux new después de que SSH en.

Desafortunadamente, esto no está resultando ser tan simple como originalmente esperaba.

• No quiero agregar ningún comando a ~/.bashrc en los servidores porque solo lo quiero para sesiones SSH, no para sesiones locales.
• Agregar tmux attach || tmux new tmux attach || tmux new en ~/.ssh/rc en los servidores, simplemente da como resultado el error de que not a terminal RequestTTY force not a terminal después de la conexión, incluso cuando la opción RequestTTY force se agrega a la línea para ese servidor en mi archivo de configuración SSH local.

Answer 1

Configuración del lado del servidor:

Para iniciar automáticamente tmux en su servidor remoto cuando inicie sesión normalmente a través de SSH (y solo SSH), edite el ~/.bashrc de su usuario o root (o ambos) en el servidor remoto en consecuencia:

if [[ -z "$TMUX" ]] && [ "$SSH_CONNECTION" != "" ]; then
    tmux attach-session -t ssh_tmux || tmux new-session -s ssh_tmux
fi

Este comando crea una sesión tmux llamada ssh_tmux si no existe, o se vuelve a conectar a una sesión ya existente con ese nombre. En caso de que su conexión se haya caído o cuando olvidó una sesión hace semanas, cada inicio de sesión SSH lo regresa automáticamente a la sesión tmux-ssh que dejó atrás.

Conéctese desde su cliente:

Nada especial, solo ssh user@hostname .

Answer 2

Como se describe en esta publicación de blog , puede ssh y luego adjuntarlo a una sesión tmux existente con un solo comando:

ssh hostname -t tmux attach -t 0

Answer 3

En mi humilde opinión, faltan dos posibles soluciones de la lista de respuestas:

1. Usando el archivo ~/.ssh/authorized_keys del host:

command="tmux attach-session -t mysession || tmux new-session -s mysession" ssh-ed25519 AAAAfoo23bar45foo23bar45foo23bar45foo23bar45foo23bar45foo23bar45foo23bar45 user@client

Esto, por supuesto, funcionará desde todos los clientes que tengan instalada la clave privada correspondiente, lo que podría ser una desventaja o una desventaja, dependiendo. Existe el riesgo de que, si algo sale mal, ya no sea posible ingresar al servidor.

2. Usando el ~/.ssh/config file del cliente, que @op ya está usando de todos modos:

Host myhost
  Hostname host
  User user
  RequestTTY yes # tmux needs a tty and won''t work without one!
                 # sometimes requires "force" instead of "yes".
  RemoteCommand tmux attach-session -t mysession || tmux new-session -s mysession

Teniendo en cuenta el riesgo con la opción (1), esta podría ser la mejor solución. En caso de problemas, las dos líneas simplemente deben comentarse.

Answer 4

Muy bien, encontré una solución principalmente satisfactoria. En mi ~/.bashrc local, escribí una función:

function ssh () {/usr/bin/ssh -t $@ "tmux attach || tmux new";}

que básicamente sobrescribe la función de terminal ssh para llamar al programa ssh incorporado con los argumentos dados, seguido de "tmux attach || tmux new" .

( $@ Denota todos los argumentos proporcionados en la línea de comando, por lo que ssh -p 123 user@hostname se expandirá a ssh -t -p 123 user@hostname "tmux attach || tmux new" )

(El argumento -t es equivalente a RequestTTY Force y es necesario para el comando tmux).

Answer 5

Puede resultarle útil: utiliza ssh en un bucle y se vuelve a conectar o se conecta a una sesión tmux existente para que tenga una manera fácil y confiable de reconectarse después de una interrupción de la red

#!/bin/bash
#
# reconnect to or spawn a new tmux session on the remote host via ssh.
# If the network connection is lost, ssh will reconnect after a small
# delay.
#

SSH_HOSTNAME=$1
TMUX_NAME=$2
PORT=$3

if [[ "$PORT" != "" ]]
then
    PORT="-p $PORT"
fi

if [ "$TMUX_NAME" = "" ]
then
    SSH_UNIQUE_ID_FILE="/tmp/.ssh-UNIQUE_ID.$LOGNAME"

    if [ -f $SSH_UNIQUE_ID_FILE ]
    then
        TMUX_NAME=`cat $SSH_UNIQUE_ID_FILE`
        TMUX_NAME=`expr $TMUX_NAME + $RANDOM % 100`
    else
        TMUX_NAME=`expr $RANDOM % 1024`
    fi

    echo $TMUX_NAME > $SSH_UNIQUE_ID_FILE

    TMUX_NAME="id$TMUX_NAME"
fi

echo Connecting to tmux $TMUX_NAME on hostname $SSH_HOSTNAME

SLEEP=0
while true; do

    ssh $PORT -o TCPKeepAlive=no -o ServerAliveInterval=15 -Y -X -C -t -o BatchMode=yes $SSH_HOSTNAME "tmux attach-session -t $TMUX_NAME || tmux -2 -u new-session -s $TMUX_NAME"
    SLEEP=10
    if [ $SLEEP -gt 0 ]
    then
        echo Reconnecting to session $TMUX_NAME on hostname $SSH_HOSTNAME in $SLEEP seconds
        sleep $SLEEP
    fi
done

Answer 6

Sé que estoy reviviendo un hilo antiguo, pero he trabajado en la solución bashrc y creo que tiene algún uso:

#attach to the next available tmux session that''s not currently occupied
if [[ -z "$TMUX" ]] && [ "SSH_CONNECTION" != "" ];
then
    for i in `seq 0 10`; do #max of 10 sessions - don''t want an infinite loop until we know this works
            SESH=`tmux list-clients -t "$USER-$i-tmux" 2>/dev/null` #send errors to /dev/null - if the session doesn''t exist it will throw an error, but we don''t care
            if [ -z "$SESH" ] #if there''s no clients currently connected to this session
            then
                tmux attach-session -t "$USER-$i-tmux" || tmux new-session -s "$USER-$i-tmux" #attach to it
                break #found one and using it, don''t keep looping (this will actually run after tmux exits AFAICT)
            fi #otherwise, increment session counter and keep going
    done

fi

Hay un límite en 10 (11) sesiones por ahora: no quería matar mi servidor con un bucle infinito en bashrc. Parece funcionar de manera bastante confiable, aparte del error de tmux fallando en la lista de clientes si la sesión no existe.

Answer 7

Utilicé líneas de @kingmeffisto (no se me permite comentar esa respuesta) y agregué una salida para que finalizar tmux también finalice la conexión ssh. Sin embargo, esto rompió las sesiones de SFTP, así que tuve que buscar $SSH_TTY lugar de $SSH_CONNECTION .

EDIT 4/2018: Se agregó una prueba para terminal interactiva a través de [[ $- =~ i ]] para permitir que herramientas como Ansible funcionen.

SID=$USER-$BASHPID
ssh user@host -t "tmux new-session -s $SID || tmux attach-session -t $SID"

Answer 8

byobu es un buen contenedor útil para tmux / screen. Se conecta a una sesión existente si está presente o crea una nueva.

Lo uso con autossh que reconecta con gracia la sesión ssh. Muy recomendable en caso de problemas de conectividad intermitente.

function ssh-tmux(){
  if ! command -v autossh &> /dev/null; then echo "Install autossh"; fi
  autossh -M 0 $* -t ''byobu || {echo "Install byobu-tmux on server..."} && bash''
}

Answer 9

Conectar:

if [ -z "$TMUX" ] && [ -n "$SSH_TTY" ] && [[ $- =~ i ]]; then
    tmux attach-session -t ssh || tmux new-session -s ssh
    exit
fi

Durante la sesión:

Use Ctrl+d para finalizar la sesión (la ventana de tmux se cierra) o Ctrl+bd para desconectarse temporalmente de la sesión y conectarse de nuevo más tarde.

¡Recuerda! Si su servidor reinicia la sesión perdida!

Cuando esté dentro de tmux en cualquier momento, puede usar Ctrl+bs para ver la lista de sesiones y cambiar la corriente a otra.

Arregle su .bashrc:

Le recomiendo que defina la función universal en su .bashrc :

ssh user@host -t "tmux new-session -s user || tmux attach-session -t user"

Utiliza 22 puertos por defecto. Defina también sus alias de conexión rápida:

function tmux-connect {
    TERM=xterm-256color ssh -p ${3:-22} $1@$2 -t "tmux new-session -s $1 || tmux attach-session -t $1"
}

Iniciar sesión sin contraseña:

Y si no desea escribir la contraseña cada vez que generar claves .ssh para iniciar sesión automáticamente :

alias office-server=''tmux-connect $USER 192.168.1.123''
alias cloud-server=''tmux-connect root my.remote.vps.server.com 49281''

Pon tu clave pública al host remoto:

ssh-keygen -t rsa
eval "$(ssh-agent -s)" && ssh-add ~/.ssh/id_rsa

Consejos adicionales:

Si desea usar una sesión-id temporal que corresponde con una sesión bash local, use como tmux id:

ssh-copy-id -p <port> user@hostname