Quand j’ai commencé à enseigner le développement à mes étudiants BTS SIO SLAM, j’ai rapidement constaté que les commandes Git représentaient l’un des premiers obstacles techniques. Pourtant, maîtriser Git est devenu absolument incontournable dans le monde professionnel : selon le sondage Stack Overflow 2025, plus de 93 % des développeurs utilisent Git au quotidien. Que vous soyez étudiant en formation, en reconversion professionnelle ou développeur junior, ce guide vous accompagnera pas à pas dans l’apprentissage de cet outil essentiel.

Dans mon expérience de formatrice et ancienne administratrice réseau, je peux vous assurer que Git ne s’apprend pas en un jour, mais qu’avec une approche structurée et de la pratique régulière, n’importe qui peut devenir à l’aise avec le versionnement de code. J’ai rédigé ce guide en pensant à mes étudiants qui débutent, mais aussi aux professionnels qui souhaitent consolider leurs bases. Vous y trouverez toutes les commandes essentielles, des exemples concrets et des conseils issus de six années de pratique en entreprise.

Qu’est-ce que Git et pourquoi l’utiliser ?

Git est un système de contrôle de version distribué créé par Linus Torvalds en 2005. Contrairement aux anciens systèmes centralisés comme SVN, Git permet à chaque développeur de disposer d’une copie complète de l’historique du projet sur sa machine locale. C’est cette architecture distribuée qui rend Git si puissant et si populaire aujourd’hui.

Pourquoi Git est indispensable en 2026

Je recommande à mes étudiants de commencer à utiliser Git dès leur premier projet, même personnel. Voici les raisons principales :

• Traçabilité complète : chaque modification est enregistrée avec son auteur, sa date et un message descriptif.
• Collaboration fluide : plusieurs développeurs peuvent travailler simultanément sur le même projet sans se marcher dessus.
• Sécurité du code : en cas d’erreur, on peut revenir à n’importe quelle version antérieure en quelques secondes.
• Standard de l’industrie : GitHub, GitLab et Bitbucket hébergent des millions de projets. Savoir utiliser Git est requis dans 95 % des offres d’emploi développeur en France en 2026.

D’après les chiffres de l’APEC, un développeur junior maîtrisant Git et les workflows collaboratifs peut prétendre à un salaire d’entrée entre 28 000 € et 35 000 € brut annuel en province, et entre 33 000 € et 42 000 € en Île-de-France. La maîtrise de Git fait partie des compétences techniques évaluées lors des entretiens d’embauche.

Git dans le programme BTS SIO

Dans le référentiel du BTS SIO, la gestion de versions fait partie des compétences attendues, notamment pour l’épreuve E5 de production et fourniture de services. Que vous soyez en option SLAM ou SISR, vous serez amenés à utiliser Git dans vos projets. En SLAM, c’est évidemment central pour le développement applicatif ; en SISR, Git est de plus en plus utilisé pour versionner les configurations réseau et les scripts d’automatisation, par exemple avec Ansible.

Installation et configuration initiale de Git

Travailler avec les branches Git

Commandes Git avancées pour gagner en productivité

Les workflows Git pour travailler en équipe

Git dans votre parcours professionnel et vos études

Avant de plonger dans les commandes Git, il faut bien sûr installer et configurer l’outil. L’installation varie selon votre système d’exploitation, mais reste simple dans tous les cas.

Installer Git sur Windows, macOS et Linux

Si vous travaillez sous Linux, Git est souvent déjà préinstallé. Vérifiez avec la commande suivante :

git --version

En avril 2026, la version stable de Git est la 2.47.x. Je conseille à mes étudiants de toujours maintenir leur installation à jour pour bénéficier des dernières améliorations de performance et de sécurité.

Configuration initiale avec git config

Une fois Git installé, la première étape consiste à renseigner votre identité. Ces informations seront associées à chaque commit que vous réaliserez :

git config --global user.name "Votre Nom"
git config --global user.email "[email protected]"

Je recommande également de configurer l’éditeur de texte par défaut et le nom de la branche principale :

git config --global core.editor "code --wait"
git config --global init.defaultBranch main

Pour vérifier l’ensemble de votre configuration, utilisez :

