Post

Gestion des connexions ssh (sshm 5.0)

Un gestionnaire de connexions SSH piloté par un inventaire CSV

Gestion des connexions ssh (sshm 5.0)

Rôle

Un gestionnaire de connexions SSH piloté par un inventaire CSV (~/.ssh/.ssh_servers, modifiable avec SSHM_HOSTS). Il liste les serveurs, s’y connecte, exécute des commandes, ouvre des tunnels et passe par un proxy ou le réseau mesh.

Inventaire CSV

  • Séparateur ;, première ligne = en-tête. Les colonnes sont repérées par leur nom, donc leur ordre est libre.
  • Colonnes utilisées : Alias, User, IPouDomain, Port_SSH, SSH_Key, Ping, Opt, IP4_6, IpMesh.
  • Les colonnes Local et Distant sont ignorées, car sshfs a été retiré.
  • Les lignes vides ou commençant par # sont ignorées. Un alias en double est signalé et ignoré.
  • Le port par défaut est 22. Une clé sans / est cherchée dans ~/.ssh.
  • Opt accepte plusieurs flags séparés par des virgules (ex. srv, pxy,debian).

Commandes

Commande Effet
sshm tableau des serveurs : ping parallèle si Ping=Y, clé manquante en rouge
sshm alias session SSH
sshm alias exe 'cmd' exécute une commande distante (sans commande : session interactive)
sshm alias tmux tmux attach, sinon nouvelle session
sshm alias web <local> <dist> tunnel -L local:localhost:dist
sshm alias vnc [port] tunnel (local 55444) + vncviewer, puis fermeture de ce seul tunnel
sshm <flag> exe 'cmd' la commande est lancée sur tous les serveurs dont Opt contient ce flag
sshm csv / sshm help affichage de l’inventaire en colonnes / aide

Modificateurs

  • proxy : passe par le serveur dont Opt=srv, via ProxyCommand. C’est automatique pour les hôtes Opt=pxy.
  • mesh : utilise l’IP de la colonne IpMesh, avec une erreur si elle est vide.
  • Ils se placent avant la commande : sshm alias mesh exe uptime.

Mode groupe (flag dans Opt)

  • N’accepte que exe, avec une commande obligatoire.
  • Les serveurs sont traités l’un après l’autre, avec un en-tête par serveur et un délai de connexion de 5 s.
  • Une erreur sur un serveur n’arrête pas la boucle.
  • Le bilan final liste les échecs, et le code de sortie est non nul s’il y en a.
  • Si un nom est à la fois un alias et un flag, l’alias l’emporte.

Structure du code

  1. Configuration et couleurs, désactivées si la sortie n’est pas un terminal.
  2. Utilitaires : run (affiche puis exécute la commande), has_flag, key_path, check_host.
  3. load_hosts lit le CSV une seule fois dans un tableau associatif H["alias,champ"].
  4. prepare construit les options ssh une seule fois (-p, -i, ProxyCommand) et le user@hôte.
  5. Une fonction par commande (cmd_exe, cmd_tmux, cmd_web, cmd_vnc) et un main qui analyse les arguments.

Par rapport à la version 3.1

  • Le fichier passe de 612 à environ 300 lignes, sans duplication « avec clé / sans clé ».
  • L’alias est cherché en correspondance exacte, alors que grep -w acceptait des correspondances partielles.
  • vnc ne tue plus tous les ssh en cours, et il passe maintenant le port dans le cas sans clé.
  • Les commandes passées à exe ne sont plus mal découpées.

Limites à connaître

  • Le ping n’est fait que si Ping=Y, et sans ping installé la colonne affiche [Non].
  • Le mode groupe est séquentiel, pas parallèle.
  • web ouvre une session shell avec le tunnel. Ajoutez -N dans cmd_web si vous ne voulez que le tunnel.
  • Je n’ai pas pu tester ping, column et vncviewer dans mon environnement. Le reste a été vérifié avec un faux ssh.

Le script ssh-manager.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
#!/usr/bin/env bash
#==============================================================================
# sshm — gestionnaire de connexions SSH piloté par un inventaire CSV
#
#   sshm                       liste des serveurs (ping des lignes Ping=Y)
#   sshm <alias> [mod] [cmd]   connexion / commande (voir : sshm help)
#
# Les colonnes du CSV sont repérées par le NOM de l'en-tête (ordre libre).
# Opt peut contenir plusieurs flags séparés par une virgule (ex. srv,debian).
#   Un flag sert de groupe : sshm debian exe 'ls -l' = exe sur chaque serveur du groupe.
# Colonnes reconnues : Alias, User, IPouDomain, Mesh, Port_SSH, SSH_Key,
#                      Ping, Opt, IP4_6   (les autres colonnes sont ignorées)
#==============================================================================
set -u

