Dépôt dans Git : ce que c’est, quels types existent et comment ils fonctionnent

Qu’est-ce qu’un dépôt dans Git

Dépôt Git — est une structure de données dans laquelle le système de contrôle de version stocke les métadonnées et les objets décrivant l’historique des modifications des fichiers du projet. Lorsqu’un développeur initialise un dépôt avec la commande git init, Git crée un dossier caché .git à la racine du projet.

À l’intérieur de ce dossier se trouvent tous les objets, références et fichiers de configuration nécessaires au fonctionnement du système. Le dépôt n’est pas lié à un emplacement spécifique — le développeur peut le créer localement puis le lier à un serveur distant.

Git utilise un modèle de dépôt distribué : chaque membre du projet possède une copie complète de l’historique sur son ordinateur. Cela signifie que la plupart des opérations — commit, visualisation de l’historique, création de branches — sont effectuées localement sans contacter le serveur.

Selon la documentation de Git, l’architecture distribuée rend le système tolérant aux pannes : si le serveur tombe en panne, n’importe quel dépôt local peut servir de source pour restaurer l’historique complet du projet.

Dépôt local et distant

Dépôt local — est une copie du projet sur l’ordinateur du développeur. Il contient tout l’historique des commits, branches et tags et permet d’effectuer les opérations commit, branch, merge et rebase sans connexion réseau.

Dépôt distant — est hébergé sur un serveur et sert de point de synchronisation pour tous les membres de l’équipe. Les développeurs envoient leurs modifications avec la commande git push et récupèrent celles des autres avec git pull.

La connexion entre le dépôt local et le dépôt distant est configurée via remote origin — l’URL du serveur stockée dans la configuration Git. Un dépôt local peut être lié à plusieurs dépôts distants, ce qui est utile lors du travail avec des forks.

Le principal avantage de ce modèle est que le développeur peut travailler sur le code hors ligne et synchroniser les modifications uniquement lorsqu’il est prêt à envoyer le résultat.

Différences entre le dépôt local et le dépôt distant

Comment Git stocke les données dans un dépôt

Le modèle de stockage de Git est fondamentalement différent des autres systèmes de contrôle de version. Au lieu de stocker une liste de modifications (delta) entre les versions, Git conserve des instantanés complets de tous les fichiers du projet au moment de chaque commit.

Chaque objet dans le dépôt est identifié par un hash SHA-1 unique de 40 caractères. Si le contenu d’un fichier n’a pas changé entre les commits, Git ne crée pas un nouvel objet mais réutilise l’existant — cela économise de l’espace.

Git utilise quatre types d’objets : blob (contenu du fichier), tree (structure du répertoire), commit (instantané avec métadonnées) et tag (référence nommée vers un commit). Tous les objets sont stockés dans le dossier .git/objects.

Selon Git Internals, le modèle d’objets de Git garantit l’intégrité des données : toute modification du contenu d’un fichier génère un nouveau hash, rendant impossible la modification de l’historique sans être détecté.

Structure du dossier .git

Le dossier .git est le cœur du dépôt. Sans lui, Git ne peut pas suivre les modifications, et un répertoire ordinaire reste simplement un ensemble de fichiers. Comprendre la structure de ce dossier aide à diagnostiquer les problèmes de dépôt.

• objects/ — tous les objets du dépôt : blobs, trees, commits, tags. Stockés sous forme compressée.
• refs/ — références vers des commits : heads (branches), tags (étiquettes), remotes (branches distantes).
• HEAD — fichier pointant vers la branche active ou le commit actuel.
• config — paramètres du dépôt : URL distante, nom d’utilisateur, email et autres paramètres.
• index — zone de staging où Git stocke les informations sur les fichiers préparés pour le commit.
• logs/ — journaux de mise à jour des références (reflog) qui stockent l’historique des déplacements de HEAD et des branches.

Le fichier HEAD mérite une attention particulière. Dans un état normal, il contient une référence symbolique vers une branche, par exemple ref: refs/heads/main. Dans un état detached HEAD, il pointe directement vers un commit — cela signifie que les nouveaux commits ne seront liés à aucune branche.

Opérations de base avec le dépôt

