Introduction
Q : Pourquoi maitriser le shell ?
R : Parce que ca fait gagner un temps fou, que c’est propre, pêrmbeau, systématique, rapide et quasi illimité en terme de possibilités.
Merci à Adrien Urban de NBS System pour la création de ce support. Il vous sera peut être utile pour dédoubloner un fichier de clients ou de commandes, peut être pour faire certains tris dans vos bases ou fichiers. Les hébergeurs comme NBS System ou d’autres fournissent des accès shell limités, mais qui permettent d’utiliser ces outils (ou une partie d’entre eux).
Ces outils seront d’ailleurs principalement utiles aux développeurs.
UNIX & son copain Posix, leurs vies, leurs œuvres
Voici un cour de shell bash/unix pour les gens qui ne sont pas à l’aise avec, essentiellement les développeurs. Ca fait gagner un temps fou.
C’est volontairement simplifié, le but c’est pas de faire des DEV des SR, c’est juste un manuel de survie, donc les SRS qui balanceront des « ouais mais en fait c’est pas tout à fait ca » :
cat /dev/urandom > /dev/tty_du_srs_en_question 2>&1 &
Il est important de noter que la première partie part du principe de base que les noms/mots/autres sont sans espace ou autres caractères spéciaux. Cet aspect est présente après le reste.
Les concepts de base
Les flux particuliers :
stdin (entrée standard) : ce n’est pas une commande, c’est un FD, file desciptor, spécial qui est le flux d’entrée. C’est le fd 0.
stdout (sortie standard) : celle que l’on utilise 90% du temps, FD, en résumé ce qui s’affiche en retour d’une commande. c’est le fd 1.
stderr : sortie d’erreur c’est le fd 2.
on en reparle après.
Les redirections :
| : celui qu’on appel « pipe » le plus régulièrement, permet de joindre la sortie standard d’une command à l’entrée standard d’une autre.
< : prend son entrée standard à partir fichier
> : redirige la sortie standard vers autre chose, un fichier par exemple ou /dev/null (dans l’espace)
(on peut préciser par exemple 2>&1 qui redirige la sortie d’erreur (2) vers la sortie standard (1))
>> : redirige en mode append, on ajoute les données à la fin du fichiers existant.
Cas concrets :
ls > toto.txt : redirige le contenu de la sortie de ls (les fichiers listés) dans le fichiers toto.txt
ls >> toto.txt : idem sauf que ca ajoute à la fin du fichier. WARNING la première (ls>toto.txt) détruit toto.txt si il existe déjà.
ls > /dev/null : renvoi la liste des fichiers dans l’espace (/dev/null = grosse poubelle géante de taille infinie)
ls | more : liste les fichiers et envoi le résultat à la commande more qui affichera page par page.
less < toto.txt : éjectera toto.txt dans l’entrée standard de less qui sortira un résultat page par page. (ceci dit ca revient au meme que faire directement less toto.txt mais j’avais pas d’exemple en tete)
Wilcards :
Comme sous Windows, on peut utiliser des jokers ou wildcards :
ls * affiche tous les fichiers (ceci dit c’est le comportement par défaut)
ls t?t?.txt : listera titi.txt toto.txt et tutu.txt enfin remplacera ? à la position voulu par n’importe quel lettre.
ls t*.txt : affichera tous les fichiers commencant par t et finissant par .txt
ls tata[1-3].txt affichera tous les fichiers commencant par tata suivi du chiffre 1, 2 ou 3 puis finissant par .txt
ls t[a-i]* affichera tous les fichiers commencant par t, suivi d’une lettre entre a et i
bien sur on combien à l’infini : ls t[1-3]abc?zz.t?t est donc une commande recevable
WARNING : Unix est TOUJOURS « case sensitive ». a n’est pas égal à A.
WARNING : Contrairement a Windows, le remplacement des wildcards est traité directement par le shell, indépendamment du programme appelé. Le programme reçoit donc directement la liste des fichiers qui correspondent, même s’il s’attendait a recevoir une expression qui contenait ces caractères la.
ls T* et ls t* retourneront donc des résultats différents ! C’est une règle valable pour TOUTES les commandes.
INFO : TAB complète dans le shell quand c’est possible, sinon propose des possibilités.
Les amis (commandes) :
ls : liste les fichiers et répertoire
ls liste les fichiers du répertoire courant
ls -l la même chose en mode colonne.
ls -l –color colore les fichiers en fonction de leurs droits et types
-r : récursif
cat : équivalent de type sous windows
cat toto.txt, affiche le contenu de toto.txt
cat toto.txt titi.txt > tutu.txt, concatene toto et titi dans le fichier tutu.txt
cat toto.txt titi.txt >> tutu.txt, concatene toto et titi à la fin du fichier tutu.txt
cat * : affiche le contenu de tous les fichiers du répertoire courant. donc cat * > tutu.txt, copie tout dans tutu.txt
On peut aussi s’en service pour écrire dans un fichier :
cat > test.txt, redirigera donc l’entrée standard vers test.txt, on tape ce qu’on veut au clavier puis à la fin on tape CTRL+d ce qui interrompt la saisie et stock le contenu dans le fichier. Très pratique pour creer un fichier rapidement. Si on veut écrire à la fin d’un fichier existant : cat >> test.txt
cut : coupe ce que l’on récupère en fonction d’un délimiteur précis
imaginons que le fichier toto.txt contienne :
abc.def.ghi test 123
zzz.aaa:bbb_456
pour afficher uniquement un des blocs séparé par un des séparateurs (en l’occurence . ou » » ou _) : cat toto.txt | cut -f 1 -d « . »
donnera en sortie :
abc
zzz
-f c’est le champs (field) et -d le séparateur.
donc pour obtenir uniquement 456 :
cat toto.txt | cut -f 3 -d « _ » par contre la ligne « abc.def.ghi test 123″ ne contenant pas d’underscore, n’a pas de troisièmes champs… et seule une ligne vide sera affiché, mais on verra plus loin comment éviter ca.
grep : affiche la pattern recherchée parmis des fichiers ou un flux
ls -l | grep toto.txt ne retournera que les lignes avec toto.txt parmis tout le résultat du ls.
cat toto.txt | grep « henri » n’affichera que les lignes du fichier toto.txt qui contiennent « henri »
cat toto.txt | grep « henri » | grep -v « IV » n’affichera que les lignes du fichier toto.txt qui contiennent « henri » mais pas celle contenant « IV »
le -v exclue le mot qui suit.
l’option -r fait un grep récursif,
l’option -i ignore la case (plus de distinction majuscule/minuscules),
l’option -n affiche egalement les numeros des lignes : grep -nri henri . | grep -v « IV »
sortira tous henri de tous les fichiers du répertoire courant et des sous répertoire, peut importe que ce soit henri ou HENRI ou HeNrI, sauf les ligne contenant également « IV ». Chaque ligne aura le nom du fichier, le numero de la ligne, ainsi que le contenu de la ligne en question.
les options -A et -B sont pratique, c’est After et Before.
donc grep -A 2 -B 3 henri toto.txt sortira toutes lignes avec henri mais aussi les 3 lignes précédentes et les 2 lignes suivantes.
find : trouve des fichiers à partir d’un chemin précis et permet d’executer une commande dessus
find a plein plein d’options, je n’en montrerai ici que deux qui sont classiques et utiles
find . -name « *.txt » -print : trouvera récursivement tous les fichiers avec l’extension .txt à partir du répertoire courant « . »
find . -name « *.txt » -exec rm ‘{}’ \;
bon celle là elle est un peu funky en terme de synthaxe, mais :
le {} désign la liste de ce qui a été retourné par find et le -exec y applique une commande. En l’occurence rm qui efface les fichiers.
donc cette ligne de commande trouvera à partir du répertoire courant et dans tous les sous répertoire les fichiers avec extensions .txt, et les effacera.
find . -exec grep -q www.nbs.fr ‘{}’ \; -print
Afficher tous les fichiers contenant www.nbs.fr.On pourra ensuite y appliquer un autre traitement, par exemple avec sed pour remplacer www.nbs.fr automatiquement par www.nbs-system.com.
Note, il existe aussi l’option -iname qui fait comme -name, mais sans tenir compte de la case des noms de fichier.
locate : trouve des fichiers à partir d’une DB générée la nuit
le système linux, en général, fait tourner régulièrement un programme qui met à jour le contenu d’une base stockant tous les fichiers de toutes les partitions.
l’avantage par rapport à find c’est qu’au lieu de chercher en live, on a un « cache » donc ca va beaucoup plus vite.
locate *.txt donnera la localisation de tous les fichiers .txt partout sur le système instantannément sans faire la recherche. Le défaut c’est que si vous avez un nouveau fichier depuis le dernier uptade de la base, il ne sera pas montré. Pour forcer l’update de la base en live : updatedb
Note: afin d’eviter certain probleme de droits sur la base, il est conseille de ne pas lancer updatedb a la main directement. Le script (emplacement sous debian) /etc/cron.daily/find le lance avec les bons arguments.
sort : permet de trier un flux
Trie les lignes…
cat dictionnaire.txt | sort > dictionnaire_trié.txt
cela va trier par ordre alphabétique le dictionnaire « dictionnaire.txt » et écrire le résultat dans dictionnaire_trié.txt
-r ca le fera à l’envers (reverse), la commande est simple mais elle a pas mal d’options différentes à apprécier 
uniq : permet de rendre unique les données qui sorte d’un flux
Supprime des lignes identiques qui se suivent…
cat fichier_plein_de_doublon.txt | sort |
uniq > fichier_dédoublonné_et_classé.txt
si le fichier contient :
titi
titi
toto
tutu
tata
tutu
ca donnera :
tata
titi
toto
tutu
sed : permet de remplacer des strings par d’autres dans un flux ou des fichiers
sed est un couteau suisse du traitement des flux. Il est capable de faire énormément de choses. Nous allons voir une toute petite partie de sed, la partie la plus utilisée.
sed permet surtout de remplacer une chaine par une autre
sed s/www.nbs.fr/www.nbs-system.com/g index.html
Affiche le contenu de index.html en remplacant toute les occurrence de www.nbs.fr par www.nbs-system.com
La syntaxe de base est s/chaine d’origine/chaine a mettre/options ou :
- Le s au debut signifie substitution
- Le / qui separe les differentes partie peux etre en fait n’importe quel caractere. Il faut le prefixer d’un backslash (\) si on souhaite utiliser le caractere en question ailleur.
- La chaine d’origine est en fait une regex, tout comme les recherches avec grep.
- Les options peuvent contenir:
o g – remplace toutes les occurrences sur une meme ligne.
o i -Cela permet de faire une recherché de chaine sans tenir compte de la case
o p – affiche la ligne s’il y a eu une substitution
On a un code dans lequel il y a des requetes SQL qui n’ont pas tenu compte de la case des noms de tables ou de champs (mysql sous windows a tendance a s’en foutre de la case) et on veux le faire passer sous unix.
Dans un premier temps, on affiche uniquement les lignes qui changent (option -n pour ne pas afficher par defaut, et le p de la substitution), de facon a verifier que cela ne fait pas de betises :
sed -n ‘s/MaJoLiE_tAbLe/majolie_table/igp’ fichier.php
Une fois que la substitution s’effectue correctement :
mv fichier.php fichier.php.old &&
sed ‘s/MaJoLiE_tAbLe/majolie_table/ig’ fichier.php.old > fichier.php
A noter que l’on a plus ni le -n, li le p, de façon a bien afficher tout le fichier d’origine.
Les regex, explications complete :
- X un caractere de base correspond a lui-meme
- . le point correspond a n’importe quel caractere (comme ? en shell)
- ^ S’il est place au debut correspond au debut de ligne.
- $ s’il est place en fin, correspond a la fin de ligne
- [aoeuiA-Z] Les classes de caracteres. N’importe quel caractere qui correspond (voyelle en misucule, ou une majuscule)
- [^0-9] un caractere qui n’est PAS un chiffre
- [0-9]* * correspond a 0-n fois ce qui precede. Ici, rien ou une suite de chiffres.
- S\? \? Correspond a 0 ou une fois ce qui precede. Ici, rien ou un S.
- \(abc\) Les \(…\) permettent simplement de faire un groupe.
Par exemple : \(ta\)\* correspond a rien, ou une suite de ta.
- X\|Y correspondra X ou Y. Attention, il faut utiliser des () pour limiter l’etendu.
Dans la chaine de remplacement, le caractere & sera remplace par l’ensemble de la chaine d’origine (pratique pour la conserver, mais la commenter). D’autre part, \n ou n est un chiffre sera remplace par le texte correspondant au neme groupe (les parentheses).
Des exemples concrets :
Afficher toute les lignes commençant par une lettre minuscule
grep ‘^[a-z]‘
Ajouter un premier argument a toute les appels d’une fonction : sed ‘s/ma fonction(/&1, /g’
Commenter tous les appels a la fonction prettylog (ne doit pas avoir de () dans les arguments:
sed ‘s#prettylog([^()]*)#/* & */#g’
remplacer les fonction log_database(, log_engine( par log(« database », ou log(« engine », :
sed ‘s/log_\(database\|engine\)(/log(« \1″, /g’
Bien evidement, on reste dans l’optique du : sed ‘s/…/…/g’ fichier1 > fichier2
tail : permet de voir la fin d’un fichier
tail toto.txt, affiche (par défaut) les 10 dernières lignes du fichier toto.txt
si vous avez à faire à un fichier qui change et qui grossit (genre fichier de log) et que vous voulez le suivre en continu :
tail -f toto.log : la commande ne s’arretera pas et continuera à vous montrer le fichier au fur et à mesure qu’il grossit.
head : permet de voir le début d’un fichier
comme tail mais pour montrer les lignes du début du fichier. (pas la peine d’essayer head -f)
chmod : permet de changer les droits d’un fichier ou répertoire
les droits sont cumulables, il existe read, write, execute. On va simplifier tout ca, mais il existe trois groupes à qui appliquer ces droits : le propriétaire du fichier, le groupe du fichier (généralement le groupe auquel appartient le propriétaire du fichier (voir chown)) et le propriétaire du fichier en lui même.
read vaut 4
write vaut 2
execute vaut 1
- chmod 400 toto.txt donne les droits en lecture à root. chmod 444 toto.txt donne les droits en lecture à tout le monde.
- chmod 555 c’est chmod 444 + chmod 111 soit les droits en lecture et en éxecution à tout le monde.
- chmod 777 c’est lecture, écriture, exécution à tout le monde. (4+2+1 pour le propriétaire, le groupe et les autres).
- chmod 000 enlève tous les droits à un fichier (notez que root bypass de toute façon ces droits)
Droits généralement utilisé :
600 – fichier normal, en lecture/ecriture uniquement pour son proprietaire
644 – pareil, et lecture pour les autres
700 – executable, en lecture/ecriture/execution uniquement pour son proprietaire
755 – pareil, et lecture/execution pour les autres
Note : un repertoire doit etre executable pour pouvoir aller dedans
Les droits peuvent egalement etre donner sous forme de modifications.
u – user
g – group
o – other
a – all
r – read
w – write
x – execute
X – execute si déjà present quelque part
chmod u+rw,go-w+rX
Ajoute les droits de lecture ecriture au proprietaire, enleve les droits d’ecriture au groupe et aux autres, leur donne le droit de lecture, ainsi que le droit d’execution si c’est un executable.
chown : permet de changer le proriétaire d’un fichier ou répertoire
Pour changer le proprietaire d’un fichier, il est necessaire d’etre root.
chown philippe:www-data toto.txt donne la propriété du fichier à philippe et l’affilie au groupe www-data.
chown xxx:yyy fichiers : xxx = user, yyy = groupe.
Donc si je veux donner la propriété et les droits à philippe et à tous les membres du groupe admin :
chown philippe:admin toto.txt
et avec un chmod 640 toto.txt je donne tous les droits de lecture/ecriture à philippe, la lecture au groupe admin, et aucun droits aux autres.
WARNING : un fichier en 777 est dangereux, tout le monde peut y écrire, a éviter en Web.
le truc classique en web qui passe (presque) dans tous les cas :
chown -R www-data.www-data *
chmod -R go-w+rX *
le -R dans ces commandes les rends récursives sur tous les fichiers et sous répertoires.
touch
touch crée un fichier vide s’il n’exite pas et change la date / heure à l’heure actuel si il existe.
touch toto.txt crée un fichier de toto.txt de 0 octets s’il n’existe pas et lui donne date/heure
au moment auquel commande est lancé s’il existe. Il existe d’autres options pour fixer une
date/heure précise entre autre.
mv / rm :
mv : c’est move.
mv toto.txt titi.txt renome toto.txt en titi.txt (attention, l’écrase s’il existe)
Note : mv permet egalement de renomer un repertoire, ou de deplacer plusieurs fichiers/repertoire vers un repertoire de destination.
rm toto.txt : efface le fichier toto.txt.
rm -r le fait récursivement. rm -f force l’effacement sans poser de question…
comme dans la plupart des commandes, on peut cumuler les switchs :
rm -rf * : efface récursivement tous les fichiers et répertoires situé sous le répertoire courant sans poser de question.
WARNING : guess why…
Lorsque vous utilisez mv ou rm de facon interactive, et que vous n’etes pas certain a 200% de votre ligne de commande (par exemple si c’est un via des variables, ou de l’expansion, …), utilisez l’options -i. Elle vous demandera confirmation avant d’écraser de façon irrémédiable des informations.
less / more :
Comme le dit régulièrement notre directeur technique, less can more. Donc less peut faire tout ce que fait more et plus.
Techniquement c’est bien aussi de connaitre more qui est en général plus utilisé dans les scripts ou les unix plus anciens (la ou il n’y a pas less)
less toto.txt va afficher le contenu (si il est en ascii, sinon en binaire il met un warning) du fichier toto.txt et bien sur ca se pipe :
grep henri toto.txt | less
pendant l’execution de more ou less vous pouvez appuyez sur / vous allez pouvoir rechercher dans le texte le mot qui vous intéresse.
echo :
echo affiche ce qui est en paramètre. echo est utile pour signaler quelque chose à l’utilisateur dans un script par exemple
(echo « Hello World »). echo peut aussi afficher le contenu d’une variable par exemple : echo $a ou encore se substituer à un ls en faisant echo * ou même à écrire dans un fichier echo YO > toto.txt.
la commande accepte beaucoup de switch, voir le manuel. (man echo)
man : les manuels des commandes
man ls
man awk (il fait mal à la tête celui la)
etc…
souvent sont aussi donné des références à d’autre man en pied de page du man.
par ailleurs man -k keyword recherche les pages de manuel qui parle de « keyword ».
Il existe plusieurs catégorie de man (1 à 
de mémoire qui sont plus ou moins spécialisés. Généralement les commandes sont en man 1 (ce qui est le mode par défaut).
si vous voulez le man plus orienté programmation C d’une chose précise : man 3 sigpause man 2 c’est plus orienté sur les syscall. Bref vous c’est plutot le 1 donc man [commande].
Par défaut man vous affiche son contenu avec un pager (less), pendant l’exécution de man, vous pouvez donc appuyez sur / vous allez pouvoir rechercher dans le texte le mot qui vous intéresse également.
sudo / su : des commandes qui permettent de passer ou de lancer des commande en tant que Super Utilisateur (root quoi)
Arreter apache… : sudo apachectl stop
va prendre les droits root temporairement pour stopper apache, si vous êtes habitilité par le fichier sudoers à la lancer cette commande.
si c’est le cas, il vous suffit de retaper le mot de passe de votre utilisateurs sur le système pour lancer la commande.
su : permet de passer root en tapant le mot de passe du compte root de la machine.
sudo -s : permet de passer root, sans connaitre le mot de passe de root, si on y est autorisé par le fichier sudoers.
WARNING : root à TOUS les droits sans aucune limite de portée. Si vous demander au système d’écrire de la merde dans la ram, il le fera sans broncher, tout comme si vous lui demander de s’effacer lui même.
wc : compte les caractères, lignes ou les mots
wc -l toto.txt compte le nombre de ligne du fichier toto.txt
cat toto.txt | wc -l ca revient au même.
-m ou -c pour les charactères
-w pour les mots
awk : permet d’appliquer un traitement avancé de formatage à un flux ou d’un fichier
awk est un langage avec un synthaxe à part entière, pas simple de surcroit. C’est très puissant et très pénible. Personnellement je m’en sers que pour une chose, reformater une sortie standard.
Pour l’exemple, un fichier contenant :
tcpmux 1/tcp # TCP port service multiplexer
echo 7/tcp
echo 7/udp
les séparateurs de colonnes sont des tabulations (il y en a 2)… La joie…
Je veux afficher la colonne 1 et la colonne 3 en admettant que mes séparateurs sont des tabulations :
cat toto.txt | awk -F « \t » ‘{ print $1 $3 }’
le -F « \t » c’est pour dire que tabulation est le séparateur de champs. print $1 $3 affiche la premiere valeur et la 3°, selon ce séparateur.
bon le résultat est que j’ai :
tcpmux1/tcp
echo7/tcp
echo7/udp
si je veux y ajouter des espaces pour rendre ca lisible :
cat toto.txt | awk -F « \t » ‘{ print $1 « » $3 }’
Évidemment, ca peut se séparer selon un autre séparateur, par exemple le « / » :
cat toto.txt | awk -F « / » ‘{ print $1 « » $2 }’
retour de la commande :
tcpmux 1 tcp # TCP port service multiplexer
echo 7 tcp
echo 7 udp
il a enlevé le séparateur au passage et l’a remplacé par 4 espaces.
Pour le moment c’est flou mais le jour où vous en aurez besoin, awk vous sauvera la vie 
Dans le doute, man [nom de la commande]. Tous les admins lisent les mans, meme les SR/CQ expérimentés. Ca sert à rien de connaitre par coeur tous les switchs (options) d’une commande, le man est donc une référence régulièrement utilisée par tous.
Bash – gestion des commandes :
& : laisse un processus s’executer en tache de fond, et vous permet de continuer a travailler sur le shell
Genre find ca peut être long, donc mettre un find qui redirige son résultat dans un fichier et le laisser en tache de fond c’est parfois une bonne idée :
find /var/www -name ‘*.php’ > ~/find.log 2> ~/find.err &
fg / bg : met un processus en foreground (fg) ou background (bg).
fg %n : n étant le numéro du job si vous avez mis plusieurs jobs en background.
jobs : liste les jobs (en background ou suspendu)
Lorsque vous etes en train d’executer une commande, Contrôle-Z la suspend.
Foreground – repasse une commande suspendu ou en background au premier plan
Background – pareil que de l’avoir lancee avec &, la tache continue en fond.
ps aux : liste tous les processus
Une commande a un code de sortie. Ce code est presque toujours correspondant a la facon dont le processus c’est termine. Si ca c’est bien passé c’est 0 sinon c’est autre chose.
&& : permet de linker deux commandes, et de n’exécuter la deuxième que si la première a échouée.
rm toto.txt && echo « ok fichier effacé »
« ok fichier effacé » s’affichera que si le fichier toto.txt a été effacé.
|| : Inversement, || permet de n’executer la deuxieme partie que si la premiere n’a pas fonctionner.
rm toto.txt || echo « Erreur lors de la supression du fichier »
; : le point virgule est un délimiteur permettant d’enchainer les commandes mais sans vérifier que le retour de la précédente s’est bien passé. ls *; echo titi > toto.txt; cat toto.txt enchaine les 3 commandes.
export : plusieurs fonction, mais on va surtout utiliser export pour exporter une variable. (La rendre visible pour des programmes que vous lanceriez apres)
export a= »toto » (stock toto dans a, et exporte a)
ou export a=’ls’ (stock le retour stdout de la commande ls dans a et exporte a)
‘commande’ : c’est la quote (‘) inverse (alt-gr 7 sur un azerty, la touche au dessus de tab sur un qwerty). backquoté une commande ou expression force son évaluation, et utilise sa sortie standard a l’endroit de la commande.
a=ls stock ls dans a. Si on veut stocker le résultat d’une commande ls dans a :
a=’ls’
Quoting
\ : n’interprête pas le caractère suivant le backslash. utile pour plein de truc.
exemple : « cd mon truc » ne marche pas. Il faut taper « cd mon\ truc » pour que l’espace entre mon et truc ne soit pas perçu par la commande comme étant deux paramètre distincts.
Il est également possible d’utiliser, de façon complètement équivalente :
cd mon\ truc
cd mon » « truc
cd « mon truc »
cd ‘mon truc’
cd mon’ truc’ »
« : double quotes. Entre double quotes, il n’y a pas de separation de mot, les variables ($a), double quotes, backquotes et backslash sont interprété. A utiliser de facon generale lorsque l’on utilise des variables, et que l’on ne veux pas avoir de separation de mot, ou de risque d’expansion. Essayez les commandes suivantes :
a=*
echo $a
echo « $a »
‘ : simple quotes. Entre simple quotes RIEN n’est interprete. Un autre simple quote met fin a la sequence sequence. Il n’y a AUCUN moyen de backslashe un simple quote dedans. Tres pratique quand on veux une chaine avec plein de double quotes, $ et autre qui reste exactement tel quel.
for : super important. Un exemple concret vaut mieux qu’un long discour. Je veux appliquer un traitement à tous les fichiers .txt du répertoire courant pour les renommer en .old :
for i in *.txt ; do mv -i « $i » « $i.old » ; done
on prend une variable i pour faire une boucle sur les mots que represente * (l’ensemble des fichiers du repertoire), ensuite on applique (do) avec $i qui est en fait une des valeurs de *, et on finit par done.
TRESSSS pratique…
Autre cas, d’utilisation : for ((i=0 ; i < 10 ; ++i)) ; { echo $i ; }
Affiche les chiffres.
Generalites
/etc/init.d/ :
c’est ici qu’on stock les scripts lançant ou stoppant les démons du système.
Par exemple sur apache :
/etc/init.d/apache start
/etc/init.d/apache stop
/etc/init.d/apache restart
pareil pour mysql et plein d’autres démons, la plupart accept stop, start, restart.
généralités :
–help donne de l’aide sur une commande
-v : en général rend la commande « verbose » (affiche plus d’info sur son execution)
-q : en général rend la commande quiet
C’est quasi toujours vrai pour –help pour -v et -q c’est fréquent mais pas systématique.
faire un script :
un script bash commence toujours par (sur sa premiere ligne) :
#! /bin/bash
C’est ce qui permet au système de savoir qu’il faut utiliser bash pour interpreter ce script.
un script de base :
cat > script_de_base.sh (on met « .sh » à la fin en général pour savoir que c’est un script bash mais c’est pas obligatoire)
#!/bin/bash
echo $1
(Contrôle-D pour finir)
ensuite on le rend exécutable: chmod +x script_de_base.sh
puis pour le lancer : ./script_de_base.sh toto
vous noterez le « ./ » au début c’est pour signaler qu’on lance le fichier depuis le répertoire courant « . » puisque, par sécurité, le répertoire courant n’est pas intégré à la variable PATH.
ca affichera $1 qui vaut en l’occurrence toto puisque $1 $2 $3 $4 etc… sont les paramètres dans l’ordre sur la ligne de commande, $0 étant le nom du programme en lui même, ici : ./script_de_base.sh
pour se faciliter la vie on met en général le path standard des binaires utiles dans le début du script :
PATH=/bin:/usr/bin:/sbin:/usr/sbin
et puis un commentaire sur ce qu’il fait le machin, c’est mieux pour les copains et les lendemains de cuites.
Quelques exemple de synthaxes un peu évoluées et utiles :
grep die *.php | grep -v « // » | grep -v « /\* » | grep -v « \*/ »
ca devrait vous retourner le nom des fichier php, avec le contenu après un : qui contienne un die mais qui n’est pas commenté (sur la ligne elle-meme).
si vous voulez tous les effacer :
Pour ne garder que les fichiers qui correspondent
grep die *.php | grep -v « // » | grep -v « /* » | grep -v « */ » |
cut -f 1 -d « : »
donc si on assigne le contenu de cette commande à une variable et qu’on fait une boucle dessus :
a=’grep die *.php | grep die | grep -v « // » | grep -v « /* » | grep -v « */ » |
cut -f 1 -d « : »‘
On commence par verifier qu’on a le bon resultat escompter avec un echo, histoire de ne pas effacer n’importe quoi : for i in $a; do echo $i; done
une fois que c’est bon : for i in $a; do rm -f $i; done
sinon ca passait bien aussi avec un find
Allez, une autre, on reformat un CSV :
le contenu original du fichier ORIGINAL.CSV :
toto:1:2222:toto is a star:20
titi:2:2222:bruno en str:4
tititt:2:2222:bruno en str:4
tutu:3:1122:denis b:8
tata:4:1112:thibault loves printers:12
tata2:4:1112:thibault loves printers:12
tata42:4:1112:thibault loves printers:12
on veut le sortir avec des séparateur qui soit des ; et pas des : et seuls les champs 1 et 5 nous intéressent et seul les tata* et titi* nous sont utiles :
Avec awk :
cat ORIGINAL.CSV | awk -F « : » ‘{ print $1 « ; » $5 }’ | grep t[ai]t[ai] > FINAL.CSV
Pareil, mais avec cut :
cat ORIGINAL.CSV | cut -d: -f 1,5 –output-delimiter « ; » | grep t[ai]t[ai] > FINAL.CSV
Redémarrer apache et mysql en une ligne en ignorant l’affichage normal et d’erreur (pas conseillé), mais au moins en ne démarrant mysql que si apache s’est bien lancé :
{ /etc/init.d/apache restart && /etc/init.d/mysql restart ; } > /dev/null 2>&1
écrit par Philippe Humeau
\\ tags: Administration Linux, administration système
Commentaires récents