// formation · Fondamentaux en informatique
Git : les fondamentaux du contrôle de version
- 12 chapitres
- ≈ 16 min de lecture
- Cours 3 / 6
- Accès libre
Scripts d’administration, fichiers de configuration, playbooks, documentation, code applicatif : dans une équipe informatique, presque tout ce qui se modifie mérite d’être versionné. Ce cours s’adresse aux techniciens, administrateurs et développeurs de PME, ainsi qu’aux stagiaires, qui veulent maîtriser Git en ligne de commande : comprendre son modèle, travailler proprement au quotidien, collaborer à plusieurs et corriger ses erreurs sans perdre de travail.
Prérequis : être à l’aise avec un terminal Linux (navigation, édition de fichiers, droits). Si besoin, commencez par le cours Scripting Shell – Découverte des fondamentaux. Les commandes de ce cours ont été vérifiées sur la documentation officielle de Git (git-scm.com, version 2.56 au moment de la rédaction).
1. Pourquoi un gestionnaire de versions ?
Sans outil dédié, l’historique d’un fichier se résume souvent à des copies : config.bak, config-ancien, script_v2_final.sh. Impossible de savoir qui a changé quoi, quand et pourquoi, ni de revenir proprement à un état antérieur. Un gestionnaire de versions enregistre chaque état significatif d’un ensemble de fichiers, avec son auteur, sa date et un message explicatif.
On distingue deux familles :
- Centralisée (CVS, Subversion) : un serveur unique détient l’historique ; chaque poste n’a qu’une copie de travail. Sans le serveur, pas d’historique ni de validation.
- Distribuée (Git, Mercurial) : chaque clone contient l’historique complet. On consulte, compare, crée des branches et valide hors ligne ; la synchronisation avec les autres dépôts est une opération distincte.
Git a été créé en 2005 par Linus Torvalds pour le développement du noyau Linux. Il est aujourd’hui le standard de fait, utilisé aussi bien sur des forges publiques que sur des forges auto-hébergées comme Forgejo, GitLab ou Gitea.
Pour un service informatique, les bénéfices sont concrets : traçabilité des changements de configuration (utile en audit et après incident), retour arrière rapide, travail en parallèle sans écrasement, revue des modifications avant mise en production, et base de toute chaîne d’intégration et de déploiement continus.
Bonne pratique : versionnez tout ce qui est texte et produit par des humains (scripts, configurations, infrastructure as code, documentation). Ne versionnez pas ce qui se régénère (binaires compilés, dépendances téléchargées, journaux) ni, surtout, les secrets.
2. Le modèle de Git : des instantanés, pas des différences
Là où d’anciens outils stockaient une suite de différences par fichier, Git enregistre à chaque validation un instantané complet de l’arborescence. Les fichiers inchangés ne sont pas dupliqués : Git réutilise simplement l’objet déjà stocké.
Tout est rangé dans une base d’objets (le répertoire .git/objects), chaque objet étant identifié par l’empreinte cryptographique de son contenu :
- blob : le contenu d’un fichier, sans son nom ;
- tree : un répertoire, c’est-à-dire une liste de noms pointant vers des blobs et d’autres trees ;
- commit : un instantané (un tree racine), son ou ses parents, l’auteur, le validateur, la date et le message ;
- tag annoté : une étiquette nommée et signée ou non, pointant vers un commit.
Schéma à retenir : chaque commit pointe vers son parent, ce qui forme une chaîne A ← B ← C. Une branche n’est qu’un pointeur mobile vers un commit (un petit fichier contenant une empreinte) ; HEAD désigne la branche, ou le commit, sur lequel on travaille. Créer une branche ne coûte donc presque rien.
Par défaut, les identifiants sont des empreintes SHA-1 de 40 caractères hexadécimaux (on n’en tape généralement que les 7 premiers). Git sait aussi créer des dépôts en SHA-256 (git init --object-format=sha256), et le projet prévoit d’en faire le format par défaut des nouveaux dépôts avec Git 3.0. Comme le contenu détermine l’identifiant, toute altération d’un objet ou de l’historique change les empreintes : l’intégrité est vérifiable.
git cat-file -t HEAD # type de l’objet : commit
git cat-file -p HEAD # contenu du commit : tree, parent, auteur, message
git cat-file -p 'HEAD^{tree}' # contenu du répertoire racine
3. Installation et configuration initiale
Git est disponible dans toutes les distributions Linux, sur macOS (outils en ligne de commande Xcode ou Homebrew) et sur Windows (Git for Windows, qui fournit aussi Git Bash). Sur Debian ou Ubuntu :
sudo apt update
sudo apt install git
git --version
La configuration se fait avec git config, à trois niveaux, le plus spécifique l’emportant :
--system: pour tous les utilisateurs de la machine (fichier/etc/gitconfig) ;--global: pour votre compte (~/.gitconfig) ;--local(par défaut dans un dépôt) : pour ce dépôt seulement (.git/config).
Avant le premier commit, renseignez votre identité : elle est inscrite dans chaque commit et ne peut plus être modifiée sans réécrire l’historique.
git config --global user.name "Prénom Nom"
git config --global user.email "prenom.nom@exemple.fr"
git config --global init.defaultBranch main
git config --global core.editor nano
git config --list --show-origin
Sans réglage, la branche initiale s’appelle encore master ; la documentation annonce le passage à main avec Git 3.0. Fixer init.defaultBranch dès maintenant évite les incohérences entre postes. Une branche initiale peut aussi être choisie à la création : git init -b main.
L’aide intégrée est complète et toujours à jour avec votre version : git help commit ou git commit -h pour un résumé des options.
Bonne pratique : sur un poste partagé ou pour un compte de service, n’utilisez pas
--globalavec une identité personnelle ; configurez l’identité au niveau du dépôt. Sur un poste professionnel, utilisez l’adresse de messagerie de l’entreprise.
4. Les trois zones et le cycle de travail
Comprendre Git, c’est d’abord comprendre ses trois zones :
- le répertoire de travail : les fichiers tels que vous les éditez ;
- l’index (ou zone de préparation, staging area) : ce qui fera partie du prochain commit ;
- le dépôt (répertoire
.git) : l’historique des commits.
Schéma du cycle : on modifie un fichier dans le répertoire de travail, on choisit ce qu’on veut valider avec git add (passage vers l’index), puis on enregistre l’instantané avec git commit (passage vers le dépôt). L’index permet de découper un travail en commits cohérents, même si plusieurs fichiers ont été modifiés en même temps.
git init # crée le dépôt (.git) dans le répertoire courant
git status # état des fichiers : non suivis, modifiés, indexés
git add fichier.conf # ajoute le fichier (ou ses modifications) à l’index
git add -p # choisit les modifications morceau par morceau
git diff # différences répertoire de travail / index
git diff --staged # différences index / dernier commit
git commit -m "Ajoute la configuration du proxy"
Un fichier est soit non suivi (jamais ajouté), soit suivi ; un fichier suivi peut être inchangé, modifié ou indexé. git status indique toujours dans quel état se trouve chaque fichier et suggère les commandes utiles.
Ignorer des fichiers. Le fichier .gitignore, versionné à la racine du dépôt, liste les motifs à ne jamais proposer à l’indexation :
# .gitignore
*.log
*.tmp
/build/
.env
.gitignore n’agit que sur les fichiers non suivis. Pour cesser de suivre un fichier déjà validé sans le supprimer du disque : git rm --cached fichier, puis un commit. Attention : le fichier reste présent dans les commits précédents.
Bonne pratique : des commits petits et cohérents (une intention par commit), un message dont la première ligne résume le changement en une cinquantaine de caractères à l’impératif, puis, après une ligne vide, le « pourquoi » si nécessaire. Exemple : « Restreint SSH au réseau d’administration ».
5. Lire et exploiter l’historique
L’historique n’a de valeur que si l’on sait l’interroger. Les commandes essentielles :
git log # historique détaillé de la branche courante
git log --oneline --graph --all # vue compacte de toutes les branches
git log -p -- fichier.conf # modifications successives d’un fichier
git log --author="Martin" --since="2 weeks ago"
git log -S "PermitRootLogin" # commits ayant ajouté ou retiré cette chaîne
git show a1b2c3d # détail d’un commit (métadonnées et diff)
git diff a1b2c3d HEAD -- script.sh
git blame script.sh # dernier commit ayant modifié chaque ligne
Git propose une syntaxe pour désigner les révisions : HEAD (commit courant), HEAD~1 ou HEAD~ (parent), HEAD~3 (trois commits plus haut), HEAD^2 (second parent d’un commit de fusion), un nom de branche ou d’étiquette, ou une empreinte abrégée. Les plages main..feature désignent les commits de feature absents de main.
git blame n’a pas vocation à désigner un coupable : il retrouve le commit, donc le message et le contexte, qui expliquent une ligne. C’est souvent le moyen le plus rapide de comprendre pourquoi une option de configuration a été posée.
Bonne pratique : créez des alias pour les vues que vous utilisez souvent, par exemple
git config --global alias.lg "log --oneline --graph --all --decorate", puisgit lg.
6. Branches et fusions
Une branche permet de développer une évolution ou une correction à l’écart de la branche principale, puis de l’y intégrer une fois prête. Depuis Git 2.23, la commande git switch est dédiée au changement de branche (et git restore à la restauration de fichiers), deux usages que git checkout mélangeait ; git checkout reste disponible.
git branch # liste les branches locales
git switch -c durcissement-ssh # crée la branche et s’y place
git switch main # revient sur main
git switch - # revient sur la branche précédente
git branch -d durcissement-ssh # supprime une branche déjà fusionnée
Deux types de fusion. Si main n’a pas bougé depuis la création de la branche, git merge se contente d’avancer le pointeur : c’est une fusion fast-forward, sans nouveau commit. Si les deux branches ont divergé, Git réalise une fusion à trois points (ancêtre commun, les deux extrémités) et crée un commit de fusion à deux parents. L’option --no-ff force la création d’un commit de fusion, pour garder la trace de la branche dans l’historique.
git switch main
git merge durcissement-ssh
git merge --no-ff fonction-sauvegarde
Conflits. Lorsque les deux branches modifient les mêmes lignes, Git s’arrête et marque les zones concernées dans le fichier :
<<<<<<< HEAD
Port 2222
=======
Port 22022
>>>>>>> durcissement-ssh
On édite le fichier pour garder la bonne version, on supprime les marqueurs, puis git add et git commit (ou git merge --continue). En cas de doute, git merge --abort revient à l’état d’avant la fusion. Un conflit n’est pas une erreur : c’est Git qui refuse de décider à votre place.
Rebase. Autre façon d’intégrer : git rebase main, lancé depuis une branche, rejoue ses commits au-dessus de main. L’historique devient linéaire, mais les commits rejoués reçoivent de nouvelles empreintes : on ne rebase donc que des commits qui n’ont pas encore été partagés.
7. Dépôts distants et collaboration
Un dépôt distant est un autre dépôt Git avec lequel on échange des commits : sur une forge, sur un serveur accessible en SSH ou simplement dans un autre répertoire. Les dépôts partagés sont généralement nus (bare) : ils contiennent l’historique mais pas de répertoire de travail.
git clone https://forge.exemple.fr/infra/scripts.git # copie complète, distant nommé origin
git init --bare /srv/git/scripts.git # dépôt partagé sans répertoire de travail
git remote add origin ssh://git@forge.exemple.fr/infra/scripts.git
git remote -v # distants configurés
Les échanges reposent sur quatre commandes :
git fetch: récupère les nouveaux commits du distant et met à jour les branches de suivi (origin/main), sans toucher à vos branches ;git merge origin/mainougit rebase origin/main: intègre ces commits à votre branche ;git pull: enchaînefetchpuis l’intégration ;git push: envoie vos commits ; il est refusé si le distant contient des commits que vous n’avez pas (mise à jour non fast-forward).
git push -u origin main # premier envoi et lien de suivi entre main et origin/main
git switch -c correctif-dns
git push -u origin correctif-dns
git fetch --prune # nettoie les branches de suivi supprimées côté distant
git push origin --delete correctif-dns
En cas de refus, on récupère d’abord le travail des autres (git pull), on résout les éventuels conflits, puis on renvoie. Ne forcez jamais l’envoi sur une branche partagée ; si une réécriture est indispensable sur votre propre branche, préférez git push --force-with-lease, qui refuse d’écraser des commits que vous n’auriez pas vus.
Sur une forge, le travail d’équipe s’organise autour des demandes de fusion (pull requests ou merge requests) : une branche est poussée, relue par un collègue, testée automatiquement, puis fusionnée. Les branches principales sont protégées contre l’envoi direct. Ce fonctionnement est à la base des chaînes décrites dans le cours Introduction à la Chaîne CI/CD.
Bonne pratique : authentifiez-vous auprès des forges par clé SSH (de préférence ed25519, protégée par une phrase de passe) ou par jeton à durée limitée, jamais avec un mot de passe stocké en clair dans l’URL du distant.
8. Annuler et corriger
Savoir revenir en arrière sans dégât est ce qui rend Git rassurant. Le choix de la commande dépend de l’endroit où se trouve l’erreur.
- Modification non indexée à abandonner :
git restore fichier(le fichier reprend son contenu de l’index ; la modification est perdue). - Fichier indexé par erreur :
git restore --staged fichier(le fichier sort de l’index, la modification reste sur le disque). - Dernier commit à compléter ou dont le message est faux :
git commit --amend(remplace le dernier commit par un nouveau). - Commit déjà partagé à annuler :
git revert a1b2c3dcrée un nouveau commit qui applique l’inverse ; l’historique n’est pas réécrit. - Commits locaux à défaire :
git resetdéplace la branche vers un commit antérieur.
Les trois modes de git reset se distinguent par ce qu’ils conservent :
git reset --soft HEAD~1 # annule le commit, garde les modifications indexées
git reset --mixed HEAD~1 # (mode par défaut) garde les modifications, non indexées
git reset --hard HEAD~1 # supprime aussi les modifications du répertoire de travail
Réorganiser ses commits locaux. git rebase -i HEAD~3 ouvre la liste des trois derniers commits : on peut les réordonner, fusionner (squash, fixup), renommer (reword) ou supprimer (drop). Idéal pour nettoyer une branche avant une demande de fusion.
Le filet de sécurité : le reflog. Git note chaque déplacement de HEAD dans le reflog, local à votre dépôt. Un commit « perdu » après un reset --hard ou un rebase raté y reste accessible tant qu’il n’a pas été nettoyé (par défaut, les entrées sont conservées plusieurs semaines).
git reflog
git reset --hard HEAD@{2} # revient à l’état d’il y a deux déplacements
Règle d’or : ne réécrivez jamais un historique déjà partagé (amend, rebase, reset suivis d’un envoi forcé). Sur une branche commune, corrigez avec
git revert. Et seul ce qui a été validé est protégé : une modification jamais indexée ni validée, effacée pargit restoreoureset --hard, est définitivement perdue.
9. Outils du quotidien : remise, étiquettes, cherry-pick et bisect
Mettre son travail de côté. Une urgence tombe alors que vos modifications ne sont pas prêtes à être validées ? git stash les range dans une pile et restaure un répertoire de travail propre.
git stash push -m "essai rotation des journaux"
git stash push -u -m "avec fichiers non suivis" # inclut les fichiers non suivis
git stash list
git stash pop # réapplique la dernière remise et la retire de la pile
git stash apply stash@{1}
git stash drop stash@{1}
Étiqueter les versions. Une étiquette (tag) nomme durablement un commit, typiquement une version livrée ou une configuration validée en production. Préférez les étiquettes annotées, qui portent un auteur, une date et un message, et peuvent être signées.
git tag -a v1.0 -m "Version 1.0 : déploiement initial"
git tag # liste les étiquettes
git show v1.0
git push origin v1.0 # les étiquettes ne sont pas envoyées par défaut
git push --follow-tags # envoie les étiquettes annotées des commits poussés
Récupérer un commit précis. git cherry-pick a1b2c3d applique sur la branche courante les modifications d’un commit pris ailleurs, par exemple un correctif de sécurité à reporter sur une branche de maintenance.
Trouver le commit fautif. git bisect effectue une recherche dichotomique entre un commit « bon » et un commit « mauvais » : avec 1 000 commits à examiner, une dizaine d’étapes suffisent. La recherche peut être automatisée avec un script de test, dont le code de sortie indique le verdict : 0 pour un commit bon, 1 à 127 (sauf 125) pour un commit mauvais, 125 pour un commit impossible à tester.
git bisect start
git bisect bad # la version courante est défectueuse
git bisect good v1.0 # v1.0 fonctionnait
git bisect run ./test.sh # Git teste chaque étape automatiquement
git bisect reset # termine et revient à la branche de départ
10. Sécurité : secrets, signatures et intégrité
Les secrets n’ont rien à faire dans Git. Un mot de passe, une clé privée ou un jeton validé dans un commit reste dans l’historique, donc dans chaque clone, même si le fichier est supprimé ensuite. Si cela arrive : considérez le secret comme compromis et révoquez-le en priorité ; nettoyer l’historique (avec des outils dédiés comme git filter-repo) ne vient qu’ensuite et impose à tous de recloner.
Mesures de prévention :
- placer les fichiers sensibles (
.env, clés, exports) dans.gitignoreet fournir un modèle sans valeur (.env.example) ; - stocker les secrets dans un coffre et les injecter au déploiement ;
- analyser les dépôts avec un détecteur de secrets, par exemple Trivy, qui recherche aussi des secrets dans le code, en local ou dans la chaîne CI ;
- relire
git diff --stagedavant chaque commit.
Signer ses commits. Les champs auteur et adresse d’un commit sont déclaratifs : n’importe qui peut écrire le nom d’un collègue. Une signature prouve que le commit a été produit par le détenteur d’une clé. Git sait signer avec OpenPGP, X.509 ou, plus simplement, avec une clé SSH :
git config --global gpg.format ssh
git config --global user.signingKey ~/.ssh/id_ed25519.pub
git config --global commit.gpgSign true
git config --global gpg.ssh.allowedSignersFile ~/.config/git/allowed_signers
git log --show-signature -1
Le fichier allowed_signers associe des adresses à des clés publiques autorisées ; c’est lui qui permet à git verify-commit et git log --show-signature de déclarer une signature valide. Les forges affichent un badge « vérifié » lorsque la clé publique de signature est enregistrée dans le compte de l’auteur.
Bonne pratique : protégez les branches principales sur la forge (pas d’envoi direct, pas d’envoi forcé, revue obligatoire), exigez des commits signés sur les dépôts sensibles (infrastructure, scripts de production) et ne clonez que des dépôts de confiance : des fichiers de configuration ou des hooks fournis par un tiers peuvent exécuter du code.
11. Organiser le travail d’équipe et anticiper Git 3.0
Git n’impose pas de méthode ; c’est à l’équipe de choisir un modèle de branches simple et de s’y tenir :
- Développement sur le tronc (trunk-based) : branches courtes (quelques heures à quelques jours), fusionnées souvent dans
main, qui reste toujours livrable. Adapté aux petites équipes et à l’intégration continue. - Branches de fonctionnalité avec demandes de fusion : une branche par évolution ou ticket, relue avant fusion. Le modèle le plus courant sur les forges.
- Branches de version ou de maintenance : utiles quand plusieurs versions doivent être maintenues en parallèle ; les correctifs y sont reportés par cherry-pick.
Conventions utiles : des noms de branches explicites (correctif/dns-interne, evolution/sauvegarde-nas), un format de message commun, un fichier README et un .gitignore dans chaque dépôt.
Ce qui changera avec Git 3.0. La documentation officielle « BreakingChanges » prévoit, pour les nouveaux dépôts, la branche initiale main, les empreintes SHA-256 et le format de références reftable ; Rust deviendra nécessaire à la compilation et certaines commandes obsolètes (git whatchanged, git pack-redundant) seront retirées. Aucune date de sortie n’est fixée. Les dépôts existants ne sont pas convertis automatiquement, et git switch, git restore et git checkout sont tous trois maintenus.
12. Synthèse
Git enregistre des instantanés reliés en chaîne, identifiés par l’empreinte de leur contenu ; les branches ne sont que des pointeurs. Le travail quotidien suit le cycle modification, indexation (git add), validation (git commit), puis synchronisation (git fetch, git pull, git push). On isole chaque évolution dans une branche, on fusionne après relecture, on résout les conflits sans crainte. Pour corriger : restore et reset en local, revert sur l’historique partagé, et le reflog comme filet de sécurité. Enfin, pas de secret dans les dépôts, des commits signés et des branches protégées.
Les huit travaux pratiques qui suivent reprennent ces notions dans l’ordre : préparation du laboratoire, premier dépôt, historique, branches et conflits, collaboration avec un dépôt distant, corrections, outils du quotidien, puis signature des commits et protection des secrets.
Évaluation : Git : les fondamentaux du contrôle de version
Répondez aux questions puis vérifiez votre score. Une seule bonne réponse par question.
Pour aller plus loin sur le blog : Git : le gardien incontournable des versions de code · Forgejo : la forge Git open source et auto-hébergée pour vos équipes IT · Trivy : le scanner de sécurité open source tout-en-un pour conteneurs, code et IaC
// travaux pratiques
8 TP pour mettre en pratique
- TP01 - Préparation du laboratoire et configuration de Git
- TP02 - Premier dépôt : indexer, valider et ignorer
- TP03 - Explorer l’historique et comparer les versions
- TP04 - Branches, fusions et résolution de conflits
- TP05 - Collaborer avec un dépôt distant
- TP06 - Annuler, corriger et réécrire l’historique local
- TP07 - Remise, étiquettes et recherche de régression avec bisect
- TP08 - Signer ses commits et protéger ses secrets
// formation sur mesure
Former votre équipe sur ce sujet ?
Azur Secure anime des sessions intra-entreprise, à distance ou dans vos locaux sur la Côte d'Azur, adaptées au niveau de vos équipes.