git config --list

Configurer une clé SSH pour GitHub ou GitLab

Pour éviter de saisir votre mot de passe à chaque push, je conseille vivement de configurer une authentification par clé SSH. Voici la procédure :

ssh-keygen -t ed25519 -C "[email protected]"
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
cat ~/.ssh/id_ed25519.pub

Copiez ensuite la clé publique affichée et ajoutez-la dans les paramètres SSH de votre compte GitHub ou GitLab. Cette opération ne prend que deux minutes et vous fera gagner un temps considérable par la suite.

Les commandes Git de base : créer et gérer un dépôt

Commençons par les commandes Git fondamentales que tout développeur doit connaître. Ce sont celles que vous utiliserez quotidiennement, quel que soit votre niveau.

git init : initialiser un nouveau dépôt

La commande git init crée un nouveau dépôt Git dans le répertoire courant. Elle génère un dossier caché .git qui contiendra tout l’historique de votre projet :

mkdir mon-projet
cd mon-projet
git init

Résultat : Initialized empty Git repository in /home/user/mon-projet/.git/

git clone : copier un dépôt existant

Pour récupérer un projet déjà existant sur un serveur distant (GitHub, GitLab, Bitbucket), on utilise git clone :

git clone [email protected]:utilisateur/nom-du-projet.git
git clone https://github.com/utilisateur/nom-du-projet.git

Cette commande télécharge l’intégralité de l’historique du projet, pas uniquement la dernière version. C’est l’un des avantages majeurs de Git par rapport aux anciens systèmes.

git status : vérifier l’état du dépôt

C’est probablement la commande que j’utilise le plus dans une journée. git status affiche l’état actuel de votre répertoire de travail : fichiers modifiés, fichiers en attente de commit, fichiers non suivis :

git status

Je dis toujours à mes étudiants : « en cas de doute, faites un git status ». C’est le réflexe numéro un à acquérir.

git add : indexer les modifications

Avant de valider vos changements avec un commit, vous devez les placer dans la zone de staging (zone d’indexation) avec git add :

git add fichier.py              # ajouter un fichier spécifique
git add src/                     # ajouter tout un répertoire
git add .                        # ajouter toutes les modifications
git add -p                       # ajouter interactivement par blocs

git commit : enregistrer les modifications

Le commit est l’unité fondamentale de Git. Il crée un instantané permanent de vos modifications indexées :

git commit -m "Ajout de la fonction de connexion utilisateur"
git commit -am "Correction du bug d'affichage sur la page d'accueil"

Un bon message de commit est court, descriptif et rédigé à l’impératif. Dans mon expérience, les équipes qui adoptent des conventions de messages (comme Conventional Commits) gagnent énormément en lisibilité sur le long terme.

Les branches sont l’une des fonctionnalités les plus puissantes de Git. Elles permettent de développer des fonctionnalités en parallèle sans impacter le code principal. Dans mon parcours professionnel, je n’ai jamais travaillé sur un projet sérieux sans utiliser un système de branches.

git branch : créer et lister les branches

git branch                       # lister les branches locales
git branch -a                    # lister toutes les branches (locales et distantes)
git branch feature/login         # créer une nouvelle branche
git branch -d feature/login      # supprimer une branche fusionnée
git branch -D feature/login      # forcer la suppression d'une branche

git checkout et git switch : changer de branche

Historiquement, on utilisait git checkout pour naviguer entre les branches. Depuis Git 2.23, la commande git switch est recommandée car elle est plus explicite :

git switch main                  # basculer sur la branche main
git switch -c feature/panier     # créer et basculer sur une nouvelle branche
git checkout main                # ancienne syntaxe, toujours fonctionnelle

git merge : fusionner les branches

Une fois votre fonctionnalité terminée et testée, vous pouvez la fusionner dans la branche principale :

git switch main
git merge feature/panier

En cas de conflit de fusion, Git vous signale les fichiers concernés. Vous devez alors ouvrir ces fichiers, résoudre manuellement les conflits (marqués par des indicateurs spéciaux), puis finaliser la fusion :

git add fichier-resolu.py
git commit -m "Résolution du conflit de fusion sur fichier-resolu.py"

