ssh-manager.sh (sshm 5.0)
Synthèse de ssh-manager.sh (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
LocaletDistantsont 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. Optaccepte 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 dontOpt=srv, viaProxyCommand. C’est automatique pour les hôtesOpt=pxy.mesh: utilise l’IP de la colonneIpMesh, 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
- Configuration et couleurs, désactivées si la sortie n’est pas un terminal.
- Utilitaires :
run(affiche puis exécute la commande),has_flag,key_path,check_host. load_hostslit le CSV une seule fois dans un tableau associatifH["alias,champ"].prepareconstruit les options ssh une seule fois (-p,-i,ProxyCommand) et leuser@hôte.- Une fonction par commande (
cmd_exe,cmd_tmux,cmd_web,cmd_vnc) et unmainqui 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 -wacceptait des correspondances partielles. vncne tue plus tous lessshen cours, et il passe maintenant le port dans le cas sans clé.- Les commandes passées à
exene sont plus mal découpées.
Limites à connaître
- Le ping n’est fait que si
Ping=Y, et sanspinginstallé la colonne affiche[Non]. - Le mode groupe est séquentiel, pas parallèle.
webouvre une session shell avec le tunnel. Ajoutez-Ndanscmd_websi vous ne voulez que le tunnel.- Je n’ai pas pu tester
ping,columnetvncviewerdans mon environnement. Le reste a été vérifié avec un fauxssh.
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 "$@"