Comment tuer une session SSH démarrée avec l'option -f (exécutée en arrière-plan)

Je suis assez perdu à ce sujet. De la page de manuel:

 -f      Requests ssh to go to background just before command execution.

Après avoir démarré SSH avec l' -foption, j'ai un tunnel fonctionnel. Mais une fois que j'ai fini de l'utiliser, je ne sais pas comment continuer à interagir avec elle. Par exemple, je ne peux pas fermer le tunnel SSH lorsque je termine.

Les méthodes habituelles que je connais ne fonctionnent pas. Par exemple, jobsne renvoie rien. La ~commande n'est pas reconnue (et je ne sais pas exactement comment l'utiliser, de toute façon).

Cependant, il pgrepme dit que le tunnel SSH est toujours en cours d'exécution (après la fermeture du terminal, etc.). Comment interagir avec? Comment puis-je le fermer?

Une solution particulièrement intéressante pour les scripts consiste à utiliser master mode, avec un socket pour les commandes de contrôle:

ssh -f -N -M -S <path-to-socket> -L <port>:<host>:<port> <server>

Pour le refermer:

ssh -S <path-to-socket> -O exit <server>

Cela évite à la fois la recherche d’identificateurs de processus et les problèmes de minutage pouvant être associés à d’autres approches.

J'ai trouvé la solution ici: http://www.g-loaded.eu/2006/11/24/auto-closing-ssh-tunnels/

Le meilleur moyen - Tunnels à fermeture automatique

Comme il a été mentionné précédemment, au lieu d'utiliser la combinaison de commutateurs -f -N, nous pouvons simplement utiliser -f seul, mais également exécuter une commande sur la machine distante. Mais quelle commande doit être exécutée, puisqu'il suffit d'initialiser un tunnel?

C'est à ce moment que dormir peut être la commande la plus utile de toutes! Dans cette situation particulière, le sommeil présente deux avantages:

• il ne fait rien, donc aucune ressource n'est consommée
• l'utilisateur peut spécifier pendant combien de temps il sera exécuté

Comment cela aide à la fermeture automatique du tunnel SSH est expliqué ci-dessous.

Nous commençons la session SSH en arrière-plan, tout en exécutant la commande de veille pendant 10 secondes sur la machine distante. Le nombre de secondes n'est pas crucial. Dans le même temps, nous exécutons vncviewer exactement comme auparavant:

[me@local]$ ssh -f -L 25901:127.0.0.1:5901 me@remote.example.org sleep 10; \
          vncviewer 127.0.0.1:25901:1

Dans ce cas, le client ssh doit charger la session ssh en arrière-plan (-f), créer le tunnel (-L 25901: 127.0.0.1: 5901) et exécuter la commande de veille sur le serveur distant pendant 10 secondes (veille). dix).

La différence entre cette méthode et la précédente (-N switch) est que, dans ce cas, l'objectif principal du client ssh n'est pas de créer le tunnel, mais plutôt d'exécuter la commande de veille pendant 10 secondes. La création du tunnel est une sorte d'effet secondaire, un objectif secondaire. Si vncviewer n'était pas utilisé, le client ssh se fermerait au bout de la période de 10 secondes, car il n'aurait plus de travail à faire, détruisant le tunnel en même temps.

Lors de l'exécution de la commande sleep, si un autre processus, vncviewer dans ce cas, commence à utiliser ce tunnel et le maintient occupé au-delà de la période de 10 secondes, alors, même si le client ssh termine son travail distant (exécution de sommeil), il ne peut pas sortir car un autre processus occupe le tunnel. En d'autres termes, le client ssh ne peut pas détruire le tunnel car il devra également tuer vncviewer. Lorsque vncviewer cesse d'utiliser le tunnel, le client ssh se ferme également car il a déjà atteint son objectif.

De cette façon, aucun processus ssh n'est laissé en arrière-plan.

Pour supprimer le tunnel, utilisez ps -C sshou ps | grep sshou toute autre variante pour déterminer quel processus ssh exécute votre tunnel. Alors tuez-le.

Vous pouvez également rechercher le processus en déterminant celui qui a ce port ouvert:

netstat -lnpt | awk '$4 ~ /:1234$/ {sub(/\/.*/, "", $7); print $7}'

Si vous voulez tuer tous les clients ssh en cours d'exécution sur votre machine (en tant qu'utilisateur), vous pkill sshle ferez.

Comme l'ont répondu d'autres personnes ici, le pkill sshtue.

Pour créer un tunnel pouvant être ramené, je le lance screensans l' -foption, puis détache l'écran avec Ctrl-A D. Pour ramener le tunnel, appelez screen -r.

Quand je commence un tunnel avec:

ssh -fN -D 8080 SOME_IP_HERE -l LOGIN_NAME_HERE

• -f Demande à ssh de passer en arrière-plan juste avant l'exécution de la commande.
• -NN'exécutez pas de commande à distance. Ceci est utile pour simplement transférer des ports.
• -D Spécifie une redirection de port "dynamique" au niveau de l'application locale.
• -l Spécifie l'utilisateur à connecter en tant que sur la machine distante.

Je peux le fermer avec:

ps -lef | grep ssh | grep "8080" | awk "{print \$2}" | xargs kill

La meilleure solution que j'ai trouvée pour tuer tous les tunnels en une seule ligne de commande est

ps -lef|grep ssh|grep "\-L"|awk '{print $4}'|xargs kill

pour les sessions ssh, il suffit de supprimer l'option tunnel

ps -lef|grep ssh|awk '{print $4}'|xargs kill