git rebase : réécrire l’historique

Le rebase est une alternative au merge qui permet d’obtenir un historique linéaire. Dans mon expérience, c’est une commande à manier avec précaution, surtout quand on débute :

git switch feature/panier
git rebase main

Règle d’or : ne faites jamais de rebase sur une branche partagée avec d’autres développeurs. Le rebase réécrit l’historique, ce qui peut créer des problèmes majeurs en équipe. Je recommande aux débutants de s’en tenir au merge jusqu’à ce qu’ils maîtrisent parfaitement le fonctionnement de Git.

Commandes Git pour travailler avec un dépôt distant

Dans un contexte professionnel, vous travaillerez presque toujours avec un dépôt distant hébergé sur GitHub, GitLab ou un serveur interne. Voici les commandes essentielles pour synchroniser votre travail local avec le serveur.

git remote : gérer les dépôts distants

git remote -v                                  # afficher les dépôts distants configurés
git remote add origin [email protected]:user/repo.git  # ajouter un dépôt distant
git remote rename origin upstream              # renommer un dépôt distant
git remote remove upstream                     # supprimer un dépôt distant

git push : envoyer les modifications

La commande git push envoie vos commits locaux vers le serveur distant :

git push origin main                           # pousser la branche main
git push -u origin feature/login               # pousser et configurer le tracking
git push origin --tags                         # pousser les tags

L’option -u (ou --set-upstream) est particulièrement utile : elle configure le lien entre votre branche locale et la branche distante. Après cette première utilisation, un simple git push suffira.

git pull et git fetch : récupérer les modifications

Il est essentiel de comprendre la différence entre ces deux commandes :

• git fetch : télécharge les modifications distantes sans les intégrer à votre branche locale. C’est une opération sûre qui vous permet d’inspecter les changements avant de les fusionner.
• git pull : équivaut à un git fetch suivi d’un git merge. C’est plus rapide mais peut provoquer des conflits inattendus.

git fetch origin                               # récupérer sans fusionner
git pull origin main                           # récupérer et fusionner
git pull --rebase origin main                  # récupérer et rebaser

Je conseille personnellement à mes étudiants d’utiliser git fetch suivi de git merge quand ils débutent, car cela offre plus de contrôle et de visibilité sur ce qui se passe.

Une fois les bases maîtrisées, ces commandes Git avancées vous feront gagner un temps considérable au quotidien. Ce sont celles que j’ai découvertes progressivement au fil de mes six années en entreprise.

git stash : mettre de côté des modifications temporaires

Vous êtes en plein développement d’une fonctionnalité quand on vous demande de corriger un bug urgent ? git stash est votre allié :

git stash                                      # mettre de côté les modifications
git stash list                                 # lister les stashs
git stash pop                                  # restaurer le dernier stash
git stash apply stash@{2}                      # appliquer un stash spécifique
git stash drop stash@{0}                       # supprimer un stash

git log : explorer l’historique

La commande git log est extrêmement polyvalente. Voici les variantes que j’utilise le plus :

git log --oneline                              # historique compact
git log --graph --oneline --all                # graphe visuel des branches
git log --author="Lucie"                       # filtrer par auteur
git log --since="2026-01-01"                   # filtrer par date
git log -p fichier.py                          # historique d'un fichier avec les diffs

git diff : comparer les modifications

git diff                                       # modifications non indexées
git diff --staged                              # modifications indexées (prêtes au commit)
git diff main..feature/login                   # différences entre deux branches
git diff HEAD~3                                # différences avec 3 commits en arrière

git reset : annuler des modifications

La commande git reset offre trois niveaux de « retour en arrière » :

git reset --soft HEAD~1                        # annule le dernier commit, garde les fichiers indexés
git reset --mixed HEAD~1                       # annule le commit et le staging (par défaut)
git reset --hard HEAD~1                        # annule tout, y compris les modifications de fichiers

git cherry-pick : récupérer un commit spécifique

git cherry-pick abc1234                        # appliquer un commit précis sur la branche courante

Cette commande est très utile quand vous devez récupérer un correctif d’une branche sans fusionner l’intégralité de celle-ci. C’est une situation fréquente dans les workflows de maintenance où l’on doit appliquer un hotfix à plusieurs branches de release.