VERSION="5.0 03/11/2026"

#------------------------------ Configuration ---------------------------------
HOST_FILE="${SSHM_HOSTS:-$HOME/.ssh/.ssh_servers}"
KEY_DIR="$HOME/.ssh"          # dossier des clés (si le champ SSH_Key n'a pas de /)
DELIM=";"
DEFAULT_PORT=22
VNC_LOCAL_PORT=55444

#------------------------------ Couleurs --------------------------------------
if [[ -t 1 ]]; then
	RED=$'\e[31;1m'  GREEN=$'\e[32;1m'  YELLOW=$'\e[33;1m'  WHITE=$'\e[37;1m'
	LIGHTGREEN=$'\e[92;1m'  LIGHTYELLOW=$'\e[93;1m'  LIGHTBLUE=$'\e[94;1m'
	LIGHTCYAN=$'\e[96;1m'  DIM=$'\e[2m'  NORMAL=$'\e[0m'
else
	RED= GREEN= YELLOW= WHITE= LIGHTGREEN= LIGHTYELLOW= LIGHTBLUE= LIGHTCYAN= DIM= NORMAL=
fi

#------------------------------ Utilitaires -----------------------------------
die() { printf 'sshm: %s\n' "$*" >&2; exit 1; }

separator() { printf '%*s\n' 88 '' | tr ' ' "${1:-=}"; }

# Affiche la commande puis l'exécute
run() {
	printf '%s+ %s%s\n' "$DIM" "$(printf '%q ' "$@")" "$NORMAL" >&2
	"$@"
}

# Cellule de tableau : couleur, largeur, texte
cell() { printf '%s%-*s%s|' "$1" "$2" "$3" "$NORMAL"; }

