Héberger un serveur Git

Un serveur Git est un bare repository accessible en réseau. Pas besoin d'une plateforme complète comme GitHub pour collaborer : un simple serveur SSH suffit. Ce guide montre comment héberger vos dépôts avec SSH, git-shell, Smart HTTP et git daemon.

Prérequis : Protocoles Git et Remotes fondamentaux.

Ce que vous allez apprendre

• Créer un bare repository pour servir un dépôt centralisé
• Configurer l'accès SSH pour un partage sécurisé en équipe
• Mettre en place Smart HTTP avec Nginx pour accès HTTPS
• Comprendre les limites d'un serveur Git auto-hébergé vs plateforme dédiée

Le bare repository

Un dépôt « bare » contient uniquement les données Git (l'équivalent du dossier .git), sans copie de travail. C'est ce qu'on place sur un serveur :

# Créer un bare repo
git init --bare project.git

Le dossier project.git contient directement les répertoires objects/, refs/, HEAD, etc., pas de fichiers de travail.

Pour créer un bare repo depuis un dépôt existant :

git clone --bare /chemin/vers/project project.git

Convention .git

Par convention, les bare repos portent l'extension .git (project.git). Cette convention aide à distinguer visuellement un bare repo d'un dépôt normal.

Méthode 1 : accès SSH

La méthode la plus simple et la plus sûre. Tout serveur avec SSH installé peut héberger des dépôts Git.

1. Sur le serveur, créez un utilisateur et un bare repo :

   sudo adduser git
   sudo mkdir -p /srv/git/project.git
   sudo git init --bare /srv/git/project.git
   sudo chown -R git:git /srv/git/project.git

2. Ajoutez les clés SSH des développeurs :

   sudo mkdir -p /home/git/.ssh
   # Ajoutez chaque clé publique
   cat id_ed25519_dev1.pub >> /home/git/.ssh/authorized_keys
   cat id_ed25519_dev2.pub >> /home/git/.ssh/authorized_keys
   sudo chown -R git:git /home/git/.ssh
   sudo chmod 700 /home/git/.ssh
   sudo chmod 600 /home/git/.ssh/authorized_keys

3. Depuis un poste client, clonez et poussez :

   git clone git@serveur:/srv/git/project.git
   cd project
   # ... travailler ...
   git push origin main

Sécuriser avec git-shell

Par défaut, l'utilisateur git a un accès SSH complet au serveur. Pour le restreindre aux seules opérations Git :

# Vérifier que git-shell est dans /etc/shells
sudo sh -c 'which git-shell >> /etc/shells'

# Changer le shell de l'utilisateur git
sudo chsh -s $(which git-shell) git

Désormais, si quelqu'un tente de se connecter en SSH interactif avec l'utilisateur git, il reçoit :

fatal: Interactive git shell is not enabled.

Seules les commandes git push, git pull et git fetch fonctionnent.

Méthode 2 : Smart HTTP (Nginx)

Smart HTTP permet l'accès Git via HTTPS, idéal derrière un pare-feu ou pour les environnements CI/CD.

1. Installez les paquets :

   sudo apt install nginx git fcgiwrap

2. Configurez Nginx :

   server {
       listen 443 ssl;
       server_name git.example.com;
   
       ssl_certificate /etc/ssl/certs/git.crt;
       ssl_certificate_key /etc/ssl/private/git.key;
   
       location ~ ^/git(/.*) {
           fastcgi_pass unix:/var/run/fcgiwrap.socket;
           include fastcgi_params;
           fastcgi_param SCRIPT_FILENAME /usr/lib/git-core/git-http-backend;
           fastcgi_param GIT_HTTP_EXPORT_ALL "";
           fastcgi_param GIT_PROJECT_ROOT /srv/git;
           fastcgi_param PATH_INFO $1;
       }
   }

3. Activez le push sur les bare repos :

   cd /srv/git/project.git
   git config http.receivepack true

4. Clonez via HTTPS :

   git clone https://git.example.com/git/project.git

Authentification HTTP

Pour contrôler l'accès en écriture, ajoutez une authentification HTTP (Basic Auth, LDAP, etc.) dans la configuration Nginx. Sans cela, tout le monde peut pousser.

Méthode 3 : git daemon (lecture seule)

git daemon sert les dépôts via le protocole Git (git://). Il est rapide mais sans authentification ni chiffrement :

git daemon --reuseaddr --base-path=/srv/git/ /srv/git/

Pour autoriser un dépôt à être servi :

touch /srv/git/project.git/git-daemon-export-ok

Pas pour la production

git daemon ne fournit ni authentification ni chiffrement. Utilisez-le uniquement sur un réseau local de confiance ou pour des miroirs publics en lecture seule.

Comparatif des méthodes

Critère	SSH	Smart HTTP	git daemon
Sécurité	Chiffrement + clés	TLS + auth HTTP	Aucune
Lecture	Oui	Oui	Oui
Écriture	Oui	Oui (si configuré)	Non
Configuration	Faible	Moyenne	Faible
Pare-feu	Port 22	Port 443	Port 9418
Cas d'usage	Équipe interne	CI/CD, accès web	Miroir lecture seule

Glissez pour voir

Organiser les dépôts sur le serveur

/srv/git/
├── team-a/
│   ├── api-backend.git
│   └── frontend-app.git
├── team-b/
│   └── data-pipeline.git
└── shared/
    ├── common-lib.git
    └── config-templates.git

Bonnes pratiques :

• Groupez par équipe ou par projet
• Utilisez des bare repos uniquement (pas de copie de travail)
• Gérez les permissions via les groupes Unix :

sudo chgrp -R team-a /srv/git/team-a/
sudo chmod -R g+rwX /srv/git/team-a/

Sauvegarder et restaurer un bare repository

Un bare repository ne contient que l'historique Git : une sauvegarde simple et régulière suffit pour garantir la continuité.

Sauvegarder

# Méthode 1 : archive tar (la plus simple)
tar czf project-$(date +%Y%m%d).git.tar.gz /srv/git/project.git

# Méthode 2 : rsync vers un autre serveur
rsync -az /srv/git/project.git backup-server:/backup/git/

# Méthode 3 : bundle Git (auto-contenu, transportable)
git -C /srv/git/project.git bundle create project-$(date +%Y%m%d).bundle --all

Le bundle Git est particulièrement utile pour les transferts hors-ligne ou les sauvegardes embarquées : il contient l'intégralité de l'historique dans un seul fichier portable.

Restaurer depuis une archive tar

# Extraire le bare repo
tar xzf project-20260328.git.tar.gz -C /srv/git/

# Vérifier l'intégrité
git -C /srv/git/project.git fsck

Restaurer depuis un bundle

# Vérifier le bundle
git bundle verify project-20260328.bundle

# Cloner depuis le bundle (reconstruction complète)
git clone project-20260328.bundle /srv/git/project.git --bare

Automatiser les sauvegardes

Planifiez la sauvegarde dans un cron :

# crontab -e
0 2 * * * tar czf /backup/git/project-$(date +\%Y\%m\%d).git.tar.gz /srv/git/project.git

Conservez au moins 7 jours de sauvegardes et vérifiez régulièrement la restauration.

Dépannage : problèmes courants

Symptôme	Cause probable	Solution
Permission denied au push	Permissions du bare repo	chown -R git:git repo.git
remote: error: refusing to update checked out branch	Le repo n'est pas bare	Recréez avec git init --bare
fatal: Interactive git shell is not enabled	git-shell actif	Normal, seules les commandes Git passent
Smart HTTP retourne 403	http.receivepack non activé	git config http.receivepack true

Glissez pour voir

À retenir

• Un bare repository (git init --bare) est la base d'un serveur Git
• SSH + git-shell : méthode la plus simple et la plus sûre
• Smart HTTP : idéal derrière un pare-feu ou pour la CI/CD
• git daemon : lecture seule, pas d'authentification, usage limité
• Pour un usage plus complet (web UI, PR, CI), envisagez une plateforme Git

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

10 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

Pour aller plus loin

• Multi-dépôts et transfert : L'organisation du code quand un seul dépôt ne suffit plus.
• Git bundle : Le transport d'un dépôt entier vers un site sans accès réseau à votre serveur.
• Stockage des credentials : La gestion des identifiants que vos utilisateurs présenteront au serveur.

×

📖 Voir la documentation →