Réseau - Web - GNU/Linux

2020 29 mai

Mise en place d'un dépôt Git sur un serveur distant

Rédigé par Marc GUILLAUME | Aucun commentaire

Si l'on est le seul développeur sur un projet, ou une petite poignée de développeurs, on peut travailler avec un dépôt Git sur un serveur accessible depuis le web via ssh. C'est la façon la plus simple d'utiliser Git depuis n'importe où sur Internet.

Prérequis

Pour pouvoir appliquer ces configurations il faut que nous possédions :

  1. Un serveur distant (sur le web ou sur votre réseau local suivant vos besoins)  ;
  2. Que ce serveur tourne sous GNU/Linux, ici je prendrai l'exemple de Debian, mais c'est adaptable à n'importe quelle distribution un peu complète ;
  3. Que vous ayez un accès root sur cette machine (via un accès direct ou via ssh) ;
  4. Et bien entendu que vous soyez un peu à l'aise avec les commandes en ligne sur une console.

Création de l'utilisateur et du répertoire racine du dépôt Git

Nous postulerons que votre serveur porte le nom dns mygit.example.com et que vous pouvez y accéder via ssh et y devenir root.

La première chose à faire, si cela n'est pas déjà fait, est d'installer Git sur votre serveur (bien entendu en tant que root, soit via sudo soit en se connectant au compte root) :

apt install git

Il faut choisir le dossier dans lequel vous installerez vos dépôts Git. Vous pouvez choisir ce que vous voulez, dans un dossier /home/gituser ou bien dans un répertoire spécial type /srv ou /var/git par exemple. Nous allons dans cet exemple choisir l'installation dans /srv/gitroot ce qui permettra de voir comment configurer l'accès à ce répertoire de l'utilisateur de Git que nous allons définir ci-dessous.

mkdir /srv/gitroot

Les dépôts Git seront utilisés via ssh. Il faut donc commencer par créer un utilisateur spécifique pour l'utilisation de Git. Nous allons dans cet exemple l'appeller de façon peu originale gituser. Comme l'on veut que cet utilisateur ne puisse pas faire autre chose que lancer des commandes git, nous allons utiliser le shell limité fourni avec Git : git-shell. Et comme répertoire home nous allons lui donner celui défini ci-dessus.

Nous savons donc déjà que nos dépôts seront accessibles via des URLs de type :

gituser@mygit.example.com:/srv/gitroot/nom-depot

Pour pouvoir utiliser git-shell il faut d'abord s'assurer qu'il est disponible :

$ cat /etc/shells   # voir si `git-shell` est déjà déclaré.  Sinon...
$ which git-shell   # s'assurer que git-shell est installé sur le système
$ echo `which git-shell` >> /etc/shells  # et ajouter le chemin complet vers git-shell

Créons l'utilisateur :

useradd --no-create-home --home-dir /srv/gitroot/ --shell /usr/bin/git-shell gituser

L'option --no-create-home permet d'éviter de copier les fichiers créés par défaut dans le répertoire utilisateur, pour les autres options voir, en cas de doute, man useradd. La commande va créer l'utilisateur et par la même occasion le groupe du même nom. Nous donnons ensuite le répertoire à l'utilisateur et au groupe gituser :

chown -R gituser\: /srv/gitroot

La syntaxe gituser\: est équivalente à gituser:gituser, elle est utilisable quand l'utilisateur et le groupe ont le même nom et surtout pratique si ce nom est long et compliqué. Sur Ubuntu en tapant les premières lettres et la touche de tabulation le complètement shell fonctionne pour trouver le nom d'user ou de groupe, pas sur Debian.

On remarquera que l'utilisateur gituser n'a pas de mot de passe. L'accès se fera uniquement par clé SSH. Dans cette version simple nous allons placer dans /srv/gitroot/.ssh/authorized_keys les clés publiques des développeurs autorisés à envoyer du code sur notre Git. il faut donc créer le dossier .ssh et le fichier authorized_keys et les donner à l'utiliateur gituser. Puis copier dans ce fichier les clés publiques des développeurs.

mkdir /srv/gitroot/.ssh
touch /srv/gitroot/.ssh/authorized_keys
chown -R gituser\: /srv/gitroot/

