Dépôt Git : le créer avec git init et connecter un remote

Un dépôt Git est un projet dont Git suit les modifications. Concrètement, c'est un dossier ordinaire contenant vos fichiers, plus un répertoire caché .git qui stocke tout l'historique : commits, branches, tags, configuration. Supprimez .git et il ne reste que des fichiers, sans la moindre version passée.

De quoi se compose un dépôt

Quand on travaille avec Git, il est utile de garder en tête trois zones entre lesquelles circulent les modifications :

• le répertoire de travail (working tree) — les fichiers que vous voyez et modifiez ;
• l'index (staging area) — le brouillon du prochain commit, où les modifications arrivent via git add ;
• l'historique — la base de commits dans .git, où les modifications arrivent via git commit.

À proprement parler, le dépôt lui-même, c'est le contenu de .git. Le répertoire de travail n'est qu'une version « dépliée » du projet que Git extrait de l'historique.

Comment créer un dépôt Git avec git init

Placez-vous dans le dossier du projet et lancez une seule commande :

cd ~/projects/my-app
git init

Initialized empty Git repository in /home/user/projects/my-app/.git/

On peut créer un dépôt aussi bien dans un dossier vide que dans un dossier contenant déjà des fichiers. Dans ce dernier cas, rien n'est perdu : les fichiers existants deviennent simplement non suivis (untracked) jusqu'à ce que vous les ajoutiez avec git add.

Variantes utiles de la commande :

# Créer le dossier et le dépôt dedans d'un coup
git init my-app

# Choisir le nom de la première branche (sinon master ou la valeur des réglages)
git init -b main

# Faire de main la branche par défaut de tous les nouveaux dépôts
git config --global init.defaultBranch main

Le premier commit

Un dépôt vide sans commit ne sert presque à rien. Juste après git init, on fait généralement ceci :

git config --global user.name "Jean Dupont"
git config --global user.email "jean@example.com"

git status
git add .
git commit -m "Structure initiale du projet"

Le nom et l'e-mail se définissent une fois par ordinateur — ils sont inscrits dans chaque commit. Sans eux, Git refuse de committer et vous demande de vous présenter.

Ajoutez tout de suite un .gitignore

Avant le premier git add ., créez un fichier .gitignore listant ce qui ne doit pas entrer dans le dépôt : dépendances, builds, secrets, fichiers de l'IDE.

node_modules/
dist/
.env
.idea/
.vscode/
*.log
__pycache__/

Si le fichier a déjà été commité, .gitignore ne le retirera pas. Il faut cesser de le suivre tout en le gardant sur le disque : git rm --cached .env, puis committer.

Que contient le dossier .git

Inutile d'y aller dans le travail quotidien, mais comprendre sa structure répond à beaucoup de questions :

Conclusion importante : dans Git, une branche est un minuscule fichier contenant un seul hash. C'est pourquoi créer une branche est instantané et ne coûte rien.

Comment vérifier qu'un dossier est un dépôt

git status
# ou plus précisément
git rev-parse --is-inside-work-tree

Hors d'un dépôt, vous obtiendrez fatal: not a git repository (or any of the parent directories): .git. Notez le « parent directories » : Git cherche .git en remontant l'arborescence. Si vous lancez par mégarde git init dans votre répertoire personnel, tout celui-ci devient un dépôt — il faut alors supprimer ce dossier .git.

Dépôt local et dépôt distant

Un dépôt créé avec git init n'existe que sur votre ordinateur. Pour partager le code et disposer d'une sauvegarde, on y connecte un dépôt distant (remote) — une copie sur un serveur : GitHub, GitLab, Bitbucket ou votre propre serveur Git.

Du point de vue de Git, le dépôt distant n'est pas « le principal » : chaque copie est complète et contient tout l'historique. Seule la convention de l'équipe en fait le dépôt central.

git remote : connecter un dépôt distant

Un remote est un nom court associé à l'adresse d'un serveur. Par convention, le nom principal est origin.

# Ajouter un remote
git remote add origin git@github.com:username/my-app.git

# Afficher la liste avec les adresses
git remote -v

origin  git@github.com:username/my-app.git (fetch)
origin  git@github.com:username/my-app.git (push)

Envoyez ensuite la branche et associez-la à la branche distante :

git push -u origin main

Les principales commandes git remote

Formats d'adresse

• https://github.com/user/repo.git — HTTPS, fonctionne partout, un token est nécessaire pour écrire ;
• git@github.com:user/repo.git — SSH, nécessite une clé, plus de mot de passe demandé une fois configuré ;
• /srv/git/repo.git ou file:///srv/git/repo.git — chemin local, pratique pour expérimenter.

