Installer et configurer un serveur GIT sous Linux

Page mise à jour le 16 avril 2018

Cet article fait partie d’une série d’articles sur GIT.

Dans cet article, j’explique comment installer un « serveur GIT » ie un dépôt GIT centralisé sur une machine Linux équipée de l’OS Debian.
Ces explications sont très facilement transposables sur d’autres OS Linux.

Prérequis

  • Disposer d’une machine Linux « le serveur ».
  • Pour éviter de mauvaises surprises, veuillez au :
    • Système d’exploitation : Linux , fréquemment mise à jour ;
    • Stockage matériel : disques dur en RAID  ;
    • Onduleur : correctement configuré ;
    • Système de sauvegarde : système efficace et robuste ;
    • Connexion Internet : évitez le 56k … ;
    • Sécurité des accès distants : un firewall correctement configuré (iptables, fail2ban, …).
  • Vous devez bien entendu avoir accès à cette machine :
    • En local mais surtout à distance (SSH) ;
    • Avec des droits administrateur (« root », ou être membre du groupe « sudo »).
  • Pour l’accès aux dépôts GIT de ce serveur depuis les clients GIT :
    • Un serveur SSH fonctionnel et correctement configuré (sécurisé) ;
      et/ou
    • Un serveur HTTP(S) fonctionnel et correctement configuré (Apache de préférence).

Installer GIT-core sur le serveur

C’est l’étape la plus simple. Seul le paquet « git-core » est nécessaire côté serveur.

# sur le serveur
$ sudo aptitude install git-core

Créer un dépôt (vide ou non) à destination du serveur

Concrètement, un dépôt GIT côté serveur est un dossier, nommé par convention my_repo.git, auquel on accède par la suite par SSH, HTTP(S), … via le client git côté utilisateur.

Plusieurs solutions pour créer ce dossier : soit directement côté serveur (dépôt vide), soit côté client (dépôt vide ou non) qu’il faudra envoyer sur le serveur.

   Créer simplement un dépôt vide, côté serveur

Solution la plus simple et rapide : créer un dépôt vide sur le serveur. Ensuite, en local, après avoir fait un clone  de ce dépôt vide, vous y ajouterez au fur et à mesure vos nouveaux fichiers. Après un (ou plusieurs) commit(s) en local, un push enverra votre travail vers le serveur (c’est à dire les différentes versions commitées).

Attention ! Si vous possédez déjà un dépôt GIT en local, avec  un ensemble de révisions (ie de commits), et que vous copiez/collez vos fichiers (tous sauf le dossier .git) dans le dossier de votre nouveau dépôt vide cloné, vous perdrez les révisions antérieures ! Il est dans ce cas préférable d’utiliser la solution suivante : Créer un dépôt en local à destination du serveur.

  • Sur le serveur, dans le dossier qui contient vos dépôts, créez un dossier nommé my_repo.git :
# sur le serveur
user@serveur:~$ mkdir -p /repos/my_repo.git
user@serveur:~$ cd repos/my_repo.git
  • A présent, initialisons ce dépôt :
# sur le serveur
user@serveur:~/repos/my_repo.git$ git init --bare
Dépôt Git vide initialisé dans /home/user/repos/my_repo.git/
  • Explications :
    • git init est la commande d’initialisation d’un dépôt GIT qui est utilisée en local (sur un client) et qui ne doit pas être utilisée seule pour initialiser un dépôt sur le serveur ;
    • git init –bare permet d’initialiser un dépôt GIT sur le serveur : cela créé un ensemble de fichiers (config, description, HEAD) et de dossiers (branches, looks, info, objects, refs) utiles à GIT ;
    • L’option –shared (facultative) permet de configurer automatiquement les droits des fichiers et dossiers du dépôt en écriture au groupe, j’en reparle plus loin.
  • Exemple client/serveur en SSH pour la suite :
 
# sur le client, on clone le dépôt :
user@client:~$ git clone user@serveur:repos/my_repo.git .
user@client:~$ cd my_repo
# sur le client, on ajoute des fichiers :
user@client:~/my_repo$ cp path/to/my_file.txt .
# sur le client, on ajoute/commit les changements :
user@client:~/my_repo$ git add .
user@client:~/my_repo$ git commit -m "1er commit"
# sur le client, on push ce commit :
user@client:~/my_repo$ git push

  Créer un dépôt vide en local à destination du serveur

  • Créez un dossier pour le dépôt :
