1.1 : Git, c'est quoi ? L'analogie de l'établi et du registre du forgeron

Vous faites déjà du versionnage, mais mal

Ouvrez le dossier Scripts de votre partage réseau. Il y a de fortes chances que vous y trouviez quelque chose qui ressemble à ça :

Maj-AD.ps1
Maj-AD_v2.ps1
Maj-AD_v2_final.ps1
Maj-AD_v2_final_OK.ps1
Maj-AD_v2_final_OK - Copie.ps1
Maj-AD_ancien_NE_PAS_SUPPRIMER.ps1

Aucun administrateur système n’a jamais décidé, un matin, de créer ce genre d’arborescence. Elle apparaît toute seule, parce qu’elle répond à un besoin parfaitement légitime : avant de modifier un script qui fonctionne, on veut pouvoir revenir en arrière. Le suffixe _v2 est une sauvegarde. Le - Copie est un filet de sécurité. Le NE_PAS_SUPPRIMER est un aveu d’incertitude.

Autrement dit, vous faites déjà de la gestion de versions. Vous la faites simplement avec le seul outil dont vous disposiez : le nom du fichier.

Et cette méthode a trois défauts qui finissent toujours par se payer.

Elle ne dit pas ce qui a changé. Entre _final et _final_OK, il y a peut-être une correction de bug critique, peut-être une virgule. Pour le savoir, il faut ouvrir les deux fichiers et comparer à l’œil, ligne par ligne.

Elle ne dit pas pourquoi. Le nom du fichier ne contient aucune intention. Six mois plus tard, personne — pas même vous — ne saura si cette v2 corrigeait un incident ou testait une idée abandonnée.

Elle ne dit pas qui, ni quand. La date de modification NTFS vous donne la dernière écriture, pas l’historique. Si trois personnes ont touché le fichier en six mois, il n’en reste aucune trace.

Git, c’est exactement ce système de suffixes — mais fait correctement, par un outil dont c’est le seul métier.

La définition, en une phrase

Git est un système qui enregistre l’état complet d’un ensemble de fichiers à chaque fois que vous le lui demandez, en conservant à chaque enregistrement l’auteur, la date et la raison du changement.

Décomposons les trois idées importantes.

L’état complet. Git ne suit pas un fichier isolé : il photographie l’ensemble du dossier. Si votre script appelle un fichier de configuration et un module, les trois sont capturés ensemble, dans un état cohérent. Vous ne restaurez pas « le script d’avril », vous restaurez « l’atelier tel qu’il était en avril ».

Quand vous le lui demandez. C’est un point qui surprend beaucoup de débutants : Git n’enregistre rien automatiquement. Il attend votre ordre. Cette contrainte, qui semble être un défaut, est en réalité la source de toute sa valeur — on y revient plus bas.

L’auteur, la date et la raison. C’est la partie que votre partage réseau ne fera jamais. Et pour un administrateur système, c’est souvent la plus précieuse des trois.

L’atelier : trois zones, pas une

C’est ici que la plupart des tutoriels perdent leurs lecteurs. Ils enchaînent les commandes sans expliquer que Git manipule trois espaces distincts. Tant qu’on n’a pas ce schéma en tête, tout paraît arbitraire. Une fois qu’on l’a, tout devient évident.

Imaginez l’atelier d’un forgeron.

   ┌──────────────┐      ┌────────────────────┐      ┌─────────────────┐
   │   L'ÉTABLI   │ ───▶ │ LE PLATEAU DE      │ ───▶ │  LE REGISTRE    │
   │              │      │ MONTAGE            │      │  DE L'ATELIER   │
   │ Vos fichiers │      │ Ce que vous avez   │      │ L'historique,   │
   │ tels qu'ils  │      │ choisi de consigner│      │ gravé, daté,    │
   │ sont là,     │      │ dans la prochaine  │      │ signé, définitif│
   │ maintenant   │      │ entrée             │      │                 │
   └──────────────┘      └────────────────────┘      └─────────────────┘
     Ça bouge sans arrêt    Vous préparez le lot        Ça ne bouge plus

L’établi

