Apprendre Git : formation complète du débutant à l'avancé

Git est l’outil de versioning de référence pour suivre l’évolution d’un projet, collaborer en équipe et sécuriser ses changements dans le temps. Que vous écriviez du code, des playbooks Ansible, des manifests Kubernetes ou des pipelines CI/CD, Git vous permet de savoir qui a changé quoi, quand, et pourquoi.

Cette page est votre point d’entrée pour apprendre Git pas à pas, du premier commit aux workflows avancés utilisés dans les équipes DevOps.

Git en une minute

Si vous découvrez Git, voici l’essentiel avant de taper la première commande :

• Git est un système de contrôle de version distribué : il enregistre l’historique complet de votre projet sous forme de commits (des instantanés datés et signés).
• Vous pouvez créer des branches pour travailler sur une fonctionnalité sans toucher au reste du projet.
• Vous pouvez fusionner votre travail, comparer les versions et revenir en arrière à tout moment sur n’importe quel commit enregistré.
• Git fonctionne entièrement en local sur votre machine, puis se synchronise avec un serveur distant si vous le souhaitez.

Git ≠ GitHub / GitLab

Git est un outil de versioning qui s’installe sur votre machine. GitHub, GitLab, Forgejo et Gitea sont des plateformes web qui hébergent des dépôts Git et ajoutent des fonctionnalités de collaboration (pull requests, issues, CI/CD intégrée).

Vous pouvez utiliser Git sans GitHub. Vous ne pouvez pas utiliser GitHub sans Git.

Pourquoi apprendre Git ?

Un professionnel DevOps écrit du code tous les jours : scripts d’automatisation, fichiers d’infrastructure as code, pipelines CI/CD, configurations. Tout ce code doit être versionné, partagé et traçable.

Git ne sert pas seulement à « sauvegarder du code ». Il sert à travailler proprement, relire les changements avant de les valider, tester des idées en branche, collaborer sans écraser le travail des autres et revenir rapidement à un état stable après une erreur. Sans Git, les équipes jonglent avec des noms de fichiers (v1, v2-final, v2-final-VRAIMENT-final), n’ont aucune trace de qui a changé quoi, et ne peuvent pas revenir en arrière proprement.

Avec Git, plusieurs personnes peuvent travailler en parallèle sur le même projet. Quand leurs modifications se croisent, Git aide à les fusionner et à traiter explicitement les conflits — ils ne disparaissent pas, mais ils sont gérés avec des outils dédiés.

Git est distribué

Contrairement aux systèmes centralisés (SVN, CVS), Git donne à chaque développeur une copie complète de l’historique sur sa machine. Vous pouvez travailler hors ligne, consulter l’historique, créer des branches et faire des commits sans connexion réseau.

Commencer maintenant

Voici les cinq commandes du cycle de base. Elles suffisent pour comprendre le rythme quotidien avec Git :

git init                          # Initialiser un dépôt dans le dossier courant
git status                        # Voir l'état des fichiers
git add .                         # Ajouter tous les fichiers modifiés au staging
git commit -m "feat: premier commit"  # Enregistrer un instantané
git log --oneline                 # Consulter l'historique

Le parcours débutant les explique pas à pas avec les concepts qui les sous-tendent.

Installer et configurer Git Préparez votre poste : installation, identité, éditeur et alias.

Le modèle Git : snapshots et 3 états Comprenez comment Git pense avant de taper la première commande. La clé pour ne jamais être perdu.

Choisissez votre parcours

Trois parcours sont disponibles selon votre niveau. Chaque guide est autonome, mais ils se complètent dans l’ordre proposé.

Parcours	Pour qui	Ce que vous saurez faire
Débutant	Première découverte de Git	Créer un dépôt, versionner du code, consulter l’historique
Intermédiaire	Vous utilisez déjà add/commit	Travailler en branche, fusionner, collaborer en équipe
Avancé	Vous pratiquez Git au quotidien	Réécrire l’historique, déboguer, automatiser, comprendre les internals

Glissez pour voir

Vous débutez complètement ? Commencez par Le modèle Git, puis enchaînez avec Installer et configurer Git.

Vous utilisez déjà add, commit et push ? Sautez directement au parcours intermédiaire.

Comment naviguer dans cette formation