Nous allons placer notre clé dans ce fichier. Nous copions notre clé (ici dans l'exemple id_rsa.pub qui se trouve dans notre répertoire $HOME/.ssh/) sur le serveur git.

Puis nous allons ajouter son contenu au fichier /srv/gitroot/.ssh/authorized_keys :

cat id_rsa.pub >> /srv/gitroot/.ssh/authorized_keys

L’utilisateur gituser ne peut utiliser la connexion SSH que pour pousser et tirer sur des dépôts Git, il ne peut pas ouvrir un shell. Si vous essayez, vous verrez un rejet de login :

$ ssh gituser@mygit.example.com
fatal: Interactive git shell is not enabled.
hint: ~/git-shell-commands should exist and have read and execute access.
Connection to gitserveur closed.

Si l'utilisateur gituser existe déjà et que vous vouliez restreindre son shell pour qu'il ne puisse utiliser que Git en utilisant git-shell il faut modifier son shell :

$ sudo chsh gituser -s `which git-shell`

On peut vérifier dans /etc/passwd :

# grep gituser /etc/passwd
gituser:x:1010:1010:,,,:/srv/gitroot/:/usr/bin/git-shell

La première partie du travail est faite, il reste à initialiser un dépôt Git sur le serveur.

Création et initialisation d'un dépôt Git sur le serveur

Les dépôts Git vont se trouver dans la racine /srv/gitroot que nous venons de définir. Les dossiers de projet peuvent se trouver dans une arborescence suivant votre besoin. Supposons que vous ayez besoin de créer des scirpts bash, des sites web en php et des développements en python, vous pouvez créer une arborescence de ce type :

/srv/gitroot/
├── bash
├── php
└── python

et vous placerez les projets dans le répertoire correspondant. Bien entendu toute cette arborescence doit appartenir à l'utilisateur et au groupe gituser. Nous allons créer un projet backup.git dans le répertoire bash, destiné à contenir des scripts lançant des commandes rsync.

Pour créer un dépôt vide nu il suffit de lancer la commande git init avec l’option --bare, ce qui initialise un dépôt sans répertoire de travail :

$ cd /srv/gitroot/bash/
$ mkdir  backup.git
$ cd backup.git
$ git init --bare
Initialized empty Git repository in /srv/gitroot/bash/backup.git/

L'arborescence se présente maintenant ainsi :

/srv/gitroot/
├── bash
│   └── backup.git
│       ├── branches
│       ├── config
│       ├── description
│       ├── HEAD
│       ├── hooks
│       │   ├── applypatch-msg.sample
│       │   ├── commit-msg.sample
│       │   ├── post-update.sample
│       │   ├── pre-applypatch.sample
│       │   ├── pre-commit.sample
│       │   ├── prepare-commit-msg.sample
│       │   ├── pre-push.sample
│       │   ├── pre-rebase.sample
│       │   ├── pre-receive.sample
│       │   └── update.sample
│       ├── info
│       │   └── exclude
│       ├── objects
│       │   ├── info
│       │   └── pack
│       └── refs
│           ├── heads
│           └── tags
├── php
└── python

Il faut bien entendu ne pas oublier de donner l'arborescence à l'utilisateur et au groupe gituser :

chown -R gituser\: /srv/gitroot/

Un utilisateur peut alors pousser la première version de project vers ce dépôt en l’ajoutant en tant que dépôt distant et en lui poussant une branche. Notons que quelqu’un doit se connecter par shell au serveur et créer un dépôt nu pour chaque ajout de projet. Un script au chapitre suivant permet d'automatiser un peu l'opération.

Pour amorcer le projet, à partir du code situé dans le dossier project de l'utilisateur :

$ cd project
$ git init
$ git add .
$ git commit -m 'première validation'
$ git remote add origin gituser@mygit.example.com:/srv/gitroot/bash/backup.git
$ git push origin master

Si vous vous connectez en ssh avec un autre port que le port par défaut (port 22), disons le port 222 par exemple, il faut modifier la chaîne de connexion au dépôt remote comme suit :

git remote add origin gituser@mygit.example.com:222/srv/gitroot/bash/backup.git

Dans la configuration du dépôt du client on doit avoir :

git remote -v                                                                                                                                                                                                
origin  ssh://gituser@mygit.example.com:222/srv/gitroot/bash/backup.git (fetch)                                                                                                                                             
origin  ssh://gituser@mygit.example.com:222/srv/gitroot/bash/backup.git (push)

Script de création de dépôt Git distant

Un script simple permet de configurer un dépôt Git sur le serveur via ssh. Le script prend en argument le nom du projet ou éventuellement le chemin et le nom. Si l'on veut créer un projet website.git en php en utilisant ce script on lancera depuis un user ayant l'accès gituser sur le serveur la commande :

ssh -l root mygit.example.com "/usr/local/sbin/createGitBare.sh php/website.git"
#!/bin/bash 
#==============================================================================
# Copyright: Yakati 2020
# Name: createGitBare.sh 
# OS: Linux
# Location: /usr/local/sbin/
# Purpose: Create a bare git repository on the server. Takes as an argument
#          the project name or the path to the project name.
# License: This script is provide free of charge with no warrenty or support. 
#          User are free to modify and distribute freely with no restrictions.
#===============================================================================

# Git root path
gitRootPath="/srv/gitroot/";
gitUser='gituser';


if [ -n "$1" ]; then
        projectName="$1";
else
        printf "%s\n" "Project name is mandatory";
        exit 1;
fi

projectPath=${gitRootPath}${projectName};


if [ ! -d ${projectPath} ]; then
        mkdir -p ${projectPath}
        if [ "$?" -eq "0" ]; then
                printf "%s\n" "Creation of directory ${projectPath}" 
        else 
                printf "%s\n" "Creation of directory ${projectPath} failed"
        fi
fi

cd ${projectPath};

pwd

git init --bare
if [ "$?" -eq "0" ]; then
        printf "%s\n" "Init git repository";
else
        printf "%s\n" "failed to init git repository";
fi


chown -R ${gitUser}\: ${gitRootPath}

exit 0;

Clonage d'un dépôt sur un autre ordinateur

Pour un utilisateur disposant d'un accès gituser sur le serveur il suffit de se placer dans son répertoire de travail et de lancer la commande :

git clone gituser@mygit.example.com:/srv/gitroot/bash/backup.git

Nous verrons dans un prochain article comment ajouter une interface web à vos dépôts en utilisant cgit.

Écrire un commentaire

Quelle est la troisième lettre du mot ayxv ?

Fil RSS des commentaires de cet article

À propos

Yakati.com - Réseau - Web - GNU/Linux © 2017

Généré par PluXml en 0.024s  Compression GZIP activée - Administration

Mes coordonnées

Marc Guillaume
contact[at]yakati.com
79150 ÉTUSSON

Crédits

Pour la gestion du contenu

Généré par PluXml, le Blog ou Cms sans base de données

Pour le contenu

Licence Creative Commons
Ce(tte) œuvre est mise à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International.

Pour le thème

Thème SOLID de blacktie.co adapté pour PluXml