# L'alias $1 possède-t-il le flag $2 dans la colonne Opt ?
has_flag() { local o=${H[$1,opt]:-}; o=${o// /}; [[ ",$o," == *",$2,"* ]]; }

# Chemin complet d'une clé (vide si pas de clé)
key_path() {
	[[ -z $1 ]] && return
	if [[ $1 == */* ]]; then printf '%s' "$1"; else printf '%s/%s' "$KEY_DIR" "$1"; fi
}

# Test de présence : ping -4/-6 selon la colonne IP4_6
check_host() {
	local host=$1 ipv=$2 flag=""
	[[ $ipv == 4 || $ipv == 6 ]] && flag="-$ipv"
	command -v ping >/dev/null || return 1
	ping ${flag:+"$flag"} -W 1 -c 1 "$host" >/dev/null 2>&1
}

#------------------------------ Inventaire ------------------------------------
declare -A COL=()      # nom normalisé de colonne -> index
declare -A H=()        # "alias,champ" -> valeur
ALIASES=()             # alias dans l'ordre du fichier

norm_col() {
	case "${1,,}" in
		alias|label)                  echo alias ;;
		user|utilisateur)             echo user ;;
		ipoudomain|ipordomain|ip|host|addr)      echo host ;;
		mesh|ipmesh)                  echo mesh ;;
		port_ssh|portssh|port)        echo port ;;
		ssh_key|keyssh|key|cle|clé)   echo key ;;
		ping|noping)                  echo ping ;;
		opt)                          echo opt ;;
		ip4_6|ipv)                    echo ipv ;;
	esac
}

load_hosts() {
	if [[ ! -f $HOST_FILE ]]; then
		mkdir -p "$(dirname "$HOST_FILE")" && : > "$HOST_FILE" || die "création de $HOST_FILE impossible"
	fi

	local line n=0 i name a f
	while IFS= read -r line || [[ -n $line ]]; do
		line=${line%$'\r'}
		[[ -z $line || $line == \#* ]] && continue
		IFS=$DELIM read -ra f <<< "$line"

		if (( n == 0 )); then                      # en-tête
			for i in "${!f[@]}"; do
				name=$(norm_col "${f[i]}")
				[[ -n $name ]] && COL[$name]=$i
			done
			for name in alias user host; do
				[[ -n ${COL[$name]+x} ]] || die "colonne '$name' absente de l'en-tête de $HOST_FILE"
			done
			n=1
			continue
		fi

		a=${f[${COL[alias]}]:-}
		[[ -z $a ]] && continue
		if [[ -n ${H[$a,alias]+x} ]]; then
			printf 'sshm: alias en double ignoré : %s\n' "$a" >&2
			continue
		fi
		ALIASES+=("$a")
		for name in "${!COL[@]}"; do
			H[$a,$name]=${f[${COL[$name]}]:-}
		done
	done < "$HOST_FILE"
}

#------------------------------ Préparation d'une connexion -------------------
SSH_OPTS=()   # options communes (-p, -i, ProxyCommand)
TARGET=""     # user@hôte

prepare() {
	local a=$1 use_mesh=$2 use_proxy=$3
	local user=${H[$a,user]:-} host=${H[$a,host]:-} port=${H[$a,port]:-} key

	if (( use_mesh )); then
		host=${H[$a,mesh]:-}
		[[ -n $host ]] || die "champ Mesh vide pour '$a'"
	fi
	[[ -n $host ]] || die "champ IPouDomain vide pour '$a'"

	SSH_OPTS=(-p "${port:-$DEFAULT_PORT}")
	key=$(key_path "${H[$a,key]:-}")
	[[ -n $key ]] && SSH_OPTS+=(-i "$key")
	TARGET="${user:+$user@}$host"

	if (( use_proxy )) || has_flag "$a" pxy; then
		local s p="" pk pport puser phost
		for s in "${ALIASES[@]}"; do
			has_flag "$s" srv && { p=$s; break; }
		done
		[[ -n $p ]] || die "aucun serveur proxy (Opt=srv) dans $HOST_FILE"
		puser=${H[$p,user]:-}; phost=${H[$p,host]:-}; pport=${H[$p,port]:-$DEFAULT_PORT}
		pk=$(key_path "${H[$p,key]:-}")
		SSH_OPTS+=(-o "ProxyCommand=ssh -W %h:%p -p $pport ${pk:+-i $(printf '%q' "$pk") }${puser:+$puser@}$phost")
	fi
}

#------------------------------ Affichage -------------------------------------
list_hosts() {
	local tmp i a st key ipv port
	tmp=$(mktemp -d) || die "mktemp impossible"

	# pings en parallèle
	for i in "${!ALIASES[@]}"; do
		a=${ALIASES[i]}
		[[ ${H[$a,ping]:-} == [Yy] ]] || continue
		( check_host "${H[$a,host]:-}" "${H[$a,ipv]:-}" && : > "$tmp/$i" ) &
	done
	wait

	separator
	echo "Aide: sshm help | Inventaire: sshm csv | Proxy: sshm alias proxy | Mesh: sshm alias mesh"
	echo "$0 | Version: $VERSION | Utilisateur: $(whoami)"
	separator

	printf '|'
	cell "$GREEN" 6 "Ping"; cell "$LIGHTBLUE" 10 "Alias"; cell "$WHITE" 10 "User"
	cell "$WHITE" 16 "IPv4v6"; cell "$LIGHTYELLOW" 5 "Port"
	cell "$LIGHTCYAN" 20 "SSH_Key"; cell "$LIGHTYELLOW" 12 "Opt"; echo
	separator -

	for i in "${!ALIASES[@]}"; do
		a=${ALIASES[i]}
		ipv=${H[$a,ipv]:-}
		port=${H[$a,port]:-$DEFAULT_PORT}

		if [[ ${H[$a,ping]:-} == [Yy] ]]; then
			if [[ -e $tmp/$i ]]; then
				st="[IP4]"; [[ $ipv == 6 ]] && st="[IP6]"
				printf '|'; cell "$GREEN" 6 "$st"
			else
				printf '|'; cell "$RED" 6 "[Non]"
			fi
		else
			printf '|'; cell "$RED" 6 "[---]"
		fi

		cell "$LIGHTBLUE" 10 "$a"
		cell "$WHITE" 10 "${H[$a,user]:-}"
		cell "$WHITE" 16 "${H[$a,host]:-}"
		cell "$LIGHTYELLOW" 5 "$port"

		key=${H[$a,key]:-}
		if [[ -z $key ]]; then cell "" 20 ""
		elif [[ -f $(key_path "$key") ]]; then cell "$LIGHTCYAN" 20 "$key"
		else cell "$RED" 20 "$key"
		fi

		cell "$LIGHTYELLOW" 12 "${H[$a,opt]:-}"
		echo
	done
	separator
	rm -rf "$tmp"
}

usage() {
	row() { printf '  %s%-30s%s %s\n' "$LIGHTGREEN" "$1" "$NORMAL" "$2"; }
	printf '%ssshm %s%s\n' "$WHITE" "$VERSION" "$NORMAL"
	printf 'Inventaire : %s\n\n' "$HOST_FILE"
	row "sshm"                         "liste des serveurs"
	row "sshm <alias>"                 "ouvre une session SSH"
	row "sshm <alias> exe 'cmd'"       "exécute une commande sur le serveur"
	row "sshm <flag> exe 'cmd'"        "idem sur tous les serveurs dont Opt contient <flag>"
	row "sshm <alias> tmux"            "tmux attach, sinon nouvelle session tmux"
	row "sshm <alias> web <loc> <dist>" "tunnel -L <loc>:localhost:<dist>"
	row "sshm <alias> vnc [port]"      "tunnel + vncviewer (distant 5901 par défaut)"
	row "sshm <alias> proxy ..."       "passe par le serveur Opt=srv (automatique si Opt=pxy)"
	row "sshm <alias> mesh ..."        "utilise l'IP du champ Mesh"
	row "sshm csv"                     "affiche l'inventaire en colonnes"
	row "sshm help"                    "cette aide"
	printf '\n  proxy et mesh se placent avant la commande : sshm alias mesh exe uptime\n'
	printf '  Hôte listé avec ping seulement si Ping=Y ; IP4_6 choisit ping -4 ou -6.\n'
}

#------------------------------ Commandes -------------------------------------
cmd_ssh()  { run ssh "${SSH_OPTS[@]}" "$TARGET"; }
cmd_exe()  { (( $# )) || { cmd_ssh; return; }; run ssh "${SSH_OPTS[@]}" "$TARGET" "$*"; }
cmd_tmux() { run ssh -t "${SSH_OPTS[@]}" "$TARGET" 'tmux attach || tmux new'; }

cmd_web() {
	(( $# == 2 )) || die "usage : sshm alias web <port local> <port distant>"
	run ssh -L "$1:localhost:$2" "${SSH_OPTS[@]}" "$TARGET"
}

cmd_vnc() {
	local rport=${1:-5901} sock
	sock=$(mktemp -u "${TMPDIR:-/tmp}/sshm-vnc.XXXXXX")
	run ssh "${SSH_OPTS[@]}" -M -S "$sock" -fN -L "$VNC_LOCAL_PORT:localhost:$rport" "$TARGET" || return
	vncviewer "localhost:$VNC_LOCAL_PORT"
	# ferme uniquement CE tunnel (et non tous les ssh en cours)
	ssh -S "$sock" -O exit "$TARGET" 2>/dev/null
}

#------------------------------ Programme principal ---------------------------
main() {
	case ${1:-} in
		help|-h|--help) usage; return ;;
		csv)            load_hosts; column -s "$DELIM" -t < "$HOST_FILE"; return ;;
		"")             load_hosts; list_hosts; return ;;
	esac

	load_hosts
	local name=$1 cmd use_mesh=0 use_proxy=0 group=0 targets=() a
	shift

	if [[ -n ${H[$name,alias]+x} ]]; then
		targets=("$name")
	else
		for a in "${ALIASES[@]}"; do has_flag "$a" "$name" && targets+=("$a"); done
		(( ${#targets[@]} )) || die "alias ou flag inconnu : $name"
		group=1
	fi

	cmd=${1:-}; (( $# )) && shift
	while [[ $cmd == proxy || $cmd == mesh ]]; do
		if [[ $cmd == proxy ]]; then use_proxy=1; else use_mesh=1; fi
		cmd=${1:-}; (( $# )) && shift
	done

	if (( group )); then
		[[ $cmd == exe && $# -gt 0 ]] || die "un flag de groupe s'utilise ainsi : sshm $name exe 'commande'"
		local fails=()
		for a in "${targets[@]}"; do
			printf '%s=== %s (%s) ===%s\n' "$LIGHTBLUE" "$a" "${H[$a,host]:-}" "$NORMAL"
			# sous-shell : une erreur sur un serveur n'interrompt pas la boucle
			( prepare "$a" "$use_mesh" "$use_proxy" &&
			  run ssh -n -o ConnectTimeout=5 "${SSH_OPTS[@]}" "$TARGET" "$*" ) || fails+=("$a")
		done
		separator
		printf '%d serveur(s), %d en échec%s\n' "${#targets[@]}" "${#fails[@]}" "${fails:+ : ${fails[*]}}"
		(( ${#fails[@]} == 0 ))
		return
	fi

	prepare "$name" "$use_mesh" "$use_proxy"

	case $cmd in
		"")   cmd_ssh ;;
		exe)  cmd_exe "$@" ;;
		tmux) cmd_tmux ;;
		web)  cmd_web "$@" ;;
		vnc)  cmd_vnc "$@" ;;
		*)    die "commande inconnue : $cmd (voir sshm help)" ;;
	esac
}

main "$@"
Cet article est sous licence CC BY 4.0 par l'auteur.