C’est votre dossier de travail, celui que vous voyez dans l’explorateur de fichiers ou avec un ls. Vos scripts, vos fichiers de configuration, vos docker-compose.yml. C’est là que vous travaillez, que vous cassez des choses, que vous testez, que vous corrigez.

Sur un établi, à un instant donné, il y a du travail terminé et du travail en cours. Une pièce presque finie à côté d’un essai raté. C’est normal, et Git ne vous demande pas de ranger.

Le plateau de montage

C’est la zone que Git appelle l’index ou le staging, et c’est la plus déroutante au premier abord — parce qu’aucun autre outil que vous connaissez n’a d’équivalent.

Avant de consigner votre travail dans le registre, vous posez sur un plateau uniquement les pièces qui doivent y figurer. Vous avez modifié six fichiers cet après-midi ? Trois concernent la correction du script de sauvegarde, trois autres sont un essai sur un tout autre sujet. Vous posez les trois premiers sur le plateau, vous laissez les trois autres sur l’établi.

Pourquoi cette étape intermédiaire ? Parce qu’elle vous permet de créer des entrées d’historique cohérentes. Un enregistrement qui contient « correction du script de sauvegarde » et rien d’autre sera lisible dans six mois. Un enregistrement qui contient six modifications sans rapport entre elles ne racontera rien à personne — et surtout, il sera impossible d’en annuler une partie sans annuler le reste.

C’est une discipline, pas une contrainte technique. Mais c’est celle qui sépare un historique utile d’un historique décoratif.

Le registre de l’atelier

C’est le dépôt : un dossier caché nommé .git, à la racine de votre projet. Il contient la totalité de l’historique depuis le premier jour.

Le registre a une propriété fondamentale : on n’y rature pas. On n’efface pas une entrée passée pour la remplacer par une autre. Si on s’est trompé, on ajoute une nouvelle entrée qui corrige la précédente, et les deux restent visibles. Cette immuabilité est ce qui rend l’historique digne de confiance — un journal qu’on peut réécrire discrètement ne prouve plus rien.

Le commit : une entrée du registre

Le passage du plateau vers le registre s’appelle un commit. C’est le mot le plus important de toute la formation.

Un commit, ce n’est pas un fichier sauvegardé. C’est une entrée de journal qui contient :

Élément Ce que ça vous apporte
Un instantané de tous les fichiers suivis Restaurer un état cohérent, pas un fichier isolé
Un auteur Savoir à qui poser la question
Une date et une heure précises Corréler avec un incident, un ticket, une intervention
Un message que vous rédigez Comprendre l’intention, six mois plus tard
Un lien vers le commit précédent Reconstituer la chaîne complète des événements
Un identifiant unique (une empreinte) Désigner cet état exact, sans ambiguïté

Ce dernier point mérite une précision. Chaque commit reçoit une empreinte calculée à partir de son contenu, qui ressemble à a3f9c21. Comme elle dépend aussi du commit précédent, modifier discrètement un commit ancien changerait toutes les empreintes suivantes — et ça se verrait immédiatement. L’historique Git n’est pas seulement un journal : c’est un journal vérifiable.

« C’est donc une sauvegarde ? » Non, et c’est important

C’est la confusion la plus fréquente, et la corriger tout de suite vous fera gagner beaucoup de temps.

Une sauvegarde est automatique et muette. Un commit est intentionnel et bavard. Votre sauvegarde de 2h du matin ne sait pas pourquoi le fichier a changé, parce que personne ne le lui a dit. Un commit porte votre explication, écrite au moment où vous aviez encore le contexte en tête.

Une sauvegarde restitue un état. Git restitue le chemin entre deux états. C’est probablement la différence la plus utile au quotidien. Votre sauvegarde peut vous rendre le fichier de lundi et celui de mercredi ; c’est à vous de comparer. Git vous dit directement : « entre lundi et mercredi, ces quatre lignes ont changé, voici lesquelles, et voici pourquoi ». Ce que vous cherchez pendant un incident, ce n’est presque jamais un fichier — c’est un changement.