git bisect : trouver un bug par dichotomie

git bisect start
git bisect bad                                 # le commit actuel est bugué
git bisect good v2.0                           # cette version fonctionnait
# Git vous fait naviguer automatiquement dans l'historique
git bisect reset                               # terminer la recherche

Je trouve cette commande brillante : elle utilise une recherche binaire pour identifier le commit exact qui a introduit un bug. Sur un projet avec des milliers de commits, elle peut vous faire économiser des heures de débogage.

Le fichier .gitignore et les bonnes pratiques

Le fichier .gitignore est un élément fondamental de tout projet Git. Il définit les fichiers et répertoires que Git doit ignorer. Dans mon expérience de formatrice, je constate que beaucoup de débutants négligent cette étape, ce qui entraîne des problèmes en production.

Exemple de fichier .gitignore pour un projet Python

# Environnements virtuels
venv/
env/
.env

# Cache Python
__pycache__/
*.pyc
*.pyo

# IDE
.vscode/
.idea/

# Fichiers systeme
.DS_Store
Thumbs.db

# Dépendances
node_modules/

# Fichiers de build
dist/
build/
*.egg-info/

Bonnes pratiques pour les messages de commit

Voici les conventions que j’impose dans mes formations et que j’applique moi-même en entreprise :

• Utiliser l’impératif : « Ajoute la validation du formulaire » plutôt que « Ajouté la validation ».
• Limiter la première ligne à 50 caractères pour la lisibilité dans les logs.
• Séparer le sujet du corps par une ligne vide si une description détaillée est nécessaire.
• Référencer les tickets : inclure le numéro de l’issue ou du ticket (ex. : « Corrige le bug #42 »).

La convention Conventional Commits est de plus en plus adoptée en entreprise. Elle structure les messages ainsi : feat: ajout du panier, fix: correction du calcul TVA, docs: mise à jour du README. Cette norme facilite la génération automatique de changelogs et le suivi sémantique des versions.

Protéger les données sensibles

Si vous avez accidentellement commité un fichier contenant des secrets (mot de passe, clé API), le simple fait de le supprimer dans un nouveau commit ne suffit pas : il reste dans l’historique. Vous devrez utiliser des outils comme git filter-branch ou l’outil BFG Repo-Cleaner pour purger l’historique. Mieux vaut prévenir que guérir : configurez votre .gitignore dès le début et utilisez des variables d’environnement pour les données sensibles. Pour approfondir la sécurité de vos projets, je vous recommande notre guide sur la cybersécurité.

Savoir utiliser les commandes Git individuellement ne suffit pas : il faut aussi comprendre comment les organiser dans un flux de travail cohérent. En entreprise, le choix du workflow Git a un impact direct sur la productivité et la qualité du code.

Git Flow

C’est le workflow le plus structuré. Il définit des branches dédiées pour chaque type d’activité :

• main : code en production, stable.
• develop : branche d’intégration pour les développements en cours.
• feature/* : branches de fonctionnalités, créées depuis develop.
• release/* : préparation d’une nouvelle version.
• hotfix/* : correctifs urgents en production.

Git Flow convient bien aux projets avec des cycles de release planifiés (logiciels installés, applications mobiles). En revanche, pour les applications web en déploiement continu, il peut paraître trop rigide.

GitHub Flow

Plus simple que Git Flow, ce workflow repose sur deux principes : la branche main est toujours déployable, et chaque fonctionnalité passe par une pull request avant d’être fusionnée. C’est le workflow que je recommande à mes étudiants pour leurs projets BTS SIO, car il est facile à comprendre et à mettre en pratique.

git switch -c feature/ma-fonctionnalite
# ... développement et commits ...
git push -u origin feature/ma-fonctionnalite
# Créer une pull request sur GitHub
# Après revue et validation, fusionner dans main

Trunk-Based Development

Ce workflow minimaliste favorise des branches très courtes (quelques heures maximum) et des intégrations fréquentes dans le tronc principal. C’est le modèle privilégié par les grandes entreprises pratiquant le DevOps intensif : Google, Facebook ou encore Netflix l’utilisent.

Outils et interfaces graphiques pour Git

Même si je suis convaincue que tout développeur doit maîtriser les commandes Git en ligne de commande, les interfaces graphiques peuvent accélérer certaines opérations et faciliter la visualisation de l’historique.

Les clients Git populaires en 2026

Pour mes étudiants qui utilisent VS Code, je recommande également l’extension GitLens qui enrichit considérablement l’expérience Git : historique en ligne, blame annoté, comparaison de branches, et bien plus encore.

Les plateformes d’hébergement

En 2026, trois plateformes dominent le marché de l’hébergement de dépôts Git :

• GitHub : leader incontesté avec plus de 100 millions de développeurs. Indispensable pour votre portfolio étudiant. Offre gratuite généreuse pour les étudiants via GitHub Education.
• GitLab : excellente alternative open source avec CI/CD intégré. Très utilisé en entreprise pour les dépôts privés.
• Bitbucket : bien intégré avec l’écosystème Atlassian (Jira, Confluence). Populaire dans les grandes entreprises.

La maîtrise de les commandes Git est un véritable accélérateur de carrière dans l’informatique. Que vous soyez en BTS SIO, en reconversion ou déjà en poste, voici comment Git s’inscrit dans votre parcours.

Git et le BTS SIO

Dans le cadre du BTS SIO, Git intervient principalement dans l’épreuve E5 et dans les projets personnels que vous présenterez lors de l’oral. Les jurys apprécient particulièrement les candidats capables de montrer un historique Git propre, des branches bien organisées et des messages de commit pertinents. C’est un signal fort de professionnalisme.

Si vous êtes en alternance, vous utiliserez Git quotidiennement en entreprise. C’est l’un des premiers outils qu’on vous demandera de maîtriser. Je recommande de commencer à pratiquer avant même votre entrée en entreprise, sur des projets personnels ou des contributions open source.

Git en entretien d’embauche

Lors des entretiens pour un poste de développeur junior, on vous posera très probablement des questions sur Git. Voici les sujets les plus fréquents :

• La différence entre merge et rebase.
• Comment résoudre un conflit de fusion.
• L’explication du workflow utilisé dans vos projets.
• La différence entre fetch et pull.
• Comment annuler un commit (avec reset ou revert).

D’après les données de Talent.io et Welcome to the Jungle, un développeur junior en France qui maîtrise Git, un framework web et les bases de SQL peut espérer un salaire de départ entre 30 000 € et 38 000 € brut annuel en 2026. La compétence Git seule ne fait pas le salaire, mais son absence est rédhibitoire.

Ressources pour approfondir

Pour aller plus loin, voici les ressources que je recommande régulièrement :

• La documentation officielle Git : exhaustive et bien structurée.
• Pro Git (livre gratuit en ligne) : la référence pour comprendre Git en profondeur.
• Learn Git Branching (learngitbranching.js.org) : un outil interactif excellent pour visualiser les opérations de branches.
• Oh My Git! : un jeu vidéo pour apprendre Git de manière ludique.

N’hésitez pas à compléter votre apprentissage avec notre article sur Python pour les débutants, un langage parfait pour pratiquer Git dans des projets concrets. Et pour mettre en place un environnement de pratique complet, pensez à configurer un homelab étudiant ou un serveur Linux maison où vous pourrez héberger votre propre instance GitLab.

Conclusion

La maîtrise de les commandes Git est un investissement qui rapporte tout au long de votre carrière en informatique. Que vous soyez étudiant en BTS SIO, en reconversion professionnelle ou développeur en poste, Git est l’outil que vous utiliserez le plus au quotidien. Mon conseil principal : ne restez pas dans la théorie. Créez un compte GitHub dès aujourd’hui, initialisez votre premier dépôt, et pratiquez chaque commande présentée dans ce guide. C’est en forgeant qu’on devient forgeron, et c’est en committant qu’on devient développeur. Si vous souhaitez aller plus loin dans votre parcours, explorez nos guides sur la formation informatique gratuite et les débouchés du BTS SIO.

Lucie Moreau

Formatrice IT indépendante depuis 2016, ancienne étudiante BTS SIO SLAM. 6 ans d'expérience en entreprise.