web-dev-qa-db-fra.com

Comment spécifier quelle clé SSH utiliser dans git pour git Push afin d'avoir gitorious comme miroir?

J'ai un projet hébergé sur git.debian.org (alioth) et je voudrais configurer un hook post-réception pour mettre à jour un miroir du référentiel sur http://gitorious.org

Je suppose que je vais devoir utiliser git Push --mirror gitorious

Maintenant, je devrai faire autoriser Alioth sur gitorious pour que le Push réussisse. Comment je fais ça?

Je suppose que je dois configurer un utilisateur sur gitorious et créer une clé ssh pour cela. Et puis quand je fais le git Poussez le crochet post-réception, assurez-vous que cette clé ssh est utilisée.

Je pourrais utiliser un ~/.ssh/config mais le problème est que de nombreux utilisateurs peuvent pousser sur alioth, et tout le monde devrait se connecter et configurer le ~/.ssh/config. Au lieu de cela, j'aimerais avoir une option de ligne de commande ou une variable d'environnement pour dire à ssh quelle clé utiliser. Puis-je faire cela?

De plus, avez-vous d'autres idées sur la manière de réaliser la mise en miroir? Et, est-il possible de le configurer dans l'autre sens (pousser gitieusement sur alioth)?

githookmirroringgit-pushgitorious
39
Mildred

La réponse se trouve dans le manuel de référence git .

GIT_SSH

Si cette variable d'environnement est définie, git fetch et git Push utiliseront cette commande au lieu de ssh lorsqu'ils doivent se connecter à un système distant. Le $GIT_SSH la commande recevra exactement deux arguments: le nom d'utilisateur @ Host (ou simplement Host) de l'URL et la commande Shell à exécuter sur ce système distant.

Pour passer des options au programme que vous souhaitez répertorier dans GIT_SSH vous devrez envelopper le programme et les options dans un script Shell, puis définir GIT_SSH pour faire référence au script Shell.

Habituellement, il est plus facile de configurer les options souhaitées via votre _ .ssh/config fichier. Veuillez consulter votre documentation ssh pour plus de détails.

Donc, j'ai besoin d'écrire un script wrapper, j'écris ceci Push-gitorious.sh script:

#!/bin/sh


if [ "run" != "$1" ]; then
  exec ssh -i "$GITORIOUS_IDENTITY_FILE" -o "StrictHostKeyChecking no" "$@"
fi

remote=YOUR_SSH_GITORIOUS_URL

echo "Mirroring to $remote"

export GITORIOUS_IDENTITY_FILE="`mktemp /tmp/tmp.XXXXXXXXXX`"
export GIT_SSH="$0"

cat >"$GITORIOUS_IDENTITY_FILE" <<EOF
YOUR SSH PRIVATE KEY

EOF
cat >"$GITORIOUS_IDENTITY_FILE.pub" <<EOF
YOUR SSH PUBLIC KEY

EOF

#echo git Push --mirror "$remote"
git Push --mirror "$remote"

rm -f "$GITORIOUS_IDENTITY_FILE"
rm -f "$GITORIOUS_IDENTITY_FILE.pub"

exit 0