Une sauvegarde protège contre la perte. Git protège contre l’oubli. Ce sont deux risques différents, et vous avez besoin des deux. Git ne remplacera jamais votre sauvegarde : si le serveur brûle avec tous les postes qui hébergeaient une copie, Git ne vous sauvera pas. Nous consacrerons d’ailleurs plusieurs leçons à sauvegarder la forge elle-même.

« Distribué » : ce que ça change pour vous

Vous lirez partout que Git est un système de gestion de versions distribué. Derrière le mot, une réalité très concrète : quand vous récupérez un projet, vous ne récupérez pas la dernière version — vous récupérez tout l’historique, en local, sur votre disque.

Trois conséquences pratiques, immédiatement utiles à un administrateur système :

Tout fonctionne hors connexion. Consulter l’historique, comparer deux versions, revenir six mois en arrière : aucune de ces opérations n’a besoin du serveur. Sur un site distant, en intervention, ou pendant que la forge redémarre, vous travaillez normalement. Seuls les échanges avec les collègues nécessitent le réseau.

Chaque copie est une copie complète. Si votre forge disparaît demain, n’importe quel poste ayant récupéré le projet peut le régénérer intégralement, historique compris. Ce n’est pas une stratégie de sauvegarde suffisante — mais c’est un filet de sécurité non négligeable.

C’est rapide. Toutes les consultations se font sur votre disque local. Comparer deux versions d’un fichier de configuration est instantané, même sur un historique de plusieurs milliers d’entrées.

Ce que Git n’est pas

Autant poser les limites tout de suite, elles vous éviteront des déconvenues.

Ce n’est pas un outil de synchronisation en temps réel. Rien à voir avec un Nextcloud ou un OneDrive. Vous décidez explicitement quand enregistrer et quand publier. Ce n’est pas un défaut : c’est ce qui rend l’historique lisible.

Ce n’est pas fait pour les gros fichiers binaires. Git excelle sur le texte — scripts, configurations, YAML, documentation. Une image disque de 4 Go ou un ISO n’ont rien à y faire, et gonfleront le dépôt définitivement. Nous verrons en section 5 comment gérer les exceptions.

Ce n’est absolument pas un coffre-fort. Un mot de passe écrit dans un fichier puis commité reste lisible dans l’historique, même après l’avoir supprimé du fichier. C’est un piège classique, et nous lui consacrerons plusieurs leçons. Retenez dès maintenant la règle : on ne met pas de secret dans un dépôt Git.

Ce n’est pas réservé aux développeurs. C’est le message de fond de cette formation, et vous en aurez la démonstration complète : un fichier texte modifié par plusieurs personnes au fil du temps est exactement ce que Git sait traiter. Que ce fichier soit du code applicatif, un script PowerShell, un nginx.conf ou l’export d’une stratégie de groupe ne fait aucune différence pour lui.

Ce qu’il faut retenir

  • Le versionnage par suffixes de fichiers que vous pratiquez déjà est une intuition juste, mise en œuvre avec un mauvais outil.
  • Git travaille sur trois zones : l’établi (vos fichiers), le plateau de montage (ce que vous avez choisi de consigner) et le registre (l’historique définitif).
  • Un commit est une entrée de journal : un instantané, un auteur, une date, un message et un lien vers le passé.
  • Git répond à « qui a changé quoi, quand et pourquoi », là où une sauvegarde ne répond qu’à « qu’y avait-il ».
  • Distribué signifie que tout l’historique est sur votre disque : consultation hors ligne, rapidité, et une copie de plus.
  • Git n’est ni une sauvegarde, ni un coffre-fort, ni un outil de synchronisation.

Gardez le schéma des trois zones en tête : nous allons le retrouver à chaque leçon des quatre prochaines sections.

Dans la leçon suivante

Vous savez maintenant ce que fait Git. Reste un malentendu à lever avant d’aller plus loin, et c’est probablement celui qui bloque le plus d’administrateurs système à l’entrée du sujet : la différence entre Git, GitHub et Forgejo. Trois choses très différentes, que tout le monde confond — y compris ceux qui les utilisent quotidiennement.