Git : les fondamentaux
Avant de parler de branches ou de pipelines, il faut comprendre ce que Git enregistre, où il le range, et le petit cycle de commandes qu'un développeur répète des dizaines de fois par jour.
À la fin de ce module, tu sauras :
- expliquer ce qu'est un commit et pourquoi on versionne ;
- situer une modification dans les trois zones de Git ;
- créer un dépôt, enregistrer des commits propres et lire l'historique ;
- ignorer les fichiers qui n'ont rien à faire dans un dépôt.
Pourquoi versionner
Tout le monde a déjà versionné sans outil. Ça ressemble à ceci :
rapport.odt
rapport-v2.odt
rapport-v2-corrige.odt
rapport-final.odt
rapport-final-VRAIMENT-final.odt
La méthode fonctionne tant qu'on est seul, sur un seul fichier, et qu'on a bonne mémoire. Elle s'effondre dès qu'un projet compte des centaines de fichiers modifiés par plusieurs personnes. Laquelle de ces copies est en production ? Qui a changé cette ligne, et pourquoi ? Comment revenir à l'état de mardi sans perdre le travail de mercredi ?
Un logiciel de gestion de versions répond à ces questions. Il enregistre une suite d'instantanés du projet, chacun accompagné de son auteur, de sa date et d'un message qui explique le changement. On obtient :
- un filet de sécurité : tout état enregistré peut être retrouvé, comparé, restauré ;
- une mémoire : l'historique dit qui a fait quoi, quand et pour quelle raison ;
- le travail en parallèle : plusieurs personnes avancent en même temps sans s'écraser, grâce aux branches (module 2) ;
- un point d'ancrage pour l'automatisation : tout ce que tu verras dans les modules 4 à 6 se déclenche à partir d'un événement Git.
Git sert d'abord à versionner du code, mais il convient à tout ce qui s'écrit en texte : documentation, configuration de serveurs, description d'infrastructure, site web.
Centralisé ou distribué
Les outils historiques (CVS, puis Subversion) sont centralisés : un serveur détient l'historique, et chaque poste n'a qu'une copie de la version en cours. Sans réseau, on ne peut presque rien faire.
Git, créé en 2005 par Linus Torvalds pour le développement du noyau Linux, est distribué : chaque copie du projet contient tout l'historique. Tu peux enregistrer, comparer, créer des branches dans un train sans connexion, puis synchroniser plus tard avec les autres.
Avec Git, ton dépôt local est complet et autonome. Un serveur comme GitLab n'est « central » que par convention : c'est le dépôt que l'équipe a choisi comme référence commune.
Dépôt, commit, historique
Trois mots reviennent sans cesse. Autant les fixer tout de suite.
- Dépôt (repository)
- Un dossier de projet suivi par Git. Concrètement, c'est ton dossier habituel, plus un sous-dossier caché
.gitqui contient tout l'historique. Supprimer.git, c'est perdre l'historique et garder seulement les fichiers actuels. - Commit
- Un instantané de l'ensemble du projet à un moment donné, avec un auteur, une date, un message et un lien vers le commit précédent (son parent).
- Historique
- La chaîne formée par les commits, chacun pointant vers son parent. On la remonte du plus récent au plus ancien.
Chaque commit est identifié par une empreinte de 40 caractères hexadécimaux, calculée à partir de son contenu, par exemple 9fceb02d0ae598e95dc970b74767f19372d61af8. Deux conséquences pratiques :
- on désigne en général un commit par les 7 ou 8 premiers caractères de son empreinte (
9fceb02), ce qui suffit à le distinguer ; - modifier quoi que ce soit dans un commit (son contenu, son message, son parent) change son empreinte : c'est un autre commit. Cette propriété garantit l'intégrité de l'historique, et elle expliquera au module 2 pourquoi le rebase « réécrit » l'histoire.
Pense à une partie de jeu vidéo avec des points de sauvegarde. Chaque commit est une sauvegarde nommée (« Avant le boss », « Clé trouvée »). Tu peux toujours recharger une sauvegarde, et personne ne t'oblige à sauvegarder à chaque pas : tu choisis les moments qui ont du sens.
Les trois zones
C'est le point qui déroute le plus quand on débute, et celui qui rend tout le reste limpide une fois compris. Entre ton éditeur de texte et l'historique, Git intercale une étape intermédiaire.
- Le répertoire de travail (working directory) : tes fichiers, tels que tu les vois et les modifies.
- L'index, ou zone de préparation (staging area) : la liste des modifications que tu as choisi de mettre dans le prochain commit.
- Le dépôt local : l'historique des commits, rangé dans
.git.
S'y ajoute, quand on travaille à plusieurs, le dépôt distant, hébergé sur un serveur. On y reviendra au module 3.
Pourquoi cet index, plutôt que d'enregistrer directement tout ce qui a changé ? Parce qu'un bon commit raconte une chose. Si tu as corrigé une faute de frappe et commencé une nouvelle page dans la même heure, l'index te permet de faire deux commits distincts, chacun avec un message clair, au lieu d'un fourre-tout.
Les états d'un fichier
Du point de vue de Git, un fichier est toujours dans l'un de ces états :
| État | Signification | Pour avancer |
|---|---|---|
| Non suivi (untracked) | Le fichier existe sur le disque mais Git ne l'a jamais enregistré. | git add |
| Modifié (modified) | Fichier connu de Git, dont le contenu diffère du dernier commit. | git add |
| Indexé (staged) | La modification est prête à partir dans le prochain commit. | git commit |
| À jour (unmodified) | Identique à la version du dernier commit. | Rien à faire |
git status ne modifie jamais rien et répond toujours à la question « où en suis-je ? ». Mieux : il indique entre parenthèses la commande à taper pour chaque situation. En cas de doute, git status.
Le cycle quotidien
Se présenter à Git, une fois pour toutes
Chaque commit porte un nom et une adresse. Il faut les déclarer avant le premier commit :
$ git config --global user.name "Camille Martin"
$ git config --global user.email "camille@exemple.fr"
$ git config --global init.defaultBranch main
L'option --global enregistre le réglage pour tous tes dépôts, dans le fichier ~/.gitconfig. La troisième ligne demande que la branche créée par défaut s'appelle main, la convention actuelle (tu croiseras encore master dans d'anciens projets, c'est la même chose sous un autre nom).
Créer ou récupérer un dépôt
$ git init # transforme le dossier courant en dépôt
$ git clone <adresse> # copie un dépôt existant, historique compris
Observer
$ git status # l'état des trois zones
$ git diff # ce qui a changé et n'est pas encore indexé
$ git diff --staged # ce qui est indexé, donc ce qui partira au prochain commit
$ git log --oneline # l'historique, une ligne par commit
Enregistrer
$ git add index.html # indexe un fichier précis
$ git add . # indexe tout ce qui a changé dans le dossier courant
$ git commit -m "Ajoute le formulaire de contact"
C'est pratique, et c'est aussi le meilleur moyen d'embarquer par mégarde un fichier de mots de passe ou 300 Mo de fichiers temporaires. Regarde toujours git status avant de valider, et lis la section sur .gitignore ci-dessous.
Revenir en arrière
$ git restore --staged index.html # retire le fichier de l'index, garde la modification
$ git restore index.html # abandonne la modification : retour au dernier commit
La première commande est sans danger. La seconde détruit un travail qui n'a jamais été enregistré : Git ne pourra pas te le rendre.
Écrire un bon message de commit
Le message est destiné à la personne qui lira l'historique dans six mois, et cette personne sera souvent toi. Quelques usages largement partagés :
- une première ligne courte (moins de 70 caractères) qui résume le changement, à l'impératif ou au présent : « Corrige le calcul de la TVA », « Ajoute la page À propos » ;
- si nécessaire, une ligne vide puis quelques phrases sur le pourquoi. Le quoi est déjà dans le diff ;
- un commit par intention. « Corrections diverses » n'aide personne.
Ignorer des fichiers
Certains fichiers n'ont pas leur place dans un dépôt : fichiers générés (binaires compilés, dossiers node_modules ou target), fichiers temporaires de l'éditeur, et surtout secrets (mots de passe, clés, fichiers .env). On les liste dans un fichier .gitignore à la racine du dépôt, un motif par ligne :
# Journaux et fichiers temporaires
*.log
*.tmp
# Dossiers générés
build/
node_modules/
# Secrets : jamais dans Git
.env
Le fichier .gitignore lui-même se versionne : toute l'équipe en profite.
.gitignore n'agit que sur les fichiers non suivis. Si un mot de passe a déjà été enregistré dans un commit, l'ajouter ensuite à .gitignore ne l'efface pas de l'historique. La seule réponse sûre est de changer le mot de passe.
Atelier 1 : ton premier dépôt
Créer un dépôt et enregistrer ses premiers commits
Environ 30 minutes. Tout se passe en local, aucun serveur n'est nécessaire.
Il te faut un terminal avec Git. Dans l'environnement de formation, . Ailleurs, vérifie avec git --version.
-
Te présenter à Git
Remplace par ton nom et ton adresse. Ces informations apparaîtront dans chacun de tes commits.
$ git config --global user.name "Ton Nom" $ git config --global user.email "toi@exemple.fr" $ git config --global init.defaultBranch main $ git config --global --listRésultat attendu
La dernière commande affiche tes réglages, dont les trois lignes que tu viens de définir :
user.name=Ton Nom user.email=toi@exemple.fr init.defaultbranch=main -
Créer le dépôt
$ mkdir -p ~/ateliers/carnet $ cd ~/ateliers/carnet $ git init $ ls -aRésultat attendu
Git répond
Initialized empty Git repository in …/carnet/.git/, etls -amontre le dossier caché.git. C'est lui, le dépôt. -
Créer un fichier et observer son état
$ echo "# Carnet de recettes" > README.md $ git statusLis attentivement la réponse. Dans quelle rubrique apparaît
README.md? Quelle commande Git te suggère-t-il ?Résultat attendu
Le fichier figure sous
Untracked files: il est non suivi. Git proposegit add <file>...pour l'inclure dans ce qui sera validé. -
Indexer puis valider
$ git add README.md $ git status $ git commit -m "Crée le carnet de recettes" $ git statusRésultat attendu
Après
git add, le fichier passe sousChanges to be committed. Après le commit,git statusannoncenothing to commit, working tree clean: les trois zones sont alignées. -
Faire deux modifications, mais deux commits
Ajoute une recette et, dans la foulée, un fichier d'idées. Ce sont deux intentions différentes : on veut deux commits.
$ echo "## Crêpes : 250 g de farine, 4 œufs, 50 cl de lait" >> README.md $ echo "Tester la recette du far breton" > idees.txt $ git status $ git diffgit diffmontre la ligne ajoutée àREADME.md, précédée d'un+. Remarque qu'il ne dit rien deidees.txt: un fichier non suivi n'a pas de version précédente à laquelle le comparer.$ git add README.md $ git commit -m "Ajoute la recette des crêpes" $ git add idees.txt $ git commit -m "Ajoute une liste d'idées à tester" -
Lire l'historique
$ git log $ git log --oneline $ git show HEADgit logdétaille chaque commit (empreinte, auteur, date, message).--onelineen donne une version compacte.git show HEADaffiche le contenu du dernier commit :HEADdésigne « là où tu te trouves », on y revient au module 2.Résultat attendu
Trois lignes pour
git log --oneline, la plus récente en haut. Tes empreintes seront différentes :3e1f9a2 Ajoute une liste d'idées à tester b47c0d1 Ajoute la recette des crêpes 9a02f6e Crée le carnet de recettes -
Se tromper, puis annuler
Abîme volontairement le fichier, constate, puis reviens au dernier commit.
$ echo "oups" > README.md $ git diff $ git restore README.md $ cat README.mdRefais ensuite une modification, indexe-la, puis retire-la de l'index sans la perdre :
$ echo "## Gaufres : à compléter" >> README.md $ git add README.md $ git restore --staged README.md $ git statusRésultat attendu
Après
git restore README.md, le fichier a retrouvé son titre et la recette des crêpes. À la fin,README.mdapparaît sousChanges not staged for commit: modifié, mais plus indexé. -
Ignorer un fichier
$ echo "mot-de-passe=1234" > secrets.env $ git status $ echo "*.env" > .gitignore $ git statusAprès la création de
.gitignore,secrets.enva disparu de la liste, et.gitignorey est apparu. Termine en validant proprement :$ git add .gitignore README.md $ git commit -m "Ignore les fichiers .env et amorce la recette des gaufres" $ git log --onelinePour aller un peu plus loin
Ce dernier commit mélange deux intentions. Comment aurais-tu pu faire deux commits ? Réponse :
git add .gitignore, un premier commit, puisgit add README.mdet un second.
Valider le module
Huit questions. Il en faut six justes pour valider.