Aller au contenu
Module 1 sur 6, environ 1 h 30

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 :

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.

À retenir

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é .git qui 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 :

Une image pour s'en souvenir

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.

  1. Le répertoire de travail (working directory) : tes fichiers, tels que tu les vois et les modifies.
  2. L'index, ou zone de préparation (staging area) : la liste des modifications que tu as choisi de mettre dans le prochain commit.
  3. 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 :

ÉtatSignificationPour 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
Le réflexe à prendre

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"
Attention à git add .

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 :

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 :

.gitignore
# 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.

Un secret poussé est un secret compromis

.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.

  1. 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 --list
    Ré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
  2. Créer le dépôt

    $ mkdir -p ~/ateliers/carnet
    $ cd ~/ateliers/carnet
    $ git init
    $ ls -a
    Résultat attendu

    Git répond Initialized empty Git repository in …/carnet/.git/, et ls -a montre le dossier caché .git. C'est lui, le dépôt.

  3. Créer un fichier et observer son état

    $ echo "# Carnet de recettes" > README.md
    $ git status

    Lis 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 propose git add <file>... pour l'inclure dans ce qui sera validé.

  4. Indexer puis valider

    $ git add README.md
    $ git status
    $ git commit -m "Crée le carnet de recettes"
    $ git status
    Résultat attendu

    Après git add, le fichier passe sous Changes to be committed. Après le commit, git status annonce nothing to commit, working tree clean : les trois zones sont alignées.

  5. 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 diff

    git diff montre la ligne ajoutée à README.md, précédée d'un +. Remarque qu'il ne dit rien de idees.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"
  6. Lire l'historique

    $ git log
    $ git log --oneline
    $ git show HEAD

    git log détaille chaque commit (empreinte, auteur, date, message). --oneline en donne une version compacte. git show HEAD affiche le contenu du dernier commit : HEAD dé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
  7. 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.md

    Refais 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 status
    Résultat attendu

    Après git restore README.md, le fichier a retrouvé son titre et la recette des crêpes. À la fin, README.md apparaît sous Changes not staged for commit : modifié, mais plus indexé.

  8. Ignorer un fichier

    $ echo "mot-de-passe=1234" > secrets.env
    $ git status
    $ echo "*.env" > .gitignore
    $ git status

    Après la création de .gitignore, secrets.env a disparu de la liste, et .gitignore y 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 --oneline
    Pour 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, puis git add README.md et un second.

Valider le module

Huit questions. Il en faut six justes pour valider.