Erreurs typiques

« error: remote origin already exists ». Un remote de ce nom existe déjà. Pour changer l'adresse, utilisez git remote set-url origin <url> plutôt qu'un nouveau add.

« failed to push some refs » / « Updates were rejected ». Le serveur contient des commits que vous n'avez pas — souvent le README créé en même temps que le dépôt sur le site. Lancez git pull --rebase origin main et recommencez le push. Si les historiques n'ont aucun lien, Git répondra « refusing to merge unrelated histories » — il faut alors l'option --allow-unrelated-histories pour git pull. Le plus simple est de créer le dépôt vide sur le site.

« src refspec main does not match any ». Vous essayez d'envoyer une branche qui n'existe pas : soit aucun commit n'a encore été fait, soit la branche s'appelle master. Vérifiez avec git branch.

Votre propre serveur Git : le dépôt bare

GitHub n'est pas obligatoire. N'importe quelle machine à laquelle vous accédez en SSH peut servir de dépôt distant. On y crée pour cela un dépôt « nu » (bare) — sans répertoire de travail, uniquement le contenu de .git :

# Sur le serveur
ssh user@server
git init --bare /srv/git/my-app.git

# Sur votre ordinateur
git remote add origin user@server:/srv/git/my-app.git
git push -u origin main

Pour travailler à trois sur un tel serveur, il suffit de donner aux collègues un accès SSH au dossier du dépôt et un groupe commun avec droits d'écriture. Pour gérer des droits par branche ou par projet, cela ne suffit plus — il faut alors un véritable hébergement Git.

On ne peut pas « entrer dans un dépôt bare et corriger un fichier » : il ne sert qu'aux échanges par push et fetch. C'est ainsi que sont organisés les dépôts de tout hébergeur Git. Si vous avez besoin d'une interface web, de revues de code et de tickets, installez une solution auto-hébergée comme GitLab, Gitea ou Forgejo.

Les branches de suivi : comment le dépôt local voit le serveur

Après la connexion d'un remote et le premier git fetch ou git push, des branches distantes du type origin/main apparaissent dans le dépôt. Ce ne sont pas les branches du serveur, mais des « instantanés » locaux de ce que vous avez vu sur le serveur lors de la dernière synchronisation. Elles ne sont mises à jour que par fetch, pull et push.

D'où une différence importante entre les trois commandes d'échange :

Pour savoir de combien votre branche est en retard ou en avance :

git fetch
git status -sb

## main...origin/main [ahead 2, behind 1]

Ici, vous avez deux commits absents du serveur, et le serveur en a un que vous n'avez pas. Avant de pousser, il faut d'abord récupérer ce commit.

Le lien entre la branche locale et la branche distante (upstream) se définit avec l'option -u lors du premier push. En cas d'oubli, on peut le définir séparément : git branch --set-upstream-to=origin/main. Pour voir tous les liens : git branch -vv.

Plusieurs dépôts : monorepo ou un dépôt par projet

Question fréquente chez les débutants : combien de dépôts Git créer ? Règle simple : un dépôt par unité développée et publiée de façon indépendante. Projets d'apprentissage, projets perso et services distincts vont dans des dépôts différents. Ne créez pas un seul dépôt pour tout le dossier « Mes projets » : l'historique serait mélangé, et publier un projet seul dans votre portfolio deviendrait compliqué.

Les grandes entreprises gardent parfois tout leur code dans un monorepo pour les changements transverses et un build unifié, mais c'est un choix d'architecture délibéré avec ses propres outils. Un débutant a intérêt à partir de la règle « un projet, un dépôt » et à ne jamais imbriquer un dépôt dans un autre sans sous-modules.

git init ou git clone

Après git clone, le remote origin est déjà configuré, inutile de l'ajouter à la main.

Pas à pas : du dossier au dépôt sur GitHub

1. Créez le dossier du projet et lancez git init -b main.
2. Ajoutez un .gitignore et un README.
3. Faites le premier commit : git add . puis git commit -m "Initial commit".
4. Créez sur GitHub un dépôt vide — sans README, licence ni .gitignore.
5. Connectez-le : git remote add origin <adresse>.
6. Envoyez le code : git push -u origin main.
7. Travaillez ensuite en boucle : modifications → git add → git commit → git push.

En résumé

Un dépôt Git, c'est votre projet plus un dossier .git contenant tout l'historique. On le crée avec git init, et la liaison avec le serveur se configure via git remote add origin et un premier git push -u. Le dépôt distant peut être GitHub, GitLab ou votre propre serveur Git avec un dépôt bare. La création d'un premier dépôt, l'index et la connexion d'un remote sont abordés en pratique dans le cours Git.