Syntaxe "bash" pour les scripts (pas les commandes)

HowtoApache.md

@@ -192,7 +192,7 @@ Attention, il ne faut jamais forcer les droits récursivement sur toute l'arbore
 
 ## SSL
 
-Apache peut gérer des connexions sécurisées via HTTPS. 
+Apache peut gérer des connexions sécurisées via HTTPS.
 
 ~~~
 # a2enmod ssl
@@ -351,7 +351,7 @@ La configuration est quasi-identique au type Basic :
 ~~~{.apache}
 AuthType Digest
 AuthName "Restricted"
-AuthUserFile /foo/.htpasswd 
+AuthUserFile /foo/.htpasswd
 Require valid-user
 ~~~
 
@@ -383,7 +383,7 @@ Voici quelques motifs classiques de redirection vers un nouveau domaine (HTTP 30
 
 - `RedirectPermanent / http://new.example.com`
 - `RedirectMatch ^/(.*)$ http://new.example.com/$1`
-- `RewriteRule ^/(.*) http://new.example.com/$1 [L,R=permanent]` 
+- `RewriteRule ^/(.*) http://new.example.com/$1 [L,R=permanent]`
 
 Pour supprimer un Query String avec une Rewrite Rule : <https://www.philipphoffmann.de/blog/2012/08/16/how-to-discard-the-query-string-in-a-rewriterule-apache-mod_rewrite/>
 
@@ -490,11 +490,11 @@ file = /var/log/apache2/error.log
 
 L'indispensable **apachetop** permet de surveiller en direct l'activité d'Apache via un fichier d'access_log (format *combined*) :
 
-~~~{.bash}
+~~~
 $ apachetop -f access.log -T 3600 -q
 ~~~
 
-On peut alors visualiser les URLs les plus sollicitées (querystrings inclus grâce à l'option *-q*), et switcher à l'aide de la touche **d**  pour voir les adresses IP source ; à l'aide de la touche **n** pour voir la répartition en codes HTTP 2xx/3xx/4xx/5xx. 
+On peut alors visualiser les URLs les plus sollicitées (querystrings inclus grâce à l'option *-q*), et switcher à l'aide de la touche **d**  pour voir les adresses IP source ; à l'aide de la touche **n** pour voir la répartition en codes HTTP 2xx/3xx/4xx/5xx.
 
 Voici l'ensemble des commandes disponibles :
 
@@ -578,7 +578,7 @@ Ajouter `Indexes` dans `AllowOverride`.
 
 ### Autorisation Options via .htaccess ?
 
-Si l'on modifie l'option `php_admin_value memory_limit` : un _reload_/_graceful_ suffit pour prendre en compte la modification. 
+Si l'on modifie l'option `php_admin_value memory_limit` : un _reload_/_graceful_ suffit pour prendre en compte la modification.
 
 Exemple pour le AllowOverride :
 
@@ -590,7 +590,7 @@ AllowOverride Options=All,MultiViews Indexes AuthConfig Limit FileInfo
 
 Quand on utilise l'authentification LDAP avec un serveur en local, il faut démarrer **slapd** avant de démarrer Apache, sinon celui-ci se plaint qu'il ne peut pas contacter le serveur LDAP, et bloque l'accès aux pages … (erreur 500).
 
-Pour cela, dans le script d'init d'apache2 ajouter slapd dans la directive `Required-Start:` 
+Pour cela, dans le script d'init d'apache2 ajouter slapd dans la directive `Required-Start:`
 
 ~~~
 # Required-Start:    $local_fs $remote_fs $network $syslog $named slapd

HowtoElasticsearch.md

@@ -260,7 +260,7 @@ On peut ainsi créer régulièrement des snapshots pour les sauvegardes.
 
 Pour créer un snapshot toutes les heures, et en conserver 24 en permanence (notion de snapshots "roulants") :
 
-~~~{.bash}
+~~~
 $ date=$(date +%H)
 $ curl -s -X DELETE "127.0.0.1:9200/_snapshot/foo/h${date}" | grep -v acknowledged..true
 $ curl -s -X PUT "127.0.0.1:9200/_snapshot/foo/h${date}?wait_for_completion=true" -o /tmp/es_snapshot_h${date}.log
@@ -351,7 +351,7 @@ Nous allons utiliser une base de données d'exemple pour faire des tests.
 
 Télécharger, <https://github.com/andrewvc/ee-datasets/archive/master.zip>, décompresser l'archive et exécuter le programme Java qui va injecter la BDD "movie_db" dans votre cluster ES.
 
-~~~{.bash}
+~~~
 $ java -jar elastic-loader.jar http://localhost:9200 datasets/movie_db.eloader
 ~~~
 
@@ -359,7 +359,7 @@ La BDD movie_db contient quelques noms de films, avec leurs informations associ
 
 Pour consulter tout son contenu :
 
-~~~{.bash}
+~~~
 $ curl http://localhost:9200/movie_db/_search?pretty=true
 ~~~
 
@@ -369,7 +369,7 @@ $ curl http://localhost:9200/movie_db/_search?pretty=true
 
 Créer un index (équivalent d'une base de données) nommé *planet* :
 
-~~~{.bash}
+~~~
 $ curl -X PUT localhost:9200/planet
 {"acknowledged":true,"shards_acknowledged":true}
 ~~~
@@ -395,14 +395,14 @@ $ curl -X PUT localhost:9200/planet/hacker/_mapping -d '
 
 Créer un document de type hacker avec l'ID 1 :
 
-~~~{.bash}
+~~~
 $ curl -X PUT localhost:9200/planet/hacker/1 -d '{"handle": "jean-michel", "age": 18}'
 {"_index":"planet","_type":"hacker","_id":"1","_version":1,"result":"created","_shards":{"total":2,"successful":1,"failed":0},"created":true
 ~~~
 
 Voir son contenu :
 
-~~~{.bash}
+~~~
 $ curl localhost:9200/planet/hacker/1?pretty=true
 {
   "_index" : "planet",
@@ -419,14 +419,14 @@ $ curl localhost:9200/planet/hacker/1?pretty=true
 
 Mise à jour du champ âge :
 
-~~~{.bash}
+~~~
 $ curl -X POST localhost:9200/planet/hacker/1/_update -d '{"doc": {"age": 19}}'
 {"_index":"planet","_type":"hacker","_id":"1","_version":2,"result":"updated","_shards":{"total":2,"successful":1,"failed":0}}
 ~~~
 
 Suppression du document :
 
-~~~{.bash}
+~~~
 $ curl -X DELETE localhost:9200/planet/hacker/1
 {"found":true,"_index":"planet","_type":"hacker","_id":"1","_version":3,"result":"deleted","_shards":{"total":2,"successful":1,"failed":0}}
 ~~~
@@ -564,7 +564,7 @@ La solution la plus propre est d'utiliser [Curator](https://www.elastic.co/guide
 Voici un exemple qui pour les index nommés `logstash-*`, ne va conserver que les 20 derniers.
 
 ~~~{.bash}
- #!/bin/bash
+#!/bin/bash
 
 indices=$(curl http://127.0.0.1:9200/_cat/indices/logstash-*?h=i | sort | head -n -20)
 

HowtoGit.md

@@ -38,7 +38,7 @@ Pour chaque commande, une page de manuel *git-<commande>* est disponible. Par ex
 
 ### Créer un dépôt
 
-~~~{.bash}
+~~~
 $ mkdir foo
 $ cd foo
 $ git init
@@ -48,7 +48,7 @@ $ git init
 
 Plusieurs méthodes d'accès pour récupérer un dépôt : ssh://, http(s)://, git://, file:// etc.
 
-~~~{.bash}
+~~~
 $ git clone ssh://git.example.com/path/projet.git
 $ git clone https://git.example.com/path/projet
 $ git clone git://git.example.com/path/projet.git
@@ -59,7 +59,7 @@ $ git clone file:///path/projet
 
 Ajouter un nouveau fichier :
 
-~~~{.bash}
+~~~
 $ touch main.c
 $ git add main.c
 $ git commit -v
@@ -67,7 +67,7 @@ $ git commit -v
 
 Modification d'un fichier existant :
 
-~~~{.bash}
+~~~
 $ vi main.c
 $ git add main.c
 $ git commit -v
@@ -78,14 +78,14 @@ $ git commit -v
 
 Voir l'état du dépôt local (fichiers non commités, etc.) :
 
-~~~{.bash}
+~~~
 $ git status
 $ git status -s -b
 ~~~
 
 Voir les derniers commits du dépôt local :
 
-~~~{.bash}
+~~~
 $ git log
 ~~~
 
@@ -95,7 +95,7 @@ Si l'on a cloné un dépôt existant, un lien est automatiquement créé entre l
 
 Pour récupérer en local les derniers changements du dépôt distant :
 
-~~~{.bash}
+~~~
 $ git pull --rebase origin
 ~~~
 
@@ -103,7 +103,7 @@ $ git pull --rebase origin
 
 Pour envoyer ses modifications locales vers le dépôt référencé comme distant :
 
-~~~{.bash}
+~~~
 $ git push origin
 ~~~
 
@@ -115,40 +115,40 @@ garder en tête que c'est une convention, rien n'oblige à en avoir une.
 
 Lister les branches existantes et connaître sa branche courante :
 
-~~~{.bash}
+~~~
 $ git branch -a
 ~~~
 
 Passer d'une branche à une autre dans son dépôt local :
 
-~~~{.bash}
+~~~
 $ git checkout myfeature
 $ git checkout master
 ~~~
 
 Créer une branche *myfeature* à partir de la branche *master* :
 
-~~~{.bash}
+~~~
 $ git checkout master
 $ git branch myfeature master
 ~~~
 
 Travailler sur la branche *myfeature* puis [merger](#git-merge) son travail dans la branche *master* :
 
-~~~{.bash}
+~~~
 $ git checkout master
 $ git merge --no-ff myfeature
 ~~~
 
 Pousser une branche locale vers le dépôt référencé comme distant :
 
-~~~{.bash}
+~~~
 $ git push origin myfeature
 ~~~
 
 Supprimer une branche locale et distante :
 
-~~~{.bash}
+~~~
 $ git branch -d myfeature
 $ git push origin :myfeature
 ~~~
@@ -159,7 +159,7 @@ $ git push origin :myfeature
 
 Affichage de l'historique de différentes façons :
 
-~~~{.bash}
+~~~
 $ git log
 $ git log -p
 $ git log --stat
@@ -178,26 +178,26 @@ On peut notamment combiner toutes ces options dans un alias à mettre dans `.git
 
 On peut aussi utiliser *whatchanged* qui va lister tout ce qui a changé :
 
-~~~{.bash}
+~~~
 $ git whatchanged
 $ git whatchanged -p
 ~~~
 
 Voir l'avant-dernier commit :
 
-~~~{.bash}
+~~~
 $ git show HEAD~1
 ~~~
 
 Voir le fichier *foo/bar* tel qu'il était dans l'avant-dernier commit :
 
-~~~{.bash}
+~~~
 $ git show HEAD~1:foo/bar
 ~~~
 
 Pour voir ce qu'il s'est passé entre deux commits :
 
-~~~{.bash}
+~~~
 $ git show HEAD~8..HEAD
 $ git show -p HEAD~8..HEAD
 ~~~
@@ -216,13 +216,13 @@ $ gitk --all
 
 Modifier son dernier message de commit :
 
-~~~{.bash}
+~~~
 $ git commit --amend
 ~~~
 
 Modifier son dernier commit :
 
-~~~{.bash}
+~~~
 $ vi main.c
 $ git add main.c
 $ git commit --amend
@@ -230,7 +230,7 @@ $ git commit --amend
 
 Modifier son avant-dernier commit :
 
-~~~{.bash}
+~~~
 $ git rebase -i HEAD^^
 … remplacer « pick » par « edit » pour le commit à modifier
 $ vi main.c
@@ -247,7 +247,7 @@ $ git rebase --continue
 
 Récupérer un commit d'une autre branche dans master :
 
-~~~{.bash}
+~~~
 $ git checkout master
 $ git cherry-pick <SHA1 du commit>
 ~~~
@@ -274,14 +274,14 @@ foo/bar*
 
 Cela permet d'avoir un buffer pour mettre « en pause » des modifications non commitées :
 
-~~~{.bash}
+~~~
 …hack…hack…
 $ git stash save
 ~~~
 
 On peut lister ce buffer :
 
-~~~{.bash}
+~~~
 $ git stash list
 stash@{0}: WIP on dev: fb1fa70… m
 stash@{1}: WIP on dev: fb1fa70… m
@@ -289,13 +289,13 @@ stash@{1}: WIP on dev: fb1fa70… m
 
 Et ré-appliquer la dernière modification stockée :
 
-~~~{.bash}
+~~~
 $ git stash pop
 ~~~
 
 Pour purger le buffer sans l'appliquer :
 
-~~~{.bash}
+~~~
 $ git stash clear
 ~~~
 
@@ -305,19 +305,19 @@ $ git stash clear
 
 Voir les modifications locales non commitées et non indexés :
 
-~~~{.bash}
+~~~
 $ git diff
 ~~~
 
 Voir les modifications locales *suivies* (ajoutées avec *git add*) :
 
-~~~{.bash}
+~~~
 $ git diff --cached
 ~~~
 
 Voir les modifications entre deux commits, ou entre deux branches :
 
-~~~{.bash}
+~~~
 $ git diff HEAD^ HEAD
 $ git diff HEAD~8 HEAD^^
 $ git diff myfeature master
@@ -327,13 +327,13 @@ $ git diff myfeature master
 
 Voir les modifications entre deux commits, mais uniquement pour un fichier *foo* :
 
-~~~{.bash}
+~~~
 $ git diff HEAD~8..HEAD^^ -- foo
 ~~~
 
 Avoir un diff inversé (pratique pour faire préparer un revert partiel par exemple) :
 
-~~~{.bash}
+~~~
 $ git diff -R
 ~~~
 
@@ -353,25 +353,25 @@ Dans certains cas il est pratique de faire un simple `git fetch`, notamment si l
 
 Pousser toutes ses branches d'un coup (ce qui est déconseillé en général) :
 
-~~~{.bash}
+~~~
 $ git push --all origin
 ~~~
 
 Si l'on a une branche locale nommée *foo* et que l'on veut la pousser dans la branche nommée *bar* du dépôt distant :
 
-~~~{.bash}
+~~~
 $ git push origin foo:bar
 ~~~
 
 /!\\ Attention, il ne faut jamais modifier un historique qui a été pushé vers un dépôt partagé. Néanmoins dans certaines situations exceptionnelles (un mot de passe ou un email qui aurait été mis par erreur) on peut être amené à faire un `push --force` :
 
-~~~{.bash}
+~~~
 $ git push -f origin
 ~~~
 
 Il faudra ensuite que chaque utilisateur du dépôt soit prévenu et accepte d'écraser leur dépôt local (en faisant ou vérifiant les modifications d'historiques) :
 
-~~~{.bash}
+~~~
 $ git fetch
 $ git reset origin
 ~~~
@@ -382,25 +382,25 @@ $ git reset origin
 
 Pour avoir le dépôt tel qu'il était à un commit :
 
-~~~{.bash}
+~~~
 $ git checkout <SHA1 du commit>
 ~~~
 
 Pour se remettre sur la version courante :
 
-~~~{.bash}
+~~~
 $ git checkout master
 ~~~
 
 Pour créer une branche et switcher directement dans cette nouvelle branche, on utilise l'option `-b` :
 
-~~~{.bash}
+~~~
 $ git checkout -b myfeature
 ~~~
 
 Pour annuler toutes les modifications d'un fichier foo/ non indexé :
 
-~~~{.bash}
+~~~
 $ git checkout foo/
 ~~~
 
@@ -411,19 +411,19 @@ $ git checkout foo/
 Une branche est en fait la création une déviation, un commit qui a deux *enfants*.
 On peut ainsi créer une branche à partir de n'importe quel commit :
 
-~~~{.bash}
+~~~
 $ git branch newbranch e150b8517a694a2d4816cff95ef612086d644f67
 ~~~
 
 Pour supprimer la branche *foo* sur un dépôt distant non cloné :
 
-~~~{.bash}
+~~~
 $ git push ssh://git.example.com/projet.git :foo
 ~~~
 
 Pour récupérer une nouvelle branche depuis le dépôt référencé comme distant :
 
-~~~{.bash}
+~~~
 $ git remote update
 ~~~
 
@@ -436,7 +436,7 @@ $ git remote update
 
 Pour supprimer toutes les modifications non commitées et les fichiers/répertoires non indexés :
 
-~~~{.bash}
+~~~
 $ git reset --hard
 $ git clean -f -d
 ~~~
@@ -446,7 +446,7 @@ Ou même sur une branche distante comme *origin/master* par exemple (ce qui est
 
 Pour désindexer des modifications d'un fichier :
 
-~~~{.bash}
+~~~
 $ git reset HEAD <fichier>
 ~~~
 
@@ -456,13 +456,13 @@ $ git reset HEAD <fichier>
 
 Pour ajouter tout un répertoire et son contenu :
 
-~~~{.bash}
+~~~
 $ git add foo/
 ~~~
 
 Pour choisir ce que l'on veut ajouter pour le prochain commit :
 
-~~~{.bash}
+~~~
 $ git add -p
 ~~~
 
@@ -485,7 +485,7 @@ Quand un merge n'est pas simple, Git peut adopter plusieurs stratégies (resolve
 
 On peut utiliser une option pour exclure l'application de certain fichier du diff :
 
-~~~{.bash}
+~~~
 $ git apply --exclude=debian/changelog /tmp/foo.diff
 ~~~
 
@@ -495,7 +495,7 @@ $ git apply --exclude=debian/changelog /tmp/foo.diff
 
 Pour voir qui a modifié les lignes d'un fichier *foo/bar* :
 
-~~~{.bash}
+~~~
 $ git blame foo/bar
 ~~~
 
@@ -508,13 +508,13 @@ On peut éditer ce fichier ou utiliser des commandes pour le faire.
 
 Pour ajouter un dépôt distant :
 
-~~~{.bash}
+~~~
 $ git remote add origin2 ssh://git.example.com/path/projet.git
 ~~~
 
 Pour lister les dépôts distants configurés :
 
-~~~{.bash}
+~~~
 $ git remote
 ~~~
 
@@ -522,13 +522,13 @@ $ git remote
 
 Pour transmettre ses 3 derniers commits, on peut générer 3 patches qui contiendront les diffs ainsi que les messages de commit :
 
-~~~{.bash}
+~~~
 $ git format-patch -3
 ~~~
 
 Si l'on a ces 3 patches, on peut les appliquer sur son dépôt local ainsi :
 
-~~~{.bash}
+~~~
 $ git am 000*.patch
 ~~~
 
@@ -545,7 +545,7 @@ Un dépôt classique possède un répertoire `.git/` qui contient toutes les don
 
 Quand on crée un dépôt ayant vocation à servir de dépôt central, il est préférable de ne pas avoir de *working copy* : il s'agira alors d'un **bare repository** que l'on peut initier avec la commande :
 
-~~~{.bash}
+~~~
 $ mkdir foo
 $ cd foo
 $ git init --bare
@@ -616,7 +616,7 @@ done
 
 On lance ensuite la commande suivante :
 
-~~~{.bash}
+~~~
 $ git svn --authors-file=path/to/authors_file clone svn+ssh://svn.example.com/path/to/repo
 ~~~
 
@@ -624,7 +624,7 @@ $ git svn --authors-file=path/to/authors_file clone svn+ssh://svn.example.com/pa
 
 Lancer la commande suivante :
 
-~~~{.bash}
+~~~
 $ git cvsimport -C repo_git -r cvs -k -vA path/to/authors_file -d user@hostname:/path/to/cvsroot repo
 ~~~
 
@@ -632,7 +632,7 @@ $ git cvsimport -C repo_git -r cvs -k -vA path/to/authors_file -d user@hostname:
 
 Lancer la commande suivante :
 
-~~~{.bash}
+~~~
 $ git-archimport -v foo@arch.example.com--branch
 ~~~
 
@@ -651,13 +651,13 @@ done
 
 Puis exécuter la commande suivante dans votre dépôt :
 
-~~~{.bash}
+~~~
 $ git filter-branch --tree-filter /tmp/recode-all-files HEAD
 ~~~
 
 Exécuter ensuite la commande suivante pour convertir les messages de commit :
 
-~~~{.bash}
+~~~
 $ git filter-branch --msg-filter 'iconv -f iso-8859-1 -t utf-8' -- --all
 ~~~
 
@@ -702,7 +702,7 @@ Il faut ajouter dans la config du repository « distant » :
 
 Il suffit de supprimer tous les fichiers sauf le `.git`, par exemple :
 
-~~~{.bash}
+~~~
 $ rm -rf *
 ~~~
 
@@ -725,7 +725,7 @@ $ git hooks.mailinglist git@example.com
 
 Pour recevoir les patches :
 
-~~~{.bash}
+~~~
 $ git config hooks.showrev "git show -C %s; echo
 ~~~
 
@@ -733,7 +733,7 @@ $ git config hooks.showrev "git show -C %s; echo
 
 (à éviter autant que possible bien sûr)
 
-~~~{.bash}
+~~~
 $ git config --global http.sslverify "false"
 ~~~
 
@@ -743,7 +743,7 @@ Quand on supprime des commits, ils ne sont pas vraiment supprimés du dépôt.
 Cela offre l'avantage de pouvoir les retrouver en cas de besoin.
 Si l'on veut gagner de la place, on peut aussi faire un nettoyage :
 
-~~~{.bash}
+~~~
 $ git repack
 $ git gc
 ~~~
@@ -753,7 +753,7 @@ $ git gc
 Il se peut qu'on change de forge (passage de gitolite à gitlab par
 exemple) et il faut alors migrer les dépots. Un moyen de faire :
 
-~~~{.bash}
+~~~
 $ for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master`; do rbranch=$(echo $branch | tr '/' ' ' | awk '{print $3}') ; git checkout -b $rbranch $branch ; done
 $ git remote add gitlab gitlab@gitlab.example.com:group/repo.git && git push gitlab --all && git remote remove origin && git remote rename gitlab origin && git push --set-upstream origin master
 ~~~

HowtoHTTP.md

@@ -129,11 +129,11 @@ Voir [TipsCurl]()
 
 Utilisation :
 
-~~~{.bash}
+~~~
 $ ab -n 1000 -c 100 -l http://127.0.0.1/helloworld.txt
 ~~~
 
 * `-n` : nombre de requêtes
 * `-c` : nombre de requêtes effectuées en simultané
 * `-l` : option importante qui tolère la variation de la réponse du serveur (si non, les requêtes seront notées en *Failed requests*)
-* `-k` : active le HTTP KeepAlive
+* `-k` : active le HTTP KeepAlive

HowtoKeePassX.md

@@ -22,7 +22,7 @@ Vous pouvez créer un fichier .kdb protégé par qui va stocker vos mots de pass
 
 Vous pourrez ainsi ultérieurement l'utiliser via :
 
-~~~{.bash}
+~~~
 $ keepass db.kdb
 ~~~
 
@@ -51,11 +51,11 @@ kpcli:/Internet> show 0
  Path: /Internet
 Title: foo
 Uname: foo
- Pass: 
+ Pass:
   URL: https://secure.example.com/
-Notes: 
+Notes:
 
 kpcli:/Internet> exit
 ~~~
 
-Note : le champ "Pass" est invisible mais l'on peut le copier/coller avec la souris.
+Note : le champ "Pass" est invisible mais l'on peut le copier/coller avec la souris.

HowtoSSL.md

@@ -25,20 +25,20 @@ OpenSSL 1.0.2h  3 May 2016
 
 Pour générer une clé privée non chiffrée (private.key) et sa demande de certificat associé (demande.csr) à transmettre à une autorité de certification :
 
-~~~{.bash}
+~~~
 $ openssl req -newkey rsa:2048 -sha256 -nodes -keyout private.key -out demande.csr
 ~~~
 
 À des fins pédagogiques, on peut découper la cette génération en 2 étapes, à savoir la génération de la clé privée et la demande de certificat :
 
-~~~{.bash}
+~~~
 $ openssl genrsa -out private.key 2048
 $ openssl req -new -sha256 -key private.key -out demande.csr
 ~~~
 
 Pour générer une demande de certificat à partir d'un certificat existant (certificat.crt) :
 
-~~~{.bash}
+~~~
 $ openssl x509 -x509toreq -sha256 -in certificat.crt -out demande.csr -signkey private.key
 ~~~
 
@@ -47,7 +47,7 @@ $ openssl x509 -x509toreq -sha256 -in certificat.crt -out demande.csr -signkey p
 1. Prérequis : avoir généré une clé et une demande de certificat (voir ci dessus)
 2. Génération du certificat avec expiration dans 1000 jours :
 
-~~~{.bash}
+~~~
 $ openssl x509 -req -sha256 -days 1000 -in demande.csr -signkey private.key -out certificat.crt
 ~~~
 
@@ -68,13 +68,13 @@ Modifier une copie du fichier `/etc/ssl/openssl.cnf` avant de générer le certi
 
 Puis générer la clé privée et le certificat associé (avec expiration dans 1000 jours) :
 
-~~~{.bash}
+~~~
 $ openssl req -newkey rsa:2048 -nodes -x509 -sha256 -days 1000 -config openssl.cnf -extensions v3_req -keyout private.key -out certificat.crt
 ~~~
 
 Si l'on veut plutôt une demande de certificat (pour transmettre à une autorité de certification) :
 
-~~~{.bash}
+~~~
 $ openssl req -newkey rsa:2048 -nodes -sha256 -days 1000 -config openssl.cnf -extensions v3_req -keyout private.key -out demande.csr
 ~~~
 
@@ -82,7 +82,7 @@ $ openssl req -newkey rsa:2048 -nodes -sha256 -days 1000 -config openssl.cnf -ex
 
 Si une clé privée a été chiffrée (private.pem), on peut générer une version non chiffrée (private.key) ainsi :
 
-~~~{.bash}
+~~~
 $ openssl rsa -in private.pem -out private.key
 $ rm private.pem
 ~~~
@@ -100,7 +100,7 @@ Verifying - Enter PEM pass phrase:
 
 Il suffit de répéter les 2 étapes ci-dessus :
 
-~~~{.bash}
+~~~
 $ openssl rsa -in private.pem -out private.key
 $ openssl rsa -in private.key -des3 -out private-new.pem
 $ rm private.pem private.key
@@ -113,13 +113,13 @@ Voir <http://security.ncsa.illinois.edu/research/grid-howtos/usefulopenssl.html>
 
 Notamment pour PKCS 12 (ou PFX) vers PEM :
 
-~~~{.bash}
+~~~
 $ openssl pkcs12 -in private.pfx -out private.pem
 ~~~
 
 S'il s'agit de la clé :
 
-~~~{.bash}
+~~~
 $ openssl pkcs12 -in private.pfx -nocerts -out private.pem
 ~~~
 
@@ -133,25 +133,25 @@ Voir <http://trac.evolix.net/infogerance/wiki/HowtoLetsEncrypt>
 
 Pour voir le contenu d'un certificat (certificat.crt) :
 
-~~~{.bash}
+~~~
 $ openssl x509 -text -in certificat.crt
 ~~~
 
 Pour voir le contenu d'un certificat d'un service réseau :
 
-~~~{.bash}
+~~~
 $ openssl s_client -connect ssl.example.com:443
 ~~~
 
 Pour voir le contenu d'une demande de certificat (demande.csr) :
 
-~~~{.bash}
+~~~
 $ openssl req -text -in demande.csr
 ~~~
 
 Pour lire le format PFX :
 
-~~~{.bash}
+~~~
 $ openssl pkcs12 -info -in certificat.pfx
 ~~~
 
@@ -159,7 +159,7 @@ $ openssl pkcs12 -info -in certificat.pfx
 
 Pour s'assurer qu'un certificat est bien issu d'un clé privée, ou d'une demande de certificat (.csr), on peut vérifier la correspondance grâce au *modulus* que l'on peut extraire et comparer :
 
-~~~{.bash}
+~~~
 $ openssl x509 -noout -modulus -in certificat.crt | openssl md5
 $ openssl rsa -noout -modulus -in private.key | openssl md5
 $ openssl req -noout -modulus -in demande.csr | openssl md5
@@ -169,7 +169,7 @@ Si toutes les empreintes MD5 sont identiques, on est sûr que c'est issu de la c
 
 Pour vérifier en une seule commande :
 
-~~~{.bash}
+~~~
 $ diff <(openssl rsa -in private.key -modulus | grep Modulus) <(openssl x509 -in certificate.crt -modulus | grep Modulus)
 ~~~
 
@@ -184,7 +184,7 @@ http://ocsp.example.com
 
 Puis, interroger le serveur OCSP obtenu (ici http://ocsp.example.com) avec la chaîne de certification (chainfile.pem) et le certificat (certificat.crt) à vérifier :
 
-~~~{.bash}
+~~~
 $ openssl ocsp -issuer chainfile.pem -cert certificat.crt -text -url http://ocsp.example.com
 ~~~
 
@@ -203,25 +203,25 @@ Revocation Time: Nov  2 09:30:00 2014 GMT
 
 Pour vérifier un fichier de certificat en ligne de commande :
 
-~~~{.bash}
+~~~
 $ openssl verify -CApath /etc/ssl/certs certificat.crt
 ~~~
 
 Pour vérifier la conformité d'un certificat d'un service réseau en ligne de commande :
 
-~~~{.bash}
+~~~
 $ openssl s_client -CApath /etc/ssl/certs -connect ssl.example.com:443
 ~~~
 
 Pour un service réseau en STARTTLS (exemple avec SMTP, valable aussi pour POP3/IMAP/FTP) :
 
-~~~{.bash}
+~~~
 $ openssl s_client -CApath /etc/ssl/certs -connect mail.site.com:25 -crlf -starttls smtp
 ~~~
 
 Pour un service en HTTPS avec l'option SNI qui permet d'envoyer un nom de domaine au sein du protocole SSL/TLS (supporté par 99.9% des navigateurs récents) :
 
-~~~{.bash}
+~~~
 $ openssl s_client -CApath /etc/ssl/certs -servername ssl.example.com -connect 192.0.2.42:443
 ~~~
 
@@ -309,18 +309,18 @@ La faille POODLE (adding Oracle On Downgraded Legacy Encryption) est une vulnér
 * Désactiver SSL 3.0 pour Nginx 1.2 : `ssl_protocols TLSv1 TLSv1.1 TLSv1.2;`
 * Désactiver SSL 3.0 pour Postfix : `smtpd_tls_mandatory_protocols=!SSLv2,!SSLv3 smtp_tls_mandatory_protocols=!SSLv2,!SSLv3 smtpd_tls_protocols=!SSLv2,!SSLv3 smtp_tls_protocols=!SSLv2,!SSLv3`
 
-#### Faille FREAK 
+#### Faille FREAK
 
-La faille FREAK (Factoring RSA Export Keys) est une vulnérabilité dans OpenSSL permettant une attaque *man-in-the-middle* pour renégocier 
+La faille FREAK (Factoring RSA Export Keys) est une vulnérabilité dans OpenSSL permettant une attaque *man-in-the-middle* pour renégocier
 un chiffrement faible. Cela se base sur des chiffrements « EXPORT » introduits dans les années 2000 par les USA pour pouvoir déchiffrement les communications. Voir <http://blog.cryptographyengineering.com/2015/03/attack-of-week-freak-or-factoring-nsa.html>, <https://freakattack.com/#sysadmin> et <https://www.smacktls.com/>.
 
 On peut tester si un serveur accepte les chiffrements EXPORT avec la commande suivante :
 
-~~~{.bash}
+~~~
 $ openssl s_client -connect example.com:443 -cipher EXPORT
 ~~~
 
-Si on obtient *error:14077410:SSL routines:SSL23_GET_SERVER_HELLO:sslv3 alert handshake failure:s23_clnt.c:749* c'est que le serveur n'accepte pas les chiffrements EXPORT. 
+Si on obtient *error:14077410:SSL routines:SSL23_GET_SERVER_HELLO:sslv3 alert handshake failure:s23_clnt.c:749* c'est que le serveur n'accepte pas les chiffrements EXPORT.
 
 Debian [a corrigé cette faille en janvier2015](https://security-tracker.debian.org/tracker/CVE-2015-0204), ce qui est surtout important pour les clients (navigateurs, etc.). On peut vérifier que sa machine ne tolère pas de chiffrements « EXPORT » via la commande `openssl ciphers | tr -s ':' '\n' | sort | grep EXP`. Sous Debian, par défaut Apache et Nginx n'ont pas été impactés car leur liste de chiffrement n'incluait pas EXPORT.
 
@@ -378,7 +378,7 @@ ssl_dhparam /etc/ssl/dhparam.pem;
 
 Note : il faut générer ses propres paramètres Diffie-Hellman ; pour des paramètres de 2048 bits (attention, c'est un peu long), on fera:
 
-~~~{.bash}
+~~~
 $ openssl dhparam -out /etc/ssl/dhparam.pem 2048
 ~~~
 

HowtoScreen.md

@@ -10,7 +10,7 @@ Il permet ainsi de lancer facilement des process dans un terminal et de les lais
 
 ## Installation
 
-~~~{.bash}
+~~~
 # apt install screen
 ~~~
 
@@ -28,19 +28,19 @@ There are screens on:
 
 Pour lancer un nouveau screen (l'option *-S foo* est facultative, elle permet juste de nommer son screen) :
 
-~~~{.bash}
+~~~
 $ screen -S foo
 ~~~
 
 Pour se rattacher à un screen existant avec le numéro 30742 (voir screen -ls) :
 
-~~~{.bash}
+~~~
 $ screen -rd 30742
 ~~~
 
 Pour se rattacher à un screen existant et utilisé en partage (permettant de voir à plusieurs un terminal) :
 
-~~~{.bash}
+~~~
 $ screen -x 30742
 ~~~
 
@@ -54,11 +54,11 @@ Ctrl+a+a : faire un Ctrl+a
 <Ctrl>+a+q : defreezer le screen courant (utile quand on freeze par erreur...)
 ~~~
 
-## Utilisation avancée 
+## Utilisation avancée
 
 Supprimer les screen "morts" :
 
-~~~{.bash}
+~~~
 $ screen -wipe
 ~~~
 
@@ -91,7 +91,7 @@ Gestion des copier/coller :
 
 ## screen avec port série
 
-~~~{.bash}
+~~~
 $ screen /dev/ttyS0 38400
 ~~~
 

HowtoTmux.md

@@ -3,11 +3,11 @@ title: Howto Tmux
 categories: sysadmin
 ...
 
-Tout comme screen, Tmux permet de gérer des terminaux lancés en arrière plan. Il s'agit d'une alternative enrichie qui prend notamment en charge des splits plus complexes. 
+Tout comme screen, Tmux permet de gérer des terminaux lancés en arrière plan. Il s'agit d'une alternative enrichie qui prend notamment en charge des splits plus complexes.
 
 Il diffère de screen avec le concept de fenêtres et "panes". Un "pane" tmux est une fenêtre dans la terminologie de screen. Une fenêtre tmux est un agencement d'un ou plusieurs "pane(s)" (par exemple, deux fenêtres côte à côte).
 
-D'autres points de comparaison : 
+D'autres points de comparaison :
 
 - les fenêtres sont des entités indépendantes qui peuvent être attachées simultanément à plusieurs sessions et peuvent être déplacées librement entre les sessions d'un même serveur tmux
 - plusieurs buffers
@@ -18,7 +18,7 @@ D'autres points de comparaison :
 
 ## Installation
 
-~~~{.bash}
+~~~
 # apt install tmux
 ~~~
 
@@ -34,25 +34,25 @@ travail: 1 windows (created Fri Oct 21 16:05:10 2016) [315x78]
 
 Pour lancer une nouvelle session :
 
-~~~{.bash}
+~~~
 $ tmux
 ~~~
 
 Pour lancer une nouvelle session sous le nom test:
 
-~~~{.bash}
+~~~
 $ tmux new -s test
 ~~~
 
 Pour lancer une nouvelle session avec mutt par exemple :
 
-~~~{.bash}
+~~~
 $ tmux new mutt
 ~~~
 
 Pour se rattacher à la session tmux 1 (voir tmux ls) :
 
-~~~{.bash}
+~~~
 $ tmux attach -t 1
 ~~~
 
@@ -67,7 +67,7 @@ Une fois attaché à une session tmux, voici la liste des commandes de base util
 <Ctrl>+b+w : lister les fenêtres disponibles
 ~~~
 
-## Utilisation avancée 
+## Utilisation avancée
 
 ### panneaux
 

HowtoTracToMarkdown.md

@@ -73,7 +73,7 @@ STDOUT.write(output)
 
 Copiez simplement ce script là où vous le souhaitez, rendez-le exécutable puis :
 
-~~~{.bash}
+~~~
 $ cat Page.trac | trac2md
 ~~~
 

HowtoVarnish.md

@@ -290,7 +290,7 @@ if (req.url ~ "^/regex$")
 if (req.backend.healthy)
 # Présence de l'entête Accept-Encoding
 if (req.http.Accept-Encoding)
-# Condition sur la requête faite 
+# Condition sur la requête faite
 if (req.method != "GET" && req.method != "HEAD")
 # Présence de l'entête X-Forwarded-For
 if (req.http.x-forwarded-for)
@@ -432,7 +432,7 @@ varnish> ban req.http.host ~ .
 
 On peut aussi purger avec une requête HTTP **PURGE** :
 
-~~~{.bash}
+~~~
 $ curl -X PURGE http://www.example.org/foo.txt
 ~~~
 
@@ -516,7 +516,7 @@ sub vcl_recv {
    }
 ~~~
 
-Pour finir, quelques informations sur le load-balancing avec Varnish 
+Pour finir, quelques informations sur le load-balancing avec Varnish
 
 * Gestion d'un poids pour chaque backend ? Oui, depuis Varnish 2.1.4 on peut préciser des poids pour chaque backend.
 * Gestion du maximum de connexions pour un backend ? via le paramètre *.max_connections*
@@ -547,7 +547,7 @@ Note : le *saint mode* (qui permet de laisser tranquille pendant un temps défin
 
 ### Nagios
 
-On peut se servir du retour de la commande *varnishadm* pour s'assurer du bon état de santé du démon. Ce plugin Nagios utilise ce principe : <http://exchange.nagios.org/directory/Plugins/Websites%2C-Forms-and-Transactions/check_varnish_health/details>. 
+On peut se servir du retour de la commande *varnishadm* pour s'assurer du bon état de santé du démon. Ce plugin Nagios utilise ce principe : <http://exchange.nagios.org/directory/Plugins/Websites%2C-Forms-and-Transactions/check_varnish_health/details>.
 
 ### Munin
 
@@ -568,7 +568,7 @@ On peut se servir du retour de la commande *varnishadm* pour s'assurer du bon é
 
 ### Exemple pour Wordpress
 
-Voici un exemple de règles pour un site utilisant WordPress : 
+Voici un exemple de règles pour un site utilisant WordPress :
 
 ~~~
 backend default {
@@ -735,5 +735,4 @@ Un reload ne suffit parfois pas, un restart sera nécessaire dans certains cas.
 
 ### Temps d'attente du client HTTP ?
 
-Quand un client HTTP interroge Varnish, il va le mettre en attente afin d'interroger le serveur HTTP final (si l'objet n'est pas caché). Pendant que le serveur HTTP final renvoie l'objet demandé à Varnish, le client HTTP est toujours mis en attente, le contenu lui sera renvoyé seulement une fois l'objet reçu à 100% par Varnish. Cela peut poser différents problèmes : dans le cas d'une grosse vidéo le démarrage sera lent, si le timeout du client HTTP est bas il peut fermer la connexion trop tôt, etc. Pour contourner ce problème, on peut utiliser le return *(pipe)*. 
-
+Quand un client HTTP interroge Varnish, il va le mettre en attente afin d'interroger le serveur HTTP final (si l'objet n'est pas caché). Pendant que le serveur HTTP final renvoie l'objet demandé à Varnish, le client HTTP est toujours mis en attente, le contenu lui sera renvoyé seulement une fois l'objet reçu à 100% par Varnish. Cela peut poser différents problèmes : dans le cas d'une grosse vidéo le démarrage sera lent, si le timeout du client HTTP est bas il peut fermer la connexion trop tôt, etc. Pour contourner ce problème, on peut utiliser le return *(pipe)*.

HowtoVim.md

@@ -31,13 +31,13 @@ Ctrl+v NNN où NNN est le numéro ASCII du caractère
 
 Exécuter automatiquement des commandes :
 
-~~~{.bash}
+~~~
 $ vim ":retab" "+wq"
 ~~~
 
 Écrire des commandes dans un script puis les rejouer :
 
-~~~{.bash}
+~~~
 $ vim -s script.txt FICHIER
 $ vim -w script.txt FICHIER2
-~~~
+~~~

PracticeSymfony.md

@@ -27,6 +27,6 @@ Il faut indiquer le paramètre `date.timezone = "Europe/Paris"` dans les fichier
 
 Pour tester la configuration PHP, des tests peuvent être lancés ainsi :
 
-~~~{.bash}
+~~~
 $ php bin/symfony_requirements
-~~~
+~~~

Syntaxe.md

@@ -22,7 +22,7 @@ Voir [Help#markdown]()
 
 Commandes Shell (sans output) :
 
-    ~~~{.bash}
+    ~~~
     $ apt-cache search foo
     # apt install foo
     ~~~
@@ -40,6 +40,11 @@ Fichiers avec coloration syntaxique si disponible (voir ci-dessous) :
     ServerName www.example.com
     ~~~~
 
+    ~~~{.bash}
+    #!/bin/bash
+    echo toto
+    ~~~~
+
 Liens externes :
 
     <http://www.example.com/>
@@ -65,7 +70,7 @@ Pour afficher le "symbole" `/!\`, il est important d'échaper le dernier caract
 Une commande lancée en root sera précédée de **#** ; en utilisateur elle sera précédée de **$**.
 Dans la mesure du possible, le maximum de commande devra être lancée en tant qu'utilisateur.
 
-~~~{.bash}
+~~~
 $ apt-cache search foo
 # apt install foo
 ~~~

TipsFirefox.md

@@ -28,6 +28,6 @@ Note : browser-plugin-freshplayer-pepperflash est dans jessie-backports
 
 ## Gestionnaire de profils
 
-~~~{.bash}
+~~~
 $ firefox --ProfileManager
-~~~
+~~~