R5.04 — Autoformation Git
Support d'autoformation (BUT Réseaux & Télécommunications, IUT d'Aix-Marseille, module R5.04) : installer et configurer Git, dépôt/commit/aire d'indexation, branches et fusion, puis travail avec un dépôt distant — avec points de contrôle et quiz auto-corrigés à chaque étape.
Chargement du visualisateur PDF…
Texte extrait du document (pour la recherche)
[Page 1]
R5.04 — Cycle de vie d'un projet informatique Autoformation
AUTOFORMATION — À FAIRE EN AUTONOMIE
Git, des premiers pas au travail à plusieurs
Ce document est à faire seul, à votre rythme, avant le TP1 — qui suppose tout ce qui suit acquis.
Modalité Prérequis À faire pour Évaluation
Individuel, en autonomie Un OS avec Git installé Le TP1 Points de contrôle et quiz auto-
corrigés
Comment utiliser ce document
• Tapez les commandes. Ne les copiez pas : la mémoire des mains compte autant que celle de la tête.
• Chaque partie se termine par un point de contrôle et un quiz. Ne passez à la suivante que si les cases
sont cochées.
• Les réponses aux quiz sont en annexe. Cherchez d'abord, vérifiez ensuite.
• Les quatre parties s'enchaînent sur le même dépôt : ne le supprimez pas entre deux séances.
Ce que vous saurez faire à la fin
Créer un dépôt, suivre l'état de vos fichiers, enregistrer votre travail par commits successifs, revenir en
arrière, travailler sur plusieurs branches, fusionner et résoudre un conflit, et synchroniser votre travail avec
un dépôt distant sur la forge etulab.
Attention
Le TP1 démarre directement sur le travail collaboratif. Aucune des commandes de ce document n'y sera
réexpliquée.
Sommaire
Comment utiliser ce document ......................................................................................................................... 1
Sommaire....................................................................................................................................................... 1
Partie 1 — Installer et configurer Git ................................................................................................................ 3
1.1 — Ce qu'est Git ........................................................................................................................................ 3
1.2 — Installation .......................................................................................................................................... 3
1.3 — Se présenter à Git................................................................................................................................ 3
1.4 — Votre première commande................................................................................................................. 4
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 1 sur 20
[Page 2]
R5.04 — Cycle de vie d'un projet informatique Autoformation
Partie 2 — Dépôt, commit et aire d'indexation ................................................................................................ 6
2.1 — Créer un dépôt .................................................................................................................................... 6
2.2 — Les trois états d'un fichier ................................................................................................................... 6
2.3 — Premier fichier, premier commit ........................................................................................................ 6
2.4 — Modifier un fichier déjà validé ............................................................................................................ 7
2.5 — Désindexer .......................................................................................................................................... 7
2.6 — Le pointeur HEAD ................................................................................................................................ 8
2.7 — Lire l'historique ................................................................................................................................... 8
2.8 — Ignorer des fichiers.............................................................................................................................. 9
2.9 — Marquer une version : les étiquettes.................................................................................................. 9
Partie 3 — Branches et fusion ......................................................................................................................... 11
3.1 — À quoi sert une branche .................................................................................................................... 11
3.2 — Créer et changer de branche ............................................................................................................ 11
3.3 — Travailler sur une branche ................................................................................................................ 11
3.4 — Visualiser ........................................................................................................................................... 11
3.5 — Fusionner .......................................................................................................................................... 12
3.6 — Comparer .......................................................................................................................................... 12
3.7 — Résoudre un conflit ........................................................................................................................... 13
Partie 4 — Travailler avec un dépôt distant .................................................................................................... 15
4.1 — Le principe ......................................................................................................................................... 15
4.2 — Préparer une clé SSH ......................................................................................................................... 15
4.3 — Créer le projet distant et le relier ..................................................................................................... 15
4.4 — Pousser son travail ............................................................................................................................ 16
4.5 — Cloner ................................................................................................................................................ 16
4.6 — Récupérer le travail des autres ......................................................................................................... 16
4.7 — Une session de travail type ............................................................................................................... 17
Annexe A — Mémento .................................................................................................................................... 18
Se repérer .................................................................................................................................................... 18
Enregistrer ................................................................................................................................................... 18
Revenir en arrière ........................................................................................................................................ 18
Branches et distant ...................................................................................................................................... 18
Annexe B — Quand ça coince.......................................................................................................................... 19
Annexe C — Réponses aux quiz ....................................................................................................................... 19
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 2 sur 20
[Page 3]
R5.04 — Cycle de vie d'un projet informatique Autoformation
Partie 1 — Installer et configurer Git
1.1 — Ce qu'est Git
Git est un gestionnaire de version distribué.
Gestionnaire de version : il conserve l'histoire complète des modifications d'un ensemble de fichiers, et
permet de revenir à n'importe quel état antérieur.
Distribué : chaque copie du projet contient l'intégralité de cette histoire, pas seulement la dernière version.
Cette seconde propriété a deux conséquences pratiques immédiates : vous pouvez travailler sans réseau, et
la disparition du serveur ne fait perdre l'historique à personne.
1.2 — Installation
Sous Debian ou Ubuntu (ou WSL) :
sudo apt update
sudo apt install git
Sous Windows :
Installez Git for Windows depuis https://git-scm.com/install/windows — il fournit « Git Bash », un terminal
qui se comporte comme celui de Linux.
Sous macOS :
brew install git
Vérifiez que la commande soit fonctionnelle en exécutant :
git --version
1.3 — Se présenter à Git
Chaque commit porte le nom et l'adresse de son auteur. Ces informations sont inscrites dans l'historique et
ne peuvent plus être modifiées ensuite sans réécrire toute l'histoire. Configurez-les correctement, une fois
pour toutes :
git config --global user.name "Prénom Nom"
git config --global user.email "prenom.nom@etu.univ-amu.fr"
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 3 sur 20
[Page 4]
R5.04 — Cycle de vie d'un projet informatique Autoformation
Réglez aussi l'éditeur qui s'ouvrira pour saisir vos messages de commit, et le nom de la branche créée par
défaut :
git config --global core.editor "nano" # ou vim, micro, code --wait…
git config --global init.defaultBranch main
Relisez votre configuration :
git config --list --global
main ou master ?
Historiquement, Git nommait « master » la branche créée à l'initialisation. La convention actuelle est «
main », et c'est celle qu'emploie ce document. Si vous voyez « master » quelque part, c'est que la
configuration ci-dessus n'a pas été appliquée — ce n'est pas grave, mais les copies d'écran ne
correspondront pas tout à fait.
1.4 — Votre première commande
Tapez git sans argument : Git affiche la liste de ses commandes les plus courantes. Cette liste est courte, et
vous finirez par toutes les connaître.
git
L'aide de chaque commande est accessible de trois façons équivalentes :
git help commit
git commit --help
man git-commit
Astuce
La page d'aide de Git est longue mais elle est la référence. Prenez l'habitude d'y aller : c'est plus rapide
qu'une recherche en ligne, et toujours à jour pour la version installée.
Point de contrôle — je sais faire
☐ Git est installé et je sais afficher sa version.
☐ Mon nom et mon adresse sont configurés globalement.
☐ Je sais ouvrir l'aide d'une commande Git.
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 4 sur 20
[Page 5]
R5.04 — Cycle de vie d'un projet informatique Autoformation
Quiz — réponses en annexe
1. Que signifie le mot « distribué » dans « gestionnaire de version distribué » ?
2. Pourquoi l'adresse de courriel configurée dans Git a-t-elle de l'importance ?
3. Quelle commande affiche toute votre configuration globale ?
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 5 sur 20
[Page 6]
R5.04 — Cycle de vie d'un projet informatique Autoformation
Partie 2 — Dépôt, commit et aire d'indexation
2.1 — Créer un dépôt
mkdir mon-projet
cd mon-projet
git init
Git répond « Dépôt Git vide initialisé dans … ». Il vient de créer un répertoire .git à la racine de votre projet.
ls -la
ls .git
Le répertoire .git
C'est le dépôt lui-même : l'historique, les branches, la configuration locale, les objets. Tout le reste du
répertoire est votre copie de travail. Supprimer .git ne supprime aucun de vos fichiers actuels, mais efface
toute leur histoire — irrémédiablement.
2.2 — Les trois états d'un fichier
C'est la notion centrale de Git, et la seule qui demande un vrai effort de compréhension. Un fichier suivi par
Git se trouve toujours dans l'un de ces trois états.
État Où se trouve le contenu Comment y arriver
Modifié Dans votre répertoire de travail, pas encore Vous éditez le fichier
signalé à Git
Indexé Dans l'aire d'indexation : prêt à entrer dans le git add <fichier>
prochain commit
Validé Dans le dépôt : enregistré dans l'historique, git commit
définitif
L'aire d'indexation (staging area, ou index) est ce qui distingue Git de la plupart des autres outils. Elle vous
permet de choisir précisément ce qui entrera dans le prochain commit, sans être obligé d'y mettre tout ce
que vous avez modifié depuis le dernier.
Astuce
Une bonne pratique : un commit = une idée. Si vous avez corrigé un bug et renommé trois variables au
passage, faites deux commits. L'aire d'indexation est là pour cela.
2.3 — Premier fichier, premier commit
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 6 sur 20
[Page 7]
R5.04 — Cycle de vie d'un projet informatique Autoformation
echo "Git, premier essai." > MonFichier.txt
git status
Git signale MonFichier.txt comme « non suivi » : il existe dans votre répertoire mais Git ne s'en occupe
pas encore. Indexez-le :
git add MonFichier.txt
git status
Le fichier apparaît maintenant dans les « modifications qui seront validées ». Validez :
git commit -m "Ajoute le premier fichier du projet"
Le message de commit
Il se lit sans ouvrir le diff. Écrivez-le à l'impératif, en moins de 72 caractères, sans point final : « Ajoute le
premier fichier du projet », pas « ajout de fichier » ni « modifs ».
2.4 — Modifier un fichier déjà validé
echo "Je ne pensais pas que c'était aussi simple." >> MonFichier.txt
git status
Git le signale comme modifié mais non indexé. Essayez de valider directement :
git commit
Git refuse : « aucune modification ajoutée à la validation ». C'est la démonstration concrète de l'aire
d'indexation — git commit ne valide que ce qui a été indexé.
git add MonFichier.txt
git commit -m "Complète le fichier d'essai"
Si vous omettez l'option -m, Git ouvre votre éditeur. Les lignes commençant par « # » sont des
commentaires : elles ne seront pas enregistrées. Un message vide annule le commit.
Question
Vous avez modifié deux fichiers, mais un seul est prêt. Quelles commandes tapez-vous pour ne valider que
celui-là ?
2.5 — Désindexer
Vous avez indexé un fichier par erreur. Pour le retirer de l'aire d'indexation sans perdre vos modifications :
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 7 sur 20
[Page 8]
R5.04 — Cycle de vie d'un projet informatique Autoformation
echo "brouillon" > Brouillon.txt
git add Brouillon.txt
git status
git restore --staged Brouillon.txt
git status
Le fichier redevient « non suivi », et son contenu est intact. Sur les versions anciennes de Git, la commande
équivalente était git reset HEAD <fichier> — vous la rencontrerez encore dans beaucoup de tutoriels.
Et pour annuler une modification non indexée, en revenant au dernier état validé :
git restore MonFichier.txt
Attention
Cette commande est destructive : les modifications non validées sont perdues, et Git ne peut pas les
retrouver. Elle est la seule de ce document dans ce cas.
2.6 — Le pointeur HEAD
HEAD désigne le commit sur lequel vous vous trouvez — celui dont votre répertoire de travail reflète le
contenu. Il se déplace automatiquement à chaque commit, et vous pouvez le déplacer vous-même pour
aller voir le passé.
git log --oneline # relever un identifiant de commit
git switch --detach <identifiant>
cat MonFichier.txt # le fichier tel qu'il était à ce moment-là
git switch - # revenir d'où l'on vient
« HEAD détachée »
Git vous prévient que HEAD n'est plus attachée à une branche. C'est normal et sans danger tant que vous
ne validez rien dans cet état. Revenez sur votre branche et tout rentre dans l'ordre.
2.7 — Lire l'historique
git log
git log --oneline
git log --stat # avec les fichiers touchés
git log -p # avec le contenu des modifications
git show <identifiant> # un commit en détail
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 8 sur 20
[Page 9]
R5.04 — Cycle de vie d'un projet informatique Autoformation
Chaque commit est identifié par une empreinte de 40 caractères. En pratique on n'en utilise que les 7
premiers, qui suffisent à le désigner sans ambiguïté.
2.8 — Ignorer des fichiers
Certains fichiers n'ont rien à faire dans un dépôt : produits de compilation, environnements virtuels, fichiers
temporaires de l'éditeur, et surtout tout ce qui contient un secret.
cat > .gitignore <<'FIN'
# environnements
.venv/
__pycache__/
# éditeurs
*.swp
.vscode/
# secrets
.env
FIN
git add .gitignore
git commit -m "Ajoute les règles d'exclusion du dépôt"
Attention
Le fichier .gitignore est lui-même versionné : c'est voulu, toute l'équipe doit partager les mêmes exclusions.
En revanche, .gitignore n'a aucun effet sur un fichier déjà suivi. Un secret validé une fois reste dans
l'historique pour toujours : la seule réponse correcte est de le révoquer.
2.9 — Marquer une version : les étiquettes
Une étiquette (tag) donne un nom lisible à un commit précis — typiquement une version publiée.
git tag -a v0.1.0 -m "Première version utilisable"
git tag
git show v0.1.0
L'option -a crée une étiquette annotée : elle porte un auteur, une date et un message, et c'est la seule
forme à utiliser pour une version publiée.
Point de contrôle — je sais faire
☐ Je sais créer un dépôt et reconnaître le rôle du répertoire .git.
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 9 sur 20
[Page 10]
R5.04 — Cycle de vie d'un projet informatique Autoformation
☐ Je sais expliquer la différence entre modifié, indexé et validé.
☐ Je sais n'indexer qu'une partie de mon travail avant un commit.
☐ Je sais désindexer un fichier et annuler une modification.
☐ Je sais lire l'historique et afficher un commit précis.
☐ Je sais écrire un .gitignore et poser une étiquette annotée.
Quiz — réponses en annexe
4. Vous tapez git commit sans avoir fait git add. Que se passe-t-il, et pourquoi ?
5. Quelle est la différence entre git restore <fichier> et git restore --staged <fichier> ?
6. Vous avez validé par erreur un fichier contenant un mot de passe, puis vous l'avez supprimé au commit
suivant. Le mot de passe est-il en sécurité ?
7. À quoi sert l'option -a de git tag ?
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 10 sur 20
[Page 11]
R5.04 — Cycle de vie d'un projet informatique Autoformation
Partie 3 — Branches et fusion
3.1 — À quoi sert une branche
Une branche est une ligne de développement indépendante. Elle permet de travailler sur une
fonctionnalité sans perturber ce qui fonctionne, et de mener plusieurs travaux en parallèle.
Techniquement, une branche n'est qu'un pointeur mobile sur un commit. C'est pour cela que créer une
branche dans Git est instantané, quelle que soit la taille du projet — là où d'autres outils dupliquaient des
répertoires entiers.
3.2 — Créer et changer de branche
git branch # lister les branches, * marque la courante
git branch nouveau-travail # créer, sans s'y déplacer
git switch nouveau-travail # s'y déplacer
git switch -c autre-travail # créer ET s'y déplacer, en une commande
switch ou checkout ?
git checkout fait les deux choses — changer de branche et restaurer des fichiers — ce qui le rend ambigu et
dangereux. Git l'a scindé en git switch (branches) et git restore (fichiers). Utilisez ces deux-là ; vous
croiserez checkout dans les documentations plus anciennes.
3.3 — Travailler sur une branche
git switch -c nouveau-travail
echo "Fichier créé sur la branche nouveau-travail." > Travail.txt
git add Travail.txt
git commit -m "Ajoute le fichier de travail"
git switch main
ls # Travail.txt a disparu
git switch nouveau-travail
ls # il est revenu
Ce va-et-vient est la démonstration la plus parlante de ce qu'est une branche : votre répertoire de travail
est reconstitué à l'identique de l'état de la branche où vous vous trouvez.
3.4 — Visualiser
git log --graph --decorate --oneline --all
Cette commande est longue à taper et vous l'utiliserez souvent. Donnez-lui un raccourci :
git config --global alias.arbre \
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 11 sur 20
[Page 12]
R5.04 — Cycle de vie d'un projet informatique Autoformation
'log --graph --decorate --oneline --all'
git arbre
Astuce
Deux outils graphiques sont livrés avec Git et rendent la structure bien plus lisible :
gitk --all (visualisation de l'historique)
git gui (préparation des commits)
3.5 — Fusionner
Le cas simple : l'avance rapide
Si la branche d'arrivée n'a pas bougé depuis la création de la branche de travail, Git se contente d'avancer
le pointeur. C'est ce qu'il appelle fast-forward : aucun commit de fusion n'est créé.
git switch main
git merge nouveau-travail
git arbre
Le cas général : le commit de fusion
Si les deux branches ont divergé, Git crée un commit particulier, qui a deux parents.
git switch main
echo "Ligne ajoutée sur main." > SurMain.txt
git add SurMain.txt && git commit -m "Ajoute un fichier sur main"
git switch nouveau-travail
echo "Ligne ajoutée sur la branche." >> Travail.txt
git add Travail.txt && git commit -m "Complète le fichier de travail"
git switch main
git merge nouveau-travail
git arbre
Fusionner ne supprime pas la branche
Après un merge, la branche fusionnée existe toujours et peut continuer à vivre. Si son travail est terminé,
supprimez-la explicitement : git branch -d nouveau-travail. Git refusera si elle contient du travail non
fusionné.
3.6 — Comparer
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 12 sur 20
[Page 13]
R5.04 — Cycle de vie d'un projet informatique Autoformation
git diff # travail non indexé
git diff --staged # ce qui est indexé
git diff main..nouveau-travail # entre deux branches
git log main..nouveau-travail # les commits d'une branche absents de l'autre
L'ordre compte : git diff A..B montre ce qu'il faudrait appliquer à A pour obtenir B. Inversez les deux et
le signe des lignes s'inverse.
3.7 — Résoudre un conflit
Un conflit survient quand les deux branches ont modifié les mêmes lignes du même fichier. Git ne peut pas
trancher : il vous passe la main. Provoquons-en un volontairement.
git switch nouveau-travail
echo "Version de la branche de travail." > MonFichier.txt
git add MonFichier.txt && git commit -m "Réécrit le fichier sur la branche"
git switch main
echo "Version de la branche principale." > MonFichier.txt
git add MonFichier.txt && git commit -m "Réécrit le fichier sur main"
git merge nouveau-travail
Git annonce le conflit et s'arrête. Ouvrez le fichier : il contient des marqueurs.
<<<<<<< HEAD
Version de la branche principale.
=======
Version de la branche de travail.
>>>>>>> nouveau-travail
Entre <<<<<<< et ======= : le contenu de la branche où vous êtes. Entre ======= et >>>>>>> : celui de la
branche que vous fusionnez. À vous d'écrire la version définitive, puis de supprimer les trois marqueurs.
nano MonFichier.txt # écrire la bonne version, retirer les marqueurs
git add MonFichier.txt # signaler le conflit comme résolu
git status
git commit # Git propose déjà un message de fusion
Astuce
Deux filets de sécurité :
git merge --abort annule la fusion et revient à l'état d'avant
git status liste à tout moment les fichiers restant à résoudre
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 13 sur 20
[Page 14]
R5.04 — Cycle de vie d'un projet informatique Autoformation
Le conflit modification / suppression
Cas plus déroutant : une branche modifie un fichier, l'autre le supprime. Git ne peut évidemment pas
fusionner les deux intentions et vous demande de choisir.
git switch nouveau-travail
git rm Travail.txt && git commit -m "Supprime le fichier de travail"
git switch main
echo "modification" >> Travail.txt
git add Travail.txt && git commit -m "Modifie le fichier de travail"
git merge nouveau-travail
# choisir l'une des deux intentions :
git rm Travail.txt # entériner la suppression
# ou
git add Travail.txt # conserver le fichier modifié
git commit
Point de contrôle — je sais faire
☐ Je sais créer une branche, m'y déplacer et la supprimer.
☐ Je sais expliquer ce qu'est une branche en une phrase.
☐ Je sais visualiser l'historique sous forme de graphe.
☐ Je sais distinguer une fusion en avance rapide d'une fusion avec commit de fusion.
☐ Je sais provoquer, lire et résoudre un conflit de contenu.
☐ Je sais annuler une fusion en cours.
Quiz — réponses en annexe
8. Pourquoi la création d'une branche est-elle instantanée, même sur un projet de plusieurs milliers de
fichiers ?
9. Dans quel cas Git effectue-t-il une fusion en avance rapide plutôt que de créer un commit de fusion ?
10. Que représentent exactement les lignes situées entre <<<<<<< et ======= dans un fichier en conflit ?
11. Que fait git add sur un fichier en conflit ?
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 14 sur 20
[Page 15]
R5.04 — Cycle de vie d'un projet informatique Autoformation
Partie 4 — Travailler avec un dépôt distant
4.1 — Le principe
Jusqu'ici votre dépôt vit sur votre machine. Un dépôt distant est une copie hébergée ailleurs, avec laquelle
vous synchronisez le vôtre. C'est ce qui permet de travailler à plusieurs, et accessoirement de ne pas tout
perdre en cas de panne de disque.
Nous utiliserons etulab.univ-amu.fr, la forge GitLab de l'université, sur laquelle vous avez un compte avec
vos identifiants habituels.
4.2 — Préparer une clé SSH
Créez (ou réutilisez si vous en avez) une paire de clés :
ssh-keygen -t ed25519 -C "prenom.nom@etu.univ-amu.fr"
# accepter le chemin proposé, et choisir une phrase de passe
Attention
La phrase de passe protège votre clé privée si votre machine est compromise. Ne la laissez pas vide.
Le fichier ~/.ssh/id_ed25519 (sans .pub) est votre clé privée : elle ne quitte jamais votre machine et ne doit
jamais être versionnée.
Affichez la clé publique et copiez-la intégralement :
cat ~/.ssh/id_ed25519.pub
Sur etulab, ouvrez votre profil, section « SSH Keys », collez la clé et enregistrez. Vérifiez :
ssh -T git@etulab.univ-amu.fr
La réponse attendue commence par « Welcome to GitLab ». Si vous voyez une demande de mot de passe,
la clé n'a pas été prise en compte.
4.3 — Créer le projet distant et le relier
Sur etulab (https://etulab.univ-amu.fr), créez un projet privé nommé « mon-projet », sans README ni
.gitignore — vous avez déjà tout cela en local. Puis, dans votre dépôt :
git remote add origin git@etulab.univ-amu.fr:votre-login/mon-projet.git
git remote -v
git push -u origin --all
git push origin --tags
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 15 sur 20
[Page 16]
R5.04 — Cycle de vie d'un projet informatique Autoformation
origin, -u, --all
« origin » est le nom conventionnel du dépôt distant principal — ce n'est qu'un nom, vous pourriez
l'appeler autrement. L'option -u établit le lien entre votre branche locale et son équivalent distant, ce qui
permet ensuite de taper git push tout court. --all pousse toutes vos branches ; les étiquettes, elles, ne
suivent pas automatiquement et demandent --tags.
4.4 — Pousser son travail
echo "Nouvelle ligne." >> MonFichier.txt
git add MonFichier.txt
git commit -m "Complète le fichier principal"
git status # « votre branche est en avance de 1 commit »
git push
git status # « votre branche est à jour »
Entre les deux, rien n'a changé dans vos fichiers : seul l'état de synchronisation avec origin/main a évolué.
4.5 — Cloner
Pour récupérer un projet existant — celui d'un binôme, ou le vôtre depuis une autre machine :
cd ~
git clone git@etulab.univ-amu.fr:votre-login/mon-projet.git copie-projet
cd copie-projet
git remote -v
git log --oneline
Le clone contient l'intégralité de l'historique, et « origin » est déjà configuré. C'est ce que signifie « distribué
» : cette copie est un dépôt complet, pas un simple téléchargement.
4.6 — Récupérer le travail des autres
Commande Ce qu'elle fait Quand l'utiliser
git fetch Récupère les nouveautés du distant sans toucher Pour voir ce qui a changé avant de
à votre travail décider
git pull Fait un fetch puis fusionne dans votre branche Quand votre travail est propre et
courante validé
git push Envoie vos commits validés vers le distant Après chaque unité de travail
terminée
Attention
git pull fusionne. Si votre répertoire de travail contient des modifications non validées, la fusion peut
échouer ou produire un conflit au mauvais moment.
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 16 sur 20
[Page 17]
R5.04 — Cycle de vie d'un projet informatique Autoformation
La règle : on valide ou on met de côté (git stash) avant de tirer.
4.7 — Une session de travail type
Voici l'enchaînement que vous répéterez au TP1, puis pendant toute la SAÉ.
git switch main
git pull # partir de l'état le plus récent
git switch -c feature/12-ma-tache
# … travail …
git add -p # relire et indexer morceau par morceau
git commit -m "Décrit ce que fait ce commit"
git push -u origin feature/12-ma-tache
# puis ouvrir une merge request sur etulab
Astuce
git add -p présente vos modifications une par une et demande, pour chacune, si elle doit entrer dans le
commit. C'est le meilleur moyen de relire son propre travail avant de le valider — et d'éviter d'y laisser un
mot de passe ou une ligne de débogage.
Point de contrôle — je sais faire
☐ J’ai une clé SSH et elle est enregistrée sur etulab.
☐ Je sais relier un dépôt local à un dépôt distant.
☐ Je sais pousser mes commits et mes étiquettes.
☐ Je sais cloner un dépôt existant.
☐ Je sais expliquer la différence entre fetch et pull.
☐ Je sais dérouler une session de travail complète, de git pull à la merge request.
Quiz — réponses en annexe
12. Quelle partie de votre paire de clés déposez-vous sur etulab, et pourquoi jamais l'autre ?
13. Vous avez poussé une étiquette avec git push. Apparaît-elle sur etulab ? Pourquoi ?
14. Quelle est la différence concrète entre git fetch et git pull ?
15. Pourquoi commencer une session de travail par git pull sur main plutôt que directement sur sa branche
?
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 17 sur 20
[Page 18]
R5.04 — Cycle de vie d'un projet informatique Autoformation
Annexe A — Mémento
Se repérer
Commande Effet
git status Où j'en suis : branche, fichiers modifiés, indexés, en conflit
git log --oneline L'historique, un commit par ligne
git arbre L'historique sous forme de graphe (alias à créer)
git diff Ce que j'ai modifié et pas encore indexé
git show <id> Le détail d'un commit
Enregistrer
Commande Effet
git add <fichier> Indexer un fichier
git add -p Indexer morceau par morceau, en relisant
git commit -m "…" Valider ce qui est indexé
git commit --amend Corriger le dernier commit (jamais après un push)
git tag -a v1.0.0 -m "…" Poser une étiquette annotée
Revenir en arrière
Commande Effet
git restore <fichier> Annuler les modifications non indexées (destructif)
git restore --staged <fichier> Désindexer sans rien perdre
git revert <id> Créer un commit qui annule un commit passé (sans réécrire l'histoire)
git stash / git stash pop Mettre son travail de côté, puis le reprendre
git merge --abort Annuler une fusion en cours
Branches et distant
Commande Effet
git switch -c <branche> Créer une branche et s'y placer
git switch <branche> Changer de branche
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 18 sur 20
[Page 19]
R5.04 — Cycle de vie d'un projet informatique Autoformation
Commande Effet
git branch -d <branche> Supprimer une branche fusionnée
git merge <branche> Fusionner une branche dans la branche courante
git fetch Récupérer sans fusionner
git pull Récupérer et fusionner
git push -u origin <branche> Publier une branche et la relier au distant
Annexe B — Quand ça coince
Symptôme Ce qui se passe Quoi faire
« aucune modification Vous avez modifié sans indexer git add puis git commit
ajoutée à la validation »
« HEAD détachée » Vous êtes sur un commit, pas sur git switch - pour revenir
une branche
« Vous avez des chemins non Une fusion est en conflit Résoudre, git add, git commit — ou git
fusionnés » merge --abort
push refusé, « non-fast- Le distant a avancé depuis votre git pull, résoudre s'il le faut, puis git push
forward » dernier pull
« Permission denied La clé SSH n'est pas reconnue Vérifier ssh -T git@etulab.univ-amu.fr et
(publickey) » la clé déposée
J'ai fait une bêtise et je ne Tout commit validé reste git reflog liste tous les déplacements de
sais plus où j'en suis retrouvable HEAD
Le filet de sécurité de Git
Tant qu'un travail a été validé par un commit, il est retrouvable — même après une manipulation
hasardeuse. git reflog conserve la trace de tous les déplacements de HEAD, y compris ceux que git log ne
montre plus. Ce qui n'a jamais été validé, en revanche, n'existe pas pour Git.
Annexe C — Réponses aux quiz
# Réponse
1 Chaque copie du projet contient l'intégralité de l'historique, et pas seulement la dernière version. Il n'y a
donc pas de serveur indispensable, et chaque clone est une sauvegarde complète.
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 19 sur 20
[Page 20]
R5.04 — Cycle de vie d'un projet informatique Autoformation
# Réponse
2 Elle est inscrite dans chaque commit et sert à vous identifier comme auteur. Elle ne peut plus être corrigée
ensuite sans réécrire l'historique.
3 git config --list --global
4 Git refuse, car git commit ne valide que le contenu de l'aire d'indexation. Une modification non indexée
n'existe pas encore pour le commit.
5 git restore <fichier> annule vos modifications et revient au dernier état validé — c'est destructif. git restore
--staged <fichier> retire seulement le fichier de l'aire d'indexation, sans toucher à son contenu.
6 Non. Le commit qui le contenait reste dans l'historique, et cet historique a été dupliqué chez tous ceux qui
ont cloné. La seule réponse correcte est de révoquer le mot de passe.
7 Elle crée une étiquette annotée, qui porte un auteur, une date et un message. C'est la seule forme à
employer pour une version publiée.
8 Parce qu'une branche n'est qu'un pointeur sur un commit : la créer revient à écrire un identifiant dans un
fichier. Rien n'est copié.
9 Quand la branche d'arrivée n'a reçu aucun commit depuis la création de la branche fusionnée : il suffit alors
d'avancer le pointeur, aucune fusion réelle n'est nécessaire.
10 Le contenu de la branche sur laquelle vous vous trouvez, c'est-à-dire celle où la fusion est faite (HEAD).
11 Il signale à Git que le conflit sur ce fichier est résolu. Le contenu indexé devient la version retenue pour le
commit de fusion.
12 La clé publique (id_ed25519.pub). La clé privée ne quitte jamais votre machine : c'est elle qui prouve votre
identité, la publier reviendrait à publier votre mot de passe.
13 Non, sauf si vous avez utilisé git push --tags ou git push origin <étiquette>. Les étiquettes ne suivent pas les
branches automatiquement.
14 git fetch récupère les nouveautés du distant sans modifier votre branche de travail. git pull fait la même
chose puis fusionne immédiatement dans la branche courante.
15 Pour partir de l'état de référence le plus récent avant de créer votre branche. Une branche créée sur un
main périmé divergera davantage et produira plus de conflits à la fusion.
BUT Réseaux & Télécommunications — IUT d'Aix-Marseille Page 20 sur 20
📝 Tester ses connaissances
1. D'après la Partie 1, qu'est-ce qui distingue précisément un gestionnaire de version « distribué » de la simple notion de gestionnaire de version ?
2. Dans la Partie 2, que se passe-t-il exactement quand on tape `git commit` sans avoir fait `git add` sur un fichier modifié ?
3. Selon la Partie 3, pourquoi la création d'une branche est-elle instantanée, même sur un projet de plusieurs milliers de fichiers ?
4. D'après la Partie 4, quelle partie de la paire de clés SSH doit être déposée sur la forge (ex: GitLab), et laquelle ne doit jamais quitter la machine ?