Cette page est le point d’entrée global de la formation Git. Elle oriente vers les pages de section (Comprendre Git, Les bases…), qui elles-mêmes orientent vers les guides unitaires (un seul sujet par guide). Pour apprendre pas à pas, suivez les parcours dans l’ordre. Chaque guide peut aussi être consulté indépendamment via la recherche ou la sidebar.

Parcours débutant (Modules 1-2)

Commencez ici si vous n’avez jamais utilisé Git ou si vous voulez consolider vos bases. Ces guides couvrent tout ce dont vous avez besoin pour utiliser Git au quotidien en solo.

1. Comprendre le modèle Git : avant de taper des commandes, comprenez comment Git pense (snapshots, 3 états, SHA). C’est la clé pour ne jamais être perdu.

2. Installer et configurer : préparez votre poste avec Git configuré correctement (identité, éditeur, alias).

3. Créer un dépôt, enregistrer des modifications, consulter l’historique : le cycle de travail quotidien.

4. Annuler des erreurs : corrigez vos modifications sans panique.

Le modèle Git : snapshots et 3 états Comprenez comment Git stocke vos données et pourquoi il est si rapide et fiable.

Installer et configurer Git Installation sur Linux, macOS et Windows. Configuration de l'identité, de l'éditeur et des alias.

Créer un dépôt Git git init et git clone : créez ou récupérez un projet versionné.

Enregistrer des modifications Le cycle add, commit : maîtrisez le staging, les diffs et le .gitignore.

Consulter l'historique git log sous toutes ses formes : filtrer, chercher, formater l'historique.

Annuler des modifications restore, commit --amend, revert : les différentes façons de corriger ses erreurs.

Parcours intermédiaire (Modules 3-4)

Vous maîtrisez add, commit et log ? Passez aux branches et au travail en équipe. C’est ici que Git révèle toute sa puissance.

1. Créer et naviguer entre les branches : travaillez sur plusieurs fonctionnalités en parallèle sans risque.

2. Fusionner et résoudre les conflits : intégrez vos branches en confiance.

3. Synchroniser avec un serveur distant : push, pull, fetch pour collaborer avec votre équipe.

4. Adopter un workflow : choisissez la méthode adaptée à votre organisation.

Les branches Git en bref Créer, lister, supprimer des branches. Comprendre HEAD et le concept de pointeur.

Merge et résolution de conflits Fast-forward, 3-way merge, marqueurs de conflit : fusionnez en confiance.

Travailler avec les remotes fetch, pull, push : synchronisez votre travail avec le serveur distant.

Workflows Git Feature Branch, Gitflow, Trunk-Based : choisissez le workflow adapté à votre équipe.

Parcours avancé (Modules 5-10)

Vous utilisez Git au quotidien et souhaitez aller plus loin ? Le parcours avancé se divise en trois dimensions complémentaires.

Maîtriser l’historique (technique avancée)

Les outils de manipulation (rebase interactif, reset, staging partiel, stash) transforment vos habitudes de commit. Vous produisez un historique propre et lisible qui facilite les revues de code et la recherche de régressions.

Rebase fondamental Principe du rebase, rebase interactif, règle d'or : quand et comment réécrire.

Réécrire l'historique amend, rebase -i (squash, fixup, reword) et filter-repo pour supprimer un fichier sensible.

Reset démystifié Les 3 arbres de Git, --soft/--mixed/--hard : comprenez enfin ce que reset fait vraiment.

Cherry-pick Appliquer un commit d'une autre branche : mécanisme, conflits, options clés.

Outils Git avancés Stash, staging interactif, bisect, submodules, bundling : les commandes puissantes.

Collaboration avancée et plateformes

Ce sous-parcours couvre ce que vous devez maîtriser pour travailler sur des projets partagés, open source ou d’entreprise.

Pull requests et code review Créer une PR structurée, conduire une revue constructive, gérer le cycle de vie.

Workflows distribués Workflow centralisé, integration manager, dictateur : collaborer à grande échelle.

Plateformes Git GitHub, GitLab, Gitea, Forgejo : comparer SaaS et self-hosted selon vos contraintes.

GitLab : la plateforme DevSecOps CI/CD intégrée, issues, sécurité, registry : bien plus qu'un simple hébergeur.

Dépannage, maintenance et projets complexes

Opérations Git : résoudre les problèmes du quotidien Push rejeté, commit mal placé, données perdues : 7 guides de survie par symptôme.

Récupérer des données perdues Reflog, fsck, ORIG_HEAD : retrouvez vos commits, branches et travail perdus.