Bien sûr, vous devez remplir la clé privée (la clé publique est incluse dans le script pour référence uniquement. Vous devez également remplir l'URL gitorious.

Dans le crochet post-réception, vous devez mettre:

path/to/Push-gitorious.sh run

L'option run est importante, sinon elle exécutera ssh directement.

Avertissement: aucune vérification n'est effectuée sur l'identité de l'hôte distant. Vous pouvez supprimer l'option de la ligne de commande ssh et personnaliser known_hosts si tu veux. Dans ce cas d'utilisation, je ne pense pas que ce soit important.

37
Mildred

Il existe deux méthodes que je connais afin que vous puissiez spécifier n'importe quel fichier de clés que vous souhaitez utiliser pour un site git sur la ligne de commande git. Vous n'avez pas besoin de coder en dur ce fichier de clés dans un fichier de configuration ou un script. Vous fournissez simplement ceci directement sur la ligne de commande git.

Méthode 1: utilisez la variable d'environnement GIT_SSH

L'utilisation sera comme ceci sur la ligne de commande:

$ PKEY=~/.ssh/keyfile.pem git clone [email protected]:me/repo.git

Pour utiliser cette commande, vous devez effectuer une pré-configuration. Créez d'abord un script Shell avec le contenu suivant:

#!/bin/sh
if [ -z "$PKEY" ]; then
    # if PKEY is not specified, run ssh using default keyfile
    ssh "$@"
else
    ssh -i "$PKEY" "$@"
fi

Ensuite, exportez et définissez la variable GIT_SSH avec une valeur égale à l'emplacement du script Shell ci-dessus.

$ export GIT_SSH=~/ssh-git.sh

où ~/ssh-git.sh est le nom de fichier du script Shell ci-dessus.

Le script doit être exécutable, alors faites un chmod:

$ chmod +x ~/ssh-git.sh

Vous pouvez maintenant exécuter cette commande avec n'importe quel fichier de clés que vous choisissez d'utiliser:

$ PKEY=~/.ssh/keyfile1.pem git clone [email protected]:me/repo.git

Pour utiliser un autre fichier de clés pour un autre hôte:

$ PKEY=~/.ssh/keyfile2.pem git clone [email protected]:other/repo.git

Cela prend en charge tout fichier clé que vous souhaitez utiliser. Chaque fois que vous devez exécuter git avec un fichier de clés que vous souhaitez utiliser, fournissez-le simplement à la variable PKEY. Vous pouvez oublier tout le reste tant que le GIT_SSH a été préconfiguré.

Prenez note de la variable PKEY. Vous pouvez utiliser n'importe quel nom tant qu'il correspond à ce qui est utilisé dans le script Shell vers lequel pointe GIT_SSH.

Méthode 2: utilisez un script wrapper

L'utilisation du script wrapper ressemblera à ceci:

$ git.sh -i ~/.ssh/keyfile.pem clone [email protected]:me/repo.git

Cette utilisation est intuitive car elle ressemble à l'exécution de ssh avec l'option -i.

Cela ne nécessite pas de pré-configuration d'un script Shell et de GIT_SSH. Il vous suffit de télécharger et d'exécuter ce script d'encapsuleur unique avec la commande git.

Vous pouvez obtenir une copie de ce script wrapper ici: http://alvinabad.wordpress.com/2013/03/23/how-to-specify-an-ssh-key-file-with-the-git -commande /

28
alvinabad

Une alternative plus simple qui n'implique aucun script externe consiste à utiliser un alias SSH. Je sais que l'affiche originale a spécifiquement demandé de ne pas modifier ~/.ssh/config, mais je soupçonne qu'il y a un malentendu ici.

L'utilisateur local sur le serveur n'est pas le même que la personne qui effectue le commit et peut être une personne différente de celle qui fait le 'git Push'.

  • sur le serveur, le logiciel d'hébergement peut fonctionner en tant qu'utilisateur unique (généralement "git")
  • l'identité de la personne qui effectue la validation n'est que la buisness de git (à ajouter aux métadonnées de validation), n'est pas pertinente pour le serveur et n'est pas soumise à l'authentification sur le serveur
  • l'identité du 'git Push'-er est pertinente et est établie sur les systèmes exécutant le logiciel d'hébergement git sur le serveur en fonction de la clé ssh

Pour cette raison, sur le système faisant le Push on peut forcer une identité spécifique même pour le même compte local et le même serveur distant, même dans le même référentiel git en utilisant un alias ssh en suivant la méthode expliquée ci-dessous.

Supposons que vous ayez sur le serveur gitorious.org votre compte habituel, appelons-le "développeur". Vous ne voulez pas pousser automatiquement en utilisant votre compte "développeur" [1] , donc vous créez un autre compte gitorious pour la synchronisation, appelons-le " robot'.

Pour l'automatisation, seul le compte "robot" sera utilisé:

Étape 1: Ajoutez 'robot' au projet gitorius qui doit être poussé.

Étape 2: Sur la machine locale, créez une clé sans mot de passe (elle sera associée au compte du robot sur gitorious).

ssh-keygen -f ~/.ssh/id_rsa_robot

Étape: téléchargez la clé publique ~/.ssh/id_rsa_robot.pub sur gitorious dans le compte 'robot'.

Étape 4: Les URI git SSH sur gitorious ont le format git @ gitorious.org: prj_or_user/subproject.git . Dans votre fichier ~/.ssh/config, ajoutez les lignes suivantes:

Host robot.gitorious.org
        HostName gitorious.org
        IdentityFile ~/.ssh/id_rsa_robot
        IdentitiesOnly "yes"

Cela garantira que:

  • chaque fois que vous utilisez le nom d'hôte 'robot.gitorious.org', il se connecte à gitorious.org (option HostName),
  • il utilisera la clé sans mot de passe pour s'authentifier en tant que robot sur gitorius.org (option IdentiFile) et
  • même si un agent ssh est en cours d'exécution, il ignorera la clé par défaut et utilisera celle sans mot de passe (IdentiesOnly "yes").

Étape 5: En supposant que l'URI SSH sur gitorious pour votre projet est '[email protected]: project/project.git', dans le référentiel local définissez un nouveau 'autopush' distant avec un hôte légèrement modifié Nom:

git remote add autopush [email protected]:project/project.git

La configuration est terminée, essayez maintenant de pousser vers gitorious via la télécommande 'autopush'.

git Push autopush master

Si tout s'est bien passé et qu'il y a des changements dans Push, vous devriez voir que vous avez réussi à être poussé vers 'gitorious.org' en tant que 'robot'

[1] Pour les push automatiques, une clé sans mot de passe doit être générée pour le compte, mais l'attacher au compte "développeur" gitieux signifierait que le travail automatisé peut pousser vers n'importe quel projet gitourious où 'développeur' est impliqué sur gitorious.

3
user4110936