# sur le client :
user@client:~$ mkdir my_repo
user@client:~$ cd my_repo/
  • Initialisez ce dépôt avec GIT (il faut donc que GIT soit installé sur la machine) :
# toujours dans le dossier my_repo
user@client:~/my_repo$ git init
Dépôt Git vide initialisé dans /home/user/my_repo/.git/

Dans ce cas, l’option –shared est inutile, car lors de la création de la version bare (ci-dessous), les droits ne sont pas conservés. Nous corrigerons les permissions manuellement plus tard du côté serveur. 

  • Créez à présent  une version bare de votre dépôt my_repo.
    Un bare repository est un dépôt qui ne contient que le nécessaire pour être placé sur le serveur (en l’occurence, qui ne contient pas les fichiers relatifs à la version de travail (ie working directory), mais qui grossièrement ne contient que le contenu du dossier .git à la racine du dépôt initialisé précédemment :
# aller à la racine du dossier my_repo
user@client:~/my_repo$ cd ..
user@client:~$ git clone --bare my_repo/ my_repo.git 
Clonage dans le dépôt nu 'my_repo.git' 
warning: Vous semblez avoir cloné un dépôt vide.
fait. 
user@client:~$ ls -l 
my_repo.git #la version 'bare', que l'on va placer sur le serveur 
my_repo #le dossier qui contient le dépôt que l'on a créé précédemment, et qui ne nous intéresse plus, donc :
user@client:~$ rm -rf my_repo
  • Déplaçons la version bare du dépôt sur le serveur
# exemple de transfert avec SCP :
user@client:~$ scp -r my_repo.git  user@serveur:repos/

Si besoin, définissez correctement le propriétaire, groupe et droits du dossier my_repo.git sur le serveur.

  • Exemple client/serveur en SSH pour la suite :
 
# sur le client, on clone le dépôt :
user@client:~$ git clone user@serveur:repos/my_repo.git .
user@client:~$ cd my_repo
# sur le client, on ajoute des fichiers :
user@client:~/my_repo$ cp path/to/my_file.txt .
# sur le client, on ajoute/commit les changements :
user@client:~/my_repo$ git add .
user@client:~/my_repo$ git commit -m "1er commit"
# sur le client, on push ce commit :
user@client:~/my_repo$ git pull

  Envoyer un dépôt local existant à destination du serveur

Supposons que vous ayez un dépôt GIT existant en local (/home/user/my_repo/). Vous avez dans le passé initialisé ce dossier, puis réalisé une série de commit.

  • Créez une version bare de votre dépôt my_repo.
    Un bare repository est un dépôt qui ne contient que le nécessaire pour être placé sur le serveur (en l’occurence, qui ne contient pas les fichiers relatifs à la version de travail (ie working directory), mais qui grossièrement ne contient que le contenu du dossier .git à la racine du dépôt initialisé précédemment :
# aller à la racine du dossier my_repo
user@client:~/my_repo$ cd ..
user@client:~$ git clone --bare my_repo/ my_repo.git 
Clonage dans le dépôt nu 'my_repo.git' 
fait. 
user@client:~$ ls -l 
my_repo.git #la version 'bare', que l'on va placer sur le serveur 
my_repo #le dossier qui contient le dépôt que l'on a créé précédemment, et qui ne nous intéresse plus, donc :
user@client:~$ rm -rf my_repo
  • Déplaçons la version bare du dépôt sur le serveur
# exemple de transfert avec SCP :
user@client:~$ scp -r my_repo.git  user@serveur:repos/

Si besoin, définissez correctement le propriétaire, groupe et droits du dossier my_repo.git sur le serveur.

  • Exemple client/serveur en SSH pour la suite :
 
# sur le client, on clone le dépôt :
user@client:~$ git clone user@serveur:repos/my_repo.git .
user@client:~$ cd my_repo
# sur le client, on ajoute des fichiers :
user@client:~/my_repo$ cp path/to/my_file.txt .
# sur le client, on ajoute/commit les changements :
user@client:~/my_repo$ git add .
user@client:~/my_repo$ git commit -m "1er commit"
# sur le client, on push ce commit :
user@client:~/my_repo$ git push

Solution client/serveur SSH mono-utilisateur

Si vous ne pensez pas avoir besoin de partager l’accès à votre dépôt avec d’autres utilisateurs, ie que vous êtes le seul à y accéder, rien de plus simple si l’on dispose d’un accès SSH au serveur.

Sur le serveur, créez logiquement dans votre /home/user un dossier nommé repos (attention aux droits si votre home est « ouvert »).

Il suffit ensuite de placer la version bare de votre dépôt (exemples ci-dessus avec SCP) dans ce dossier /home/user/repos.

Exemple d’utilisation :

 
# sur le client, on clone le dépôt :
user@client:~$ git clone user@serveur:repos/my_repo.git .
user@client:~$ cd my_repo
# sur le client, on ajoute des fichiers :
user@client:~/my_repo$ cp path/to/my_file.txt .
# sur le client, on ajoute/commit les changements :
user@client:~/my_repo$ git add .
user@client:~/my_repo$ git commit -m "1er commit"
# sur le client, on push ce commit :
user@client:~/my_repo$ git push

Par la suite, en local, à chaque git push, git pull (ou autre commande nécessitant une connexion au dépôt stocké sur le serveur), votre login/pwd sera demandé, à moins que vous ayez configuré SSH pour utiliser votre clé SSH (sur le serveur, .ssh/authorized_keys contient votre clé publique)

Solution client/serveur SSH multi-utilisateurs

SI vous comptez travailler à plusieurs sur le même dépôt stocké sur le serveur, il est plus interessant de créer un utilisateur et un groupe git sur le serveur, pour gérer les accès SSH via /home/git/.ssh/authorized_keys

  • Sur le serveur, créez un utilisateur git :
 # sur le serveur 
root@serveur:$ adduser git 
Ajout de l'utilisateur git ...
Ajout du nouveau groupe git ... 
Ajout du nouvel utilisateur git avec le groupe git ... 
Création du répertoire personnel /home/git ...
Copie des fichiers depuis /etc/skel ... 
Entrez le nouveau mot de passe UNIX : ******
Retapez le nouveau mot de passe UNIX : ******
passwd: le mot de passe a été mis à jour avec succès 
  • Sur le serveur, connectez vous avec le compte git :
 # sur le serveur 
root@serveur:$ su git
  • Sur le serveur, connecté en tant que git, créez un dossier racine pour les dépôts, et une éventuelle arborescence :
 # sur le serveur 
git@serveur:$ mkdir repo

Remarque : avec cette solution, si vous créez un dépôt vide, l’utilisation de l’option –shared lors de la commande git clone –bare a pour effet de créer un dépôt partagé en écriture aux membres du groupe git.

# sur le serveur
git@serveur:~$ mkdir -p repos/my_repo.git
git@serveur:~$ cd repos/my_repo.git
git@serveur:~/repos/my_repo.git$ git init --bare --shared
Dépôt Git *partagé* vide initialisé dans /home/git/repos/my_repo.git/

git@serveur:~/repos/my_repo.git$ ls -l
total 32K
drwxrwsr-x 2 git git branches
-rwxrw-r-- 1 git git config
-rw-rw-r-- 1 git git description
-rw-rw-r-- 1 git git HEAD
drwxrwsr-x 2 git git hooks
drwxrwsr-x 2 git git info
drwxrwsr-x 4 git git objects
drwxrwsr-x 4 git git refs

Sans cette option, les membres du groupe git ont juste accès en lecture.

# sur le serveur
git@serveur:~/repos/my_repo.git$ git init --bare
Dépôt Git vide initialisé dans /home/git/repos/my_repo.git/

git@serveur:~/repos/my_repo.git$ ls -l
total 32
drwxr-sr-x 2 git git branches
-rwxr--r-- 1 git git config
-rw-r--r-- 1 git git description
-rw-r--r-- 1 git git HEAD
drwxr-sr-x 2 git git hooks
drwxr-sr-x 2 git git info
drwxr-sr-x 4 git git objects
drwxr-sr-x 4 git git refs

  Gestion des accès au serveur

Plutôt que de communiquer le login/mot de passe du compte git aux autres utilisateurs, il est préférable d’utiliser la fonctionnalité d’authentification par clé de SSH : ajoutez la clé publique des utilisateurs au fichier /home/git/.ssh/authorized_keys

Une autre solution consiste à créer un compte pour chaque utilisateur sur le serveur, et d’ajouter ces utilisateurs au groupe git, en ajustant bien sûr les droits lecture/écriture/exécution du dossier (et sous-dossiers) /home/git/repos.

Communiquer avec le serveur GIT par HTTP(S)

Cette section est en cours de rédaction …

3 réflexions sur « Installer et configurer un serveur GIT sous Linux »

  1. salut ,merci pour cet article très détallé et facile à comprendre mais moi j’aimerais plus de détails sur le fait de créer plusieurs comptes utilisateurs pour gérer un projet.merci

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.