Maintenir un projet Accepter des contributions, préparer une release, gérer le changelog.

Je veux…

Vous ne savez pas par quel guide commencer ? Choisissez selon votre besoin immédiat :

Je veux…	Par où commencer
Démarrer Git depuis zéro	Installer et configurer Git
Comprendre comment Git fonctionne	Le modèle Git
Travailler avec des branches	Les branches en bref
Corriger une erreur	Annuler des modifications ou Récupérer des données perdues
Comprendre rebase	Rebase fondamental
Choisir GitHub ou GitLab	Plateformes Git
Contribuer à un projet open source	Pull requests et code review
Intégrer Git dans mes pratiques DevOps	Workflows Git

Glissez pour voir

Les erreurs fréquentes des débutants

Ces erreurs sont commises par presque tout le monde au début. Les connaître à l’avance vous fera gagner beaucoup de temps.

Erreur	Ce qu’il faut faire à la place
Confondre Git et GitHub	Git est l’outil local, GitHub est la plateforme en ligne — ils sont distincts
Faire git add . sans vérifier	Toujours lancer git status avant d’ajouter quoi que ce soit
Committer des secrets	Configurer .gitignore et utiliser des gestionnaires de secrets
Travailler directement sur main	Créer une branche pour chaque fonctionnalité ou correctif
Utiliser push --force sur une branche partagée	Comprendre les conséquences avant de réécrire l’historique distant
Oublier git status	En faire un réflexe : lancer avant et après chaque opération
Messages de commit vagues (update, fix)	Expliquer l’intention : fix: correct null pointer in login handler

Glissez pour voir

Git dans l’écosystème DevOps

Git n’est pas qu’un outil de développeur. En DevOps, il est au centre de tout :

• Infrastructure as Code : vos fichiers Terraform, Ansible, Kubernetes sont versionnés dans Git (provisionnement, gestion de configuration)
• Pipelines CI/CD : chaque push déclenche un pipeline (GitLab CI, GitHub Actions)
• GitOps : le dépôt Git devient la source de vérité unique pour vos déploiements (en savoir plus)
• Sécurité : ne jamais committer de secrets (secrets dans le code)

Cinq bonnes pratiques Git en DevOps

1. Un commit = une intention : chaque commit doit être petit, cohérent et compréhensible sans contexte supplémentaire.
2. Soignez vos messages de commit : un bon message explique le pourquoi, pas le quoi (fix: correct null pointer in auth est utile, update file ne l’est pas).
3. Jamais de secrets dans Git : mots de passe, clés API et tokens n’ont rien à faire dans l’historique, même dans un dépôt privé.
4. Protégez votre branche principale : activez les protections de branche sur votre plateforme pour forcer les revues de code avant merge.
5. Automatisez les contrôles : lint, tests et analyse de sécurité dans votre CI pour valider chaque push.

Ne commitez jamais de secrets

Un secret committé dans Git est exposé dans l’historique même si vous le supprimez ensuite. N’importe qui ayant accès au dépôt peut le retrouver. Configurez un .gitignore strict et consultez le guide secrets dans le code Git.

Ressources complémentaires

Livres gratuits

• Pro Git : le livre officiel, complet et gratuit
• Git Magic : approche progressive
• Apprenez Git : format PDF

Vidéos

• xavki : playlist Git (35 vidéos)

Exercices interactifs

• Learn Git Branching : visualisez les branches en temps réel
• Oh My Git! : apprenez Git en jouant

À retenir

• Git trace chaque modification : chaque commit enregistré dans l’historique peut être inspecté et, dans la grande majorité des cas, retrouvé — y compris après une suppression accidentelle via le reflog.
• Git est distribué : chaque développeur possède une copie complète de l’historique, ce qui permet de travailler hors ligne.
• Git pense en snapshots : chaque commit est une photo complète de votre projet, pas une liste de différences.
• Les 3 états : vos fichiers passent par Working Directory → Staging Area → Repository. Comprendre ce modèle évite la majorité des confusions.
• Les branches sont légères : une branche est juste un pointeur vers un commit, pas une copie du projet. Créez-en autant que nécessaire, elles ne coûtent presque rien.
• Git ≠ GitHub : Git est l’outil de versioning, les plateformes (GitHub, GitLab, Forgejo) sont les services qui l’hébergent.
• Jamais de secrets dans Git : ni dans les fichiers, ni dans les messages de commit, ni dans aucune branche.

×

📖 Voir la documentation →