423 lines
11 KiB
Markdown
423 lines
11 KiB
Markdown
Quelques astuces SHell. Des bouts de commandes, ou simplement les arguments qui vont bien.
|
|
|
|
# Script
|
|
|
|
Style guide : <https://google.github.io/styleguide/shell.xml>
|
|
|
|
# Configuration
|
|
|
|
## Initialisation du shell
|
|
|
|
Entre les 3 modes ("login", "interactive non-login" et "non-interactive non-login") il y a de quoi se perdre à propos des fichiers chargés. Voici un rappel assez complet : <https://github.com/rbenv/rbenv/wiki/Unix-shell-initialization>
|
|
|
|
## History Bash
|
|
|
|
`bashrc` :
|
|
|
|
~~~
|
|
export HISTCONTROL=$HISTCONTROL${HISTCONTROL+,}ignoreboth
|
|
export HISTSIZE=65535
|
|
export HISTTIMEFORMAT="%c : "
|
|
~~~
|
|
|
|
> *Note* : si besoin on peut `chattr +a /root/.bash_history` pour empêcher sa suppression
|
|
|
|
## Changer l'éditeur de texte par défaut pour une commande
|
|
|
|
Normalement le script (vipw, vigr, -ldapvi, ...) se réfère aux fichiers scripts (qui ne sont que des liens vers les binaires) :
|
|
|
|
~~~{.bash}
|
|
/etc/alternatives/
|
|
~~~
|
|
|
|
Sinon en ligne de commande :
|
|
|
|
~~~{.bash}
|
|
$ EDITOR=nano vipw
|
|
~~~
|
|
|
|
# Manipulations
|
|
|
|
## Tâches de fond
|
|
|
|
~~~{.bash}
|
|
$ bg = "mettre en arrière plan"
|
|
$ fg = "mettre en premier plan"
|
|
$ jobs = "lister les tâches de fond"
|
|
%% = "dernier job utilisé (représenté par un +)"
|
|
%x = "job numéro x"
|
|
~~~
|
|
|
|
~~~{.bash}
|
|
$ vi foo
|
|
^Z
|
|
[1]+ Stopped vi foo
|
|
$ tail -f bar
|
|
...
|
|
^C
|
|
$ fg
|
|
^Z
|
|
[1]+ Stopped vi foo
|
|
$ kill -9 %%
|
|
|
|
[1]+ Killed vi foo
|
|
$ ( sleep 1m; echo "Premier !" ) &
|
|
[1] 13649
|
|
$ ( sleep 30; echo "Deuxième !" ) &
|
|
[2] 13651
|
|
$ jobs
|
|
[1]- Running sleep 1m && echo ...
|
|
[2]+ Running sleep 30 && echo ...
|
|
$ fg %2
|
|
^Z
|
|
[2]+ Stopped sleep 30 && echo ...
|
|
$ jobs
|
|
[1]- Running sleep 1m && echo ...
|
|
[2]+ Stopped sleep 30 && echo ...
|
|
$ sleep 30; bg
|
|
Premier !
|
|
[2]- Done sleep 30 && echo ...
|
|
Deuxième !
|
|
$ jobs
|
|
[1]- Done sleep 1m && echo ...
|
|
$ vi foo
|
|
^Z
|
|
[1]+ Stopped vi foo
|
|
$ exit
|
|
There are stopped jobs.
|
|
$ kill -9 %% #fg :x
|
|
$ exit
|
|
~~~
|
|
|
|
## Connaître le rang d'un élément dans une liste
|
|
|
|
Utilisation de **tac** pour inverser la liste, sans la trier :
|
|
|
|
~~~{.bash}
|
|
$ ./liste_serveur.sh | tac | grep -n NOUVEAU_SERVEUR
|
|
2:NOUVEAU_SERVEUR
|
|
~~~
|
|
|
|
-> 'grep -n' reviens au même que 'nl | grep'
|
|
|
|
## Ajout mot en début de chaque ligne d'un buffer
|
|
|
|
~~~{.bash}
|
|
$ sed 's/^/Coucou /g' <<<"$VAR"
|
|
~~~
|
|
|
|
## Avoir le 'fingerprint' SSH d'une liste de serveur
|
|
|
|
-> pour s'assurer que le host soit connu (~/.ssh/known_hosts) et ainsi automatiser des tâches sur des serveurs même si toujours aucune connexion effectuée et acceptée :
|
|
|
|
~~~{.bash}
|
|
$ (for host in machine1 machine2 ...; do echo $host; timeout -k 2 2 ssh -o 'StrictHostKeyChecking no' $host cat /etc/ssh/ssh_host_dsa_key.pub >> ~/.ssh/known_hosts; done)
|
|
~~~
|
|
|
|
# Fichiers et FS
|
|
|
|
## Ordinaire
|
|
|
|
### Savoir si lignes en doublon dans un fichier
|
|
|
|
~~~{.bash}
|
|
$ uniq -d <fichier>
|
|
~~~
|
|
|
|
ou autrement (appliquer un filtre différent) :
|
|
|
|
~~~{.bash}
|
|
$ diff <fichier> <(cat <fichier> | uniq)
|
|
~~~
|
|
|
|
### Comparer deux fichiers quant à l'existence de nouvelles lignes
|
|
|
|
~~~{.bash}
|
|
$ grep -F -x -v -f <fichier1> <fichier2>
|
|
~~~
|
|
|
|
### Supprimer des vieux fichiers
|
|
|
|
- Par exemple, si + vieux de 30 jours en modification :
|
|
|
|
~~~{.bash}
|
|
$ find DIR/ -type f -mtime +30 -delete
|
|
$ find DIR/ -type f -mtime +30 -exec rm '{}' \;
|
|
~~~
|
|
|
|
### Comparer deux fichiers à travers SSH
|
|
|
|
~~~{.bash}
|
|
$ diff <fichier> <(ssh REMOTE cat <fichier>)
|
|
~~~
|
|
|
|
## Droits
|
|
|
|
### Changer propriétaires owner et group selon actuels
|
|
|
|
~~~{.bash}
|
|
$ chown -c -R --from user:user userbis:userbis .
|
|
$ chown -c -R --from www-user:user www-userbis:userbis .
|
|
~~~
|
|
|
|
### Copier seulement les droits de deux hiérarchies de fichiers
|
|
|
|
## Répertoire
|
|
|
|
### Surveiller les ouvertures/écriture des fichiers présent dans un répertoire
|
|
|
|
~~~{.bash}
|
|
$ iwatch <target>
|
|
~~~
|
|
|
|
### Savoir les différents users qui ont écris dans /tmp
|
|
|
|
~~~{.bash}
|
|
$ stat -c %U /tmp/* | sort | uniq -c | sort -n
|
|
~~~
|
|
|
|
Si «too arguments pour stat» (version bien plus lente) :
|
|
|
|
~~~
|
|
$ find /tmp -exec stat -c %U '{}' \; | sort | uniq -c | sort -n
|
|
~~~
|
|
|
|
### Comparer deux répertoires à travers SSH
|
|
|
|
Générique :
|
|
|
|
~~~{.bash}
|
|
$ DIR=$PWD
|
|
$ for file in $(rsync -rvn $DIR REMOTE:$DIR | grep -v "^skipping non-regular file" | head -n -2); do echo $DIR/$file :; diff $DIR/$file <(ssh REMOTE cat $DIR/$file); done
|
|
~~~
|
|
|
|
Pour /etc/ :
|
|
|
|
~~~
|
|
# for file in $(rsync -rvn /etc/ --exclude=*.log --exclude=ssh --exclude=ssl --exclude=.git --exclude=shadow* --exclude=gshadow* REMOTE:/etc/ | \
|
|
grep -v "^skipping non-regular file" | head -n -2); do \
|
|
echo /etc/$file :; diff /etc/$file <(ssh REMOTE cat /etc/$file); done
|
|
~~~
|
|
|
|
## Espace et Inode
|
|
|
|
### Analyse disque
|
|
|
|
Quand il s'agit de / - penser à exclure les autres partitions (si existante de toute évidence) :
|
|
|
|
~~~
|
|
# ncdu / --exclude /home --exclude /srv --exclude /var --exclude /tmp --exclude /boot --exclude /usr --exclude /proc
|
|
~~~
|
|
|
|
Pour certaines anciennes versions :
|
|
|
|
~~~
|
|
# ncdu --exclude "/home/*" /
|
|
~~~
|
|
|
|
Sinon voir du côté de [HowtoDUC](/HowtoDUC).
|
|
|
|
### Tester l'écriture disque
|
|
|
|
Simplement, en écriture (fichier de 5.1GB) :
|
|
|
|
~~~{.bash}
|
|
$ dd if=/dev/zero of=test count=10000000
|
|
~~~
|
|
|
|
### Lister les répertoires ayant le plus de fichiers <=> max inode
|
|
|
|
~~~{.bash}
|
|
PATH_TO_WATCH='/var'; RESULT_FILE='list_max_inode.txt'; TMP=$(mktemp)
|
|
#Regarder dans le premier niveau
|
|
(for i in $(find $PATH_TO_WATCH -type d); do echo $(ls -a "$i" | wc -l) $i; done) | sort -n > $TMP
|
|
#compter dans les sous niveaux
|
|
cat $TMP | (while read line; do num=$(echo $line | awk '{ print $1 }'); path=$(echo $line | awk '{ print $2 }'); echo ${path%/*}; done) | sort | uniq | (while read line; do echo $(grep "$line" $TMP | cut -f1 -d' ' | xargs echo -n | tr -s ' ' '+' | xargs echo | bc -l) $line; done) | sort -n | tee $RESULT_FILE
|
|
rm $TMP
|
|
~~~
|
|
|
|
# Utilisateurs UNIX
|
|
|
|
## Lister les utilisateurs + groupe
|
|
|
|
### UNIX
|
|
|
|
~~~{.bash}
|
|
$ for user in $(getent passwd | awk -F ':' '$3 > 10000 {printf $1 " "}'); do groups $user; done
|
|
~~~
|
|
|
|
### LDAP
|
|
|
|
~~~{.bash}
|
|
$ for user in $(getent passwd | awk -F ':' '$3 > 10000 {printf $1 " "}'); do \
|
|
ldapsearch -x -h localhost -LLL -b "dc=MACHINE,dc=DOMAIN,dc=COM" cn | tail -n2 | \
|
|
tr '\n' ' ' | cut -d':' -f2 | echo -n "$(cat <&0)"; echo = $(groups $user); done
|
|
~~~
|
|
|
|
# Serveur web
|
|
|
|
## Avoir un rendu des requêtes par IP à partir d'un access.log
|
|
|
|
Selon le format, il faudra peut-être changer la valeur du field de cut (-f1 par -f2).
|
|
|
|
### Compte rendu pour un laps de temps
|
|
|
|
~~~{.bash}
|
|
$ date; (timeout 60 tail -f access.log | cut -d' ' -f1) | sort | uniq -c | sort -n
|
|
~~~
|
|
|
|
### En direct
|
|
|
|
- Version simple :
|
|
|
|
~~~{.bash}
|
|
$ tail -f access.log | stdbuf -oL cut -d ' ' -f1 | uniq -c
|
|
~~~
|
|
|
|
- Version couleur :
|
|
|
|
~~~{.bash}
|
|
$ SEUIL=5; tail -f access.log | stdbuf -oL cut -d ' ' -f1 | stdbuf -oL uniq -c | \
|
|
eval "awk '\$1 > $SEUIL {printf \"\\033[1;31m\" \$1 \" \" \$2 \"\\033[0m \\n\"; next;};{printf \$1 \" \" \$2 \"\\n\";}'"
|
|
~~~
|
|
|
|
## Comparer les requêtes effectués dans access.log
|
|
|
|
Les différentes requêtes sont comparés aux nombres de caractères différent. La variable SEUIL est la limite de caractères différents pour 2 requêtes.
|
|
|
|
~~~{.bash}
|
|
SEUIL=20; i=1; lastline=; cat access.log | sed 's/.*\] \(.*\)\" [0-9]\{3\}.*$/\1\"/' | \
|
|
(while read line; do diff=$(cmp -bl <(echo "$lastline") <(echo "$line") 2>/dev/null | wc -l); \
|
|
((diff<SEUIL)) && ((i=i+1)) || { echo "$i $line"; i=1; }; lastline="$line"; done)
|
|
~~~
|
|
|
|
Si on veut les adresses IPs, ou simplement trier le access.log avant l'analyse, il faut modifier après le : cat acccess.log |
|
|
|
|
Et si l'on considère les mots comme une seule différence (et non par caractères), on peut descendre le seuil :
|
|
|
|
~~~{.bash}
|
|
SEUIL=3; i=1; lastline=; cat access.log | sed 's/.*\] \(.*\)\" [0-9]\{3\}.*$/\1\"/' | \
|
|
(while read line; do diff=$(cmp -bl <(echo "$lastline") <(echo "$line") 2>/dev/null | awk '{print $1}' | \
|
|
(compt=0; lastnumber=0; while read number; do ((lastnumber+1!=number)) && ((compt=compt+1)); lastnumber=$number; done; echo $compt)); \
|
|
((diff<SEUIL)) && ((i=i+1)) || { echo "$i $line"; i=1; }; lastline="$line"; done)
|
|
~~~
|
|
|
|
C'est à dire que entre 2 requêtes du type :
|
|
|
|
- /page.do?pseudo=Example&pass=0322
|
|
- /page.do?pseudo=Mail&pass=3892
|
|
|
|
il n'y a que 2 différences : le «pseudo», et le «pass».
|
|
|
|
# Processus / Process
|
|
|
|
## Surveiller les nouveaux processus créés
|
|
|
|
### Liste simple
|
|
|
|
~~~{.bash}
|
|
$ ps -e -o etimes=,pid,cmd | sort -rn | awk '{if ($1!=0 && $3!~/\[.*\]/) print $0 }'
|
|
~~~
|
|
|
|
### Watch
|
|
|
|
Toutes les 5 secondes :
|
|
|
|
~~~{.bash}
|
|
$ watch -n 5 -d "ps -e -o etimes=,pid,user,cmd | sort -n | awk '{if (\$1==0 || \$2==$$ || \$3~/watch/ || \$3~/\[.*\]/) {} else print \$0 }'"
|
|
~~~
|
|
|
|
Se baser seulement par rapport aux utilisateurs ayant créés dernièrement ces processus (SEUIL <=> processus vieux de moins de $SEUIL secondes) :
|
|
|
|
~~~{.bash}
|
|
$ SEUIL=100; watch -n 5 -d "ps -e -o etimes=,user | sort -n | awk '{if (\$1<$SEUIL) print \$2 }' | sort | uniq -c | sort -n"
|
|
~~~
|
|
|
|
## Lister avec le plus de fils (/fork)
|
|
|
|
~~~{.bash}
|
|
(total_procs=0; for foo in $(ps -e -o ppid | sed '1d' | sort -n | uniq -c | sort -n | awk '{ print $1 ":" $2 }'); do val=$(echo $foo | cut -d: -f1); total_procs=$((total_procs+val)); pid=$(echo $foo | cut -d: -f2); (( pid != 0 )) && { echo -n $val ') '; ps -p $pid -o pid,cmd | tail -n1; }; done; echo Total = $total_procs) | tail
|
|
~~~
|
|
|
|
## Consommation Swap
|
|
|
|
~~~{.bash}
|
|
(for file in /proc/*; do [ -e $file/status ] || continue; PID=$(basename $file); RES=$(grep VmSwap: $file/status | sed 's/VmSwap\:[[:space:]]*\(.*\)/\1/'); [ -n "$RES" ] && echo $RES ' = ' $PID ' ' $(ps -p $PID -o cmd --no-headers); done) | sort -n
|
|
~~~
|
|
|
|
## Consommation RAM (VmSize)
|
|
|
|
~~~{.bash}
|
|
$ top -o RES
|
|
~~~
|
|
|
|
### Par utilisateur
|
|
|
|
~~~{.bash}
|
|
for var in users1 users2; do echo '#' $var ':'; ps -u $var -o pid= | while read pid; do echo -n $pid ') threads: ' "$(ps -p $pid -T | wc -l)" "; $(grep VmSize /proc/$pid/status)"; echo; vmsize=$(grep VmSize /proc/$pid/status | sed 's/^VmSize:\s*\([0-9]*\) kB/\1/'); done; done
|
|
for var in $(getent passwd | cut -d':' -f1); do echo '#' $var ':'; ps -u $var -o pid= | while read pid; do echo -n $pid ') threads: ' "$(ps -p $pid -T | wc -l)" "; $(grep VmSize /proc/$pid/status)"; echo; vmsize=$(grep VmSize /proc/$pid/status | sed 's/^VmSize:\s*\([0-9]*\) kB/\1/'); done; done
|
|
~~~
|
|
|
|
## Fichiers ouverts
|
|
|
|
### socket/port
|
|
|
|
- Connaître les sockets ouvertes et ports en écoutent par un processus :
|
|
|
|
~~~{.bash}
|
|
$ lsof -Pan -p PID -i
|
|
~~~
|
|
|
|
- Connaître le pid qui écoute sur un port (2ème colonne) :
|
|
|
|
~~~{.bash}
|
|
$ lsof -i :Port
|
|
~~~
|
|
|
|
### Selon l'utilisateur
|
|
|
|
~~~
|
|
# lsof -u UID
|
|
~~~
|
|
|
|
Si www-data a uid=33, lister fichiers ouvert par serveur-web :
|
|
|
|
~~~
|
|
# lsof -u 33 | awk '{ print $2 " = " $9 }' | grep "/home/.*$"
|
|
~~~
|
|
|
|
## Créer un fichier "dummy" de différentes tailles
|
|
|
|
Pour tester les performances d'un FTP ou autre on a besoin d'envoyer un fichier volumineux ou pas, voici comment créer un fichier vide (dummy) d'une certaine taille avec dd :
|
|
|
|
Pour un fichier de 10Mio :
|
|
|
|
~~~
|
|
dd if=/dev/zero of=10M.bin bs=1024 count=0 seek=$[1024*100]
|
|
~~~
|
|
|
|
Pour 100Mio :
|
|
|
|
~~~
|
|
dd if=/dev/zero of=100M.bin bs=1024 count=0 seek=$[1024*1000]
|
|
~~~
|
|
|
|
Pour 1Gio :
|
|
|
|
~~~
|
|
dd if=/dev/zero of=1G.bin bs=1024 count=0 seek=$[1024*1024]
|
|
~~~
|
|
|
|
## stdout / stderr
|
|
|
|
Renvoyer stdout/stderr dans une même sortie (par exemple /dev/null) :
|
|
|
|
~~~
|
|
eject /dev/coin > /dev/null 2>&1
|
|
~~~
|
|
|
|
Détecter les tabulations
|
|
|
|
~~~
|
|
$ grep -P '\t'
|
|
~~~ |