Travailler avec un dépôt Git implique un ensemble d’opérations de base que le développeur effectue quotidiennement. Chaque opération modifie l’état du dépôt en ajoutant de nouveaux objets ou en déplaçant des références.

• git init — crée un nouveau dépôt vide dans le répertoire courant. Git crée le dossier .git avec la structure initiale.
• git clone — copie un dépôt distant existant sur la machine locale avec tout l’historique des commits.
• git add — ajoute les modifications de fichiers à la zone de staging (index), les préparant pour le commit.
• git commit — crée un instantané du projet basé sur les données de l’index et le sauvegarde comme un nouvel objet commit.
• git push — envoie les nouveaux commits du dépôt local vers le dépôt distant, mettant à jour les branches sur le serveur.
• git pull — récupère les nouveaux commits du dépôt distant et les fusionne avec la branche locale actuelle.

Les opérations push et pull sont les seules qui nécessitent une connexion au serveur distant. Toutes les autres opérations sont effectuées entièrement localement, garantissant une vitesse élevée même avec un volume d’historique important.

Cycle de vie d’un fichier dans le dépôt

Chaque fichier dans le dépôt passe par quatre états : untracked (non suivi), modified (modifié), staged (préparé) et committed (validé). Git ne suit que les fichiers qui ont été explicitement ajoutés via git add ou qui sont déjà dans l’historique des commits.

Comprendre ce modèle est la clé pour travailler efficacement avec Git. Le développeur peut préparer sélectivement seulement une partie des fichiers modifiés pour le commit, créant des commits logiquement complets avec une description claire.

Plateformes populaires pour héberger des dépôts

Les dépôts distants sont généralement hébergés sur des plateformes spécialisées qui fournissent une interface web, un système de contrôle d’accès et des outils supplémentaires pour le développement collaboratif.

• GitHub — la plus grande plateforme avec plus de 100 millions de dépôts. Propose Actions, Pull Requests, Issues et Wiki. Gratuit pour les projets publics.
• GitLab — plateforme avec CI/CD intégré, Container Registry et un pipeline DevOps intégré. Disponible en version SaaS et self-hosted.
• Bitbucket — solution d’Atlassian avec intégration Jira et Trello. Populaire dans les environnements d’entreprise grâce à ses paramètres d’accès flexibles.

Le choix de la plateforme dépend de la taille de l’équipe, des exigences de confidentialité et des intégrations nécessaires. Pour le développement mobile, GitHub est souvent choisi en raison du large soutien de la communauté et de l’intégration avec les outils CI/CD pour iOS et Android.

Exemples de commandes pour travailler avec un dépôt

Considérons un scénario pratique : un développeur clone un dépôt existant, crée une nouvelle branche, apporte des modifications et les envoie au serveur. Chaque commande illustre le travail avec différents composants du dépôt.

# Cloner un dépôt distant
git clone https://github.com/user/mobile-app.git

# Naviguer vers le répertoire du projet
cd mobile-app

# Créer une nouvelle branche feature et basculer dessus
git checkout -b feature/auth

# Vérifier l’état des fichiers modifiés
git status

# Ajouter toutes les modifications à la zone de staging
git add .

# Créer un commit avec description
git commit -m "Add authentication module"

# Envoyer les modifications vers le dépôt distant
git push origin feature/auth

La commande git status est l’une des plus utiles au quotidien. Elle montre quels fichiers sont modifiés, lesquels sont préparés pour le commit et lesquels ne sont pas du tout suivis par Git.

Visualisation de l’historique des commits

Pour analyser l’historique du dépôt, la commande git log est utilisée avec divers indicateurs de formatage. Elle affiche la chronologie des commits, leurs auteurs, dates et identifiants SHA-1.

# Afficher l’historique avec visualisation du graphe des branches
git log --oneline --graph --all

# Afficher les modifications dans un commit spécifique
git show a1b2c3d

# Comparer l’état actuel avec le dernier commit
git diff HEAD

# Afficher l’historique d’un fichier spécifique
git log --follow src/MainActivity.kt

L’indicateur --graph affiche un graphique ASCII des branchements, ce qui est particulièrement utile dans les dépôts avec un travail actif sur plusieurs branches. Pour les projets mobiles avec des versions fréquentes, un graphique visuel aide à évaluer rapidement la structure du développement.