J'ai un compte GitHub d'entreprise et je souhaite sauvegarder tous les référentiels qu'il contient, en tenant compte de tout ce qui pourrait être créé à des fins d'automatisation. J'espérais quelque chose comme ça:

git clone git@github.com:company/*.git 

ou similaire fonctionnerait, mais il ne semble pas aimer le caractère générique.

Existe-t-il un moyen dans Git de cloner puis de tout extraire en supposant que l'on dispose des autorisations appropriées?

Je ne pense pas qu'il soit possible de le faire de cette façon. Votre meilleur pari est de trouver et de parcourir une liste des référentiels d'une organisation à l'aide de l'API.

Essaye ça:

• Créez un jeton API en allant dans Paramètres du compte -> Applications
• Appelez: http://${GITHUB_BASE_URL}/api/v3/orgs/${ORG_NAME}/repos?access_token=${ACCESS_TOKEN}
• La réponse sera un tableau d'objets JSON. Chaque objet comprendra des informations sur l'un des référentiels de cette organisation. Je pense que dans votre cas, vous chercherez spécifiquement la ssh_urlpropriété.
• Ensuite, git clonechacun de ces ssh_urlart.

C'est un peu de travail supplémentaire, mais il est nécessaire que GitHub ait une authentification appropriée.

Sous Windows et tous les systèmes UNIX / LINUX , en utilisant Git Bash ou tout autre terminal , remplacez-le YOURUSERNAMEpar votre nom d'utilisateur et utilisez:

CNTX={users|orgs}; NAME={username|orgname}; PAGE=1
curl "https://api.github.com/$CNTX/$NAME/repos?page=$PAGE&per_page=100" |
  grep -e 'git_url*' |
  cut -d \" -f 4 |
  xargs -L1 git clone

• Définissez CNTX=userset NAME=yourusername, pour télécharger tous vos référentiels.
• Définissez CNTX=orgset NAME=yourorgname, pour télécharger tous les référentiels de votre organisation.

La taille de page maximale est de 100, vous devez donc l'appeler plusieurs fois avec le bon numéro de page pour obtenir tous vos référentiels (définis PAGEsur le numéro de page souhaité que vous souhaitez télécharger).

Voici un script shell qui fait ce qui précède: https://gist.github.com/erdincay/4f1d2e092c50e78ae1ffa39d13fa404e

Référentiels d'organisation

Pour cloner tous les dépôts de votre organisation, essayez le shell one-liner suivant:

GHORG=company; curl "https://api.github.com/orgs/$GHORG/repos?per_page=1000" | grep -o 'git@[^"]*' | xargs -L1 git clone

Référentiels d'utilisateurs

Cloner tout à l'aide des URL de référentiel Git:

GHUSER=CHANGEME; curl "https://api.github.com/users/$GHUSER/repos?per_page=1000" | grep -o 'git@[^"]*' | xargs -L1 git clone

Cloner tout en utilisant l'URL de clonage:

GHUSER=CHANGEME; curl "https://api.github.com/users/$GHUSER/repos?per_page=1000" | grep -w clone_url | grep -o '[^"]\+://.\+.git' | xargs -L1 git clone

Voici la fonction shell utile qui peut être ajoutée aux fichiers de démarrage de l'utilisateur (en utilisant curl+ jq):

# Usage: gh-clone-user (user)
gh-clone-user() {
  curl -sL "https://api.github.com/users/$1/repos?per_page=1000" | jq -r '.[]|.clone_url' | xargs -L1 git clone
}

Dépôts privés

Si vous avez besoin de cloner les dépôts privés, vous pouvez ajouter un jeton d'autorisation dans votre en-tête comme:

-H 'Authorization: token <token>'

ou passez-le dans le param ( ?access_token=TOKEN), par exemple:

curl -s "https://api.github.com/users/$GHUSER/repos?access_token=$GITHUB_API_TOKEN&per_page=1000" | grep -w clone_url | grep -o '[^"]\+://.\+.git' | xargs -L1 git clone

Remarques:

• Pour récupérer uniquement les référentiels privés, ajoutez-les type=privateà votre chaîne de requête.
• Une autre façon consiste à utiliser hubaprès avoir configuré votre clé API.

Voir également:

• API REST GitHub v3 - Répertoriez vos référentiels
• Comment télécharger GitHub Release à partir d'un dépôt privé en utilisant la ligne de commande .
• Comment récupérer la liste de tous les référentiels github d'une personne? .

<sup>Conseils :
- Pour augmenter la vitesse, définissez le nombre de processus parallèles en spécifiant le -Pparamètre pour xargs( -P4= 4 processus).
- Si vous devez augmenter les limites de GitHub, essayez de vous authentifier en spécifiant votre clé API.
- Ajouter --recursivepour récurer dans les sous-modules enregistrés et mettre à jour tous les sous-modules imbriqués à l'intérieur.</sup>

Cet élément essentiel accomplit la tâche en une seule ligne sur la ligne de commande:

curl -s https://api.github.com/orgs/[your_org]/repos?per_page=200 | ruby -rubygems -e 'require "json"; JSON.load(STDIN.read).each { |repo| %x[git clone #{repo["ssh_url"]} ]}'

Remplacez [your_org]par le nom de votre organisation. Et définissez votre per_pagesi nécessaire.

METTRE À JOUR:

Comme l'a mentionné ATutorMe, la taille maximale de la page est de 100, selon la documentation GitHub .

Si vous avez plus de 100 dépôts, vous devrez ajouter un pageparamètre à votre URL et vous pourrez exécuter la commande pour chaque page.

curl -s "https://api.github.com/orgs/[your_org]/repos?page=2&per_page=100" | ruby -rubygems -e 'require "json"; JSON.load(STDIN.read).each { |repo| %x[git clone #{repo["ssh_url"]} ]}'

Remarque: le per_pageparamètre par défaut est 30.

Allez dans Paramètres du compte -> Application et créez une clé API,
puis insérez la clé API, l'URL de l'instance github et le nom de l'organisation dans le script ci-dessous

#!/bin/bash

# Substitute variables here
ORG_NAME="<ORG NAME>"
ACCESS_TOKEN="<API KEY>"
GITHUB_INSTANCE="<GITHUB INSTANCE>

URL="https://${GITHUB_INSTANCE}/api/v3/orgs/${ORG_NAME}/repos?access_token=${ACCESS_TOKEN}"

curl ${URL} | ruby -rjson -e 'JSON.load(STDIN.read).each {|repo| %x[git clone #{repo["ssh_url"]} ]}'

Enregistrez-le dans un fichier, chmod u+xle fichier, puis exécutez-le.

_{Merci à Arnaud pour le code ruby.}

Alors, j'ajouterai ma réponse aussi. :) (j'ai trouvé que c'est simple)

Récupérer la liste (j'ai utilisé la société "magento"):

curl -si https://api.github.com/users/magento/repos | grep ssh_url | cut -d '"' -f4

Utilisez à la clone_urlplace ssh_urlpour utiliser l'accès HTTP.

Alors, clonons-les tous! :)

curl -si https://api.github.com/users/magento/repos | \
    grep ssh_url | cut -d '"' -f4 | xargs -i git clone {}

Si vous allez récupérer des dépôts privés, ajoutez simplement le paramètre GET ?access_token=YOURTOKEN

J'ai trouvé un commentaire dans le gist @seancdavis fourni pour être très utile, surtout parce que, comme l'affiche originale, je voulais synchroniser tous les dépôts pour un accès rapide, mais la grande majorité d'entre eux étaient privés.

curl -u [[USERNAME]] -s https://api.github.com/orgs/[[ORGANIZATION]]/repos?per_page=200 |
  ruby -rubygems -e 'require "json"; JSON.load(STDIN.read).each { |repo| %x[git clone #{repo["ssh_url"]} ]}'

Remplacez [[USERNAME]] par votre nom d'utilisateur Github et [[ORGANIZATION]] par votre organisation Github. La sortie (métadonnées du référentiel JSON) sera transmise à un simple script ruby:

# bring in the Ruby json library
require "json"

# read from STDIN, parse into ruby Hash and iterate over each repo
JSON.load(STDIN.read).each do |repo|
  # run a system command (re: "%x") of the style "git clone <ssh_url>"
  %x[git clone #{repo["ssh_url"]} ]
end

J'ai fait un script avec Python3 et Github APIv3

https://github.com/muhasturk/gitim

Courez juste

./gitim

Ce one-liner en python fera ce dont vous avez besoin. Il:

• vérifie github vos dépôts disponibles

• pour chacun, effectue un appel système à git clone

  python -c "import json, urllib, os; [os.system('git clone ' + r['ssh_url']) for r in json.load(urllib.urlopen('https://api.github.com/orgs/<<ORG_NAME>>/repos?per_page=200'))]"
  

curl -s https://api.github.com/orgs/[GITHUBORG_NAME]/repos | grep clone_url | awk -F '":' '{ print $2 }' | sed 's/\"//g' | sed 's/,//' | while read line; do git clone "$line"; done

Solution simple:

NUM_REPOS=1000
DW_FOLDER="Github_${NUM_REPOS}_repos"
mkdir ${DW_FOLDER}
cd ${DW_FOLDER}
for REPO in $(curl https://api.github.com/users/${GITHUB_USER}/repos?per_page=${NUM_REPOS} | awk '/ssh_url/{print $2}' | sed 's/^"//g' | sed 's/",$//g') ; do git clone ${REPO} ; done

J'ai essayé quelques-unes des commandes et des outils ci-dessus, mais j'ai décidé qu'ils étaient trop compliqués, alors j'ai écrit un autre outil de ligne de commande pour ce faire, appelé github-dl.

Pour l'utiliser (en supposant que vous ayez installé nodejs)

npx github-dl -d /tmp/test wires

Cela obtiendrait une liste de tous les dépôts à partir de wireset écrirait des informations dans le testrépertoire, en utilisant les détails d'autorisation (utilisateur / pass) que vous fournissez sur la CLI.

En détail, il

1. Demande d'authentification (prend en charge 2FA)
2. Obtient la liste des dépôts pour l'utilisateur / l'organisation via l'API Github
3. Est-ce que la pagination pour cela, donc plus de 100 repo pris en charge

Il ne clone pas réellement les dépôts, mais écrit plutôt un .txtfichier dans lequel vous pouvez passer xargspour faire le clonage, par exemple:

cd /tmp/test
cat wires-repo-urls.txt | xargs -n2 git clone

# or to pull
cat /tmp/test/wires-repo-urls.txt | xargs -n2 git pull

Peut-être que cela vous est utile; il ne s'agit que de quelques lignes de JS, il devrait donc être facile de s'adapter à vos besoins

Il existe également un module npm très utile pour ce faire. Il peut non seulement cloner, mais également extraire (pour mettre à jour les données que vous avez déjà).

Vous créez simplement une configuration comme celle-ci:

[{
   "username": "BoyCook",
   "dir": "/Users/boycook/code/boycook",
   "protocol": "ssh"
}]

et faites gitall clonepar exemple. Ougitall pull

Au cas où quelqu'un chercherait une solution Windows, voici une petite fonction dans PowerShell pour faire l'affaire (pourrait être oneliner / alias sinon le fait que j'en ai besoin pour fonctionner avec et sans proxy).

function Unj-GitCloneAllBy($User, $Proxy = $null) {
    (curl -Proxy $Proxy "https://api.github.com/users/$User/repos?page=1&per_page=100").Content 
      | ConvertFrom-Json 
      | %{ $_.clone_url } 
      # workaround git printing to stderr by @wekempf aka William Kempf
      # https://github.com/dahlbyk/posh-git/issues/109#issuecomment-21638678
      | %{ & git clone $_ 2>&1 } 
      | % { $_.ToString() }
}

Donc, en pratique, si vous souhaitez cloner tous les dépôts de l'organisation FOOqui correspondent BAR, vous pouvez utiliser le one-liner ci-dessous, qui nécessite jq et les utilitaires cli communs

curl 'https://api.github.com/orgs/FOO/repos?access_token=SECRET' |
  jq '.[] |
  .ssh_url' |
  awk '/BAR/ {print "git clone " $0 " & "}' |
  sh

Un autre script shell avec des commentaires qui clone tous les référentiels (publics et privés) d'un utilisateur:

#!/bin/bash

USERNAME=INSERT_USERNAME_HERE
PASSWORD=INSERT_PASSWORD_HERE

# Generate auth header
AUTH=$(echo -n $USERNAME:$PASSWORD | base64)

# Get repository URLs
curl -iH "Authorization: Basic "$AUTH https://api.github.com/user/repos | grep -w clone_url > repos.txt

# Clean URLs (remove " and ,) and print only the second column
cat repos.txt | tr -d \"\, | awk '{print $2}'  > repos_clean.txt

# Insert username:password after protocol:// to generate clone URLs
cat repos_clean.txt |  sed "s/:\/\/git/:\/\/$USERNAME\:$PASSWORD\@git/g" > repos_clone.txt

while read FILE; do
    git clone $FILE
done <repos_clone.txt

rm repos.txt & rm repos_clone.txt

Créez un alias / func bash dans votre ~/.bashrc file

J'ai résolu ce problème pour mon équipe en créant une fonction alias / bash dans mon ~/.bashrc file

pas

ouvrez un terminal ou un shell Linux et ouvrez votre ~/.bashrc file:

sudo nano ~/.bashrc

ajoutez cette fonction:

CloneAll() {
    # Make the url to the input github organization's repository page.
    ORG_URL="https://api.github.com/orgs/${1}/repos?per_page=200";

    # List of all repositories of that organization (seperated by newline-eol).
    ALL_REPOS=$(curl -s ${ORG_URL} | grep html_url | awk 'NR%2 == 0' \
                | cut -d ':' -f 2-3 | tr -d '",');

    # Clone all the repositories.
    for ORG_REPO in ${ALL_REPOS}; do
        git clone ${ORG_REPO}.git;
    done
}

enregistrez et fermez votre fichier ~ / .bashrc puis fermez le terminal - vous devez faire ceci ou la nouvelle fonction ne s'initialise pas:

ouvrez un nouveau terminal et essayez-le:

CloneAll <your_github_org_name>

exemple : si votre URL de dépôt github personnelle s'appelle https://github.com/awesome-async, la commande serait

CloneAll awesome-async

Important

le per_page=200à la fin de la première variable ORG_URLdéfinit le nombre de dépôts qui seront clonés, alors faites particulièrement attention à cela:

ORG_URL="https://api.github.com/orgs/${1}/repos?per_page=200";  <---- make sure this is what you want

J'espère que cela t'aides! :)

Vous pouvez obtenir une liste des référentiels en utilisant curl, puis itérer sur ladite liste avec une boucle bash:

GIT_REPOS=`curl -s curl https://${GITHUB_BASE_URL}/api/v3/orgs/${ORG_NAME}/repos?access_token=${ACCESS_TOKEN} | grep ssh_url | awk -F': ' '{print $2}' | sed -e 's/",//g' | sed -e 's/"//g'`
for REPO in $GIT_REPOS; do
  git clone $REPO
done

Vous pouvez utiliser un outil open source pour cloner un tas de référentiels github: https://github.com/artiomn/git_cloner

Exemple:

git_cloner --type github --owner octocat --login user --password user https://my_bitbucket

Utilisez l'API JSON de api.github.com. Vous pouvez voir l'exemple de code dans la documentation de github: https://developer.github.com/v3/

Ou là:

https://github.com/artiomn/git_cloner/blob/master/src/git_cloner/github.py

Pour cloner uniquement les dépôts privés, avec une clé d'accès, et avec python 3 et le module de requêtes installé:

ORG=company; ACCESS_KEY=0000000000000000000000000000000000000000; for i in $(python -c "import requests; print(' '.join([x['ssh_url'] for x in list(filter(lambda x: x['private'] ,requests.get('https://api.github.com/orgs/$ORG/repos?per_page=1000&access_token=$ACCESS_KEY').json()))]))"); do git clone $i; done;

Une solution Python3 qui inclut une pagination exhaustive via LinkHeader.

Conditions préalables:

• "Jeton d'accès personnel" de l' API Github
• pip3 install links-from-link-header
• centre

import json
import requests
from requests.auth import HTTPBasicAuth
import links_from_header

respget = lambda url: requests.get(url, auth=HTTPBasicAuth('githubusername', 'githubtoken'))

myorgname = 'abc'
nexturl = f"https://api.github.com/orgs/{myorgname}/repos?per_page=100"

while nexturl:
    print(nexturl)
    resp = respget(nexturl)

    linkheads = resp.headers.get('Link', None)
    if linkheads:
        linkheads_parsed = links_from_header.extract(linkheads)
        nexturl = linkheads_parsed.get('next', None)
    else:
        nexturl = None

    respcon = json.loads(resp.content)
    with open('repolist', 'a') as fh:
        fh.writelines([f'{respconi["full_name"]}\n' for respconi in respcon])

Ensuite, vous pouvez utiliser xargsou parallèle et:cat repolist | parallel -I% hub clone %

Si vous avez une liste de référentiels dans une liste comme celle-ci, alors ce script shell fonctionne:

user="https://github.com/user/"

declare -a arr=("repo1", "repo2")

for i in "${arr[@]}"

do

   echo $user"$i"

   git clone $user"$i"

done 

J'ai créé un exemple de script batch. Vous pouvez télécharger tous les référentiels privés / publics depuis github.com. Une fois le référentiel téléchargé, il est automatiquement converti en fichier zip.

@echo off
setlocal EnableDelayedExpansion
SET "username=olyanren"
SET "password=G....."
set "mypath=%cd%\"
SET "url=https://%username%:%password%@github.com/%username%/"
FOR /F "tokens=* delims=" %%i in (files.txt) do (
SET repo=%%i
rmdir /s /q !repo!
git clone "!url!!repo!.git"
cd !repo!
echo !mypath!
git archive --format=zip -o "!mypath!!repo!.zip" HEAD
cd ..
)

Remarque: le fichier files.txt ne doit contenir que des noms de référentiel tels que:

repository1
repository2

Mise à jour du 19 mai

utiliser cette commande bash pour une organisation (dépôt privé inclus)

curl -u "{username}" "https://api.github.com/orgs/{org}/repos?page=1&per_page=100" | grep -o 'git@[^"]*' | xargs -L1 git clone

Les réponses prédominantes ici ne tiennent pas compte du fait que l'API Github ne renverra qu'un maximum de 100 référentiels malgré ce que vous pouvez spécifier dans per_page. Si vous clonez une organisation Github avec plus de 100 référentiels, vous devrez suivre les liens de pagination dans la réponse de l'API.

J'ai écrit un outil CLI pour faire exactement cela :

clone-github-org -o myorg

Cela clonera tous les référentiels de l' myorgorganisation dans le répertoire de travail actuel.

Pour les organisations auxquelles vous avez accès avec des dépôts privés:

curl -u <YOUR_GITHUB_USERNAME> -s https://api.github.com/orgs/<ORG_NAME>/repos?per_page=200 | ruby -rubygems -e ’require “json”; JSON.load(STDIN.read).each { |repo| %x[git clone #{repo[“html_url”]} ]}'

Il utilise le html_url, donc vous n'avez pas besoin d' access_tokenentrer simplement votre mot de passe github lorsque vous y êtes invité.

Clonez tous vos dépôts qui ne sont pas des fourchettes:

curl -u "username" https://api.github.com/user/repos\?page\=1\&per_page\=100 |
  jq -r 'map(select(.fork == false)) | .[] | .ssh_url' |
  xargs -L1 git clone

Clonez vos informations essentielles:

curl https://api.github.com/users/username/gists\?page\=1\&per_page\=100 |
   jq -r ".[] | .git_pull_url +\" '\" + (.files|keys|join(\"__\") + \"'\")" |
   xargs -L1 git clone

Cette jqcommande est complexe car le nom du dépôt de gists est un hachage, de sorte que la commande concatène tous les noms de fichiers pour être le nom du dépôt

Vous pouvez filtrer le JSON arbitrairement en utilisant jq

installer: sudo apt-get install jq

Dans l'exemple ci-dessus, j'ai filtré les fourchettes en utilisant ceci: curl ... | jq -r 'map(select(.fork == false))' ...- utile pour ne pas cloner des dépôts où vous avez fait des demandes d'extraction occasionnelles

jq prend en charge certaines fonctionnalités très avancées. man jqest votre ami

Vous pouvez vous authentifier avec curl -u "username" ... pour accéder aux dépôts privés

URL d'API de Guthub

• Vos dépôts (nécessite une authentification): https://api.github.com/user/repos\?page\=1\&per_page\=100
• Tout utilisateur: https://api.github.com/users/other_username/repos\?page\=1\&per_page\=100
• Organisations: https://api.github.com/orgs/orgname/repos\?page\=1\&per_page\=100

Documents de l'API Github pour les dépôts

"""
Clone all public Github Repos

https://developer.github.com/v3/repos/#list-repositories-for-a-user
"""

import urllib.request, base64
import json
import os


def get_urls(username):
    url = f"https://api.github.com/users/{username}/repos?per_page=200"
    request = urllib.request.Request(url)
    result = urllib.request.urlopen(request)
    return json.load(result)


if __name__ == "__main__":
    for r in get_urls("MartinThoma"):
        if not os.path.isdir(r["name"]):
            print(f"Clone {r['name']}...")
            os.system("git clone " + r["ssh_url"])
        else:
            print(f"SKIP {r['name']}...")

Pour cloner tous vos propres dépôts privés et publics, générez simplement un nouveau jeton d'accès avec un accès aux dépôts et utilisez ceci:

(remplacez-le par votre propre jeton d'accès et nom d'utilisateur)

for line in $(curl https://api.github.com/user/repos?access_token=ACCESS_TOKEN_HERE  | grep -o "git@github.com:YOUR_USER_NAME/[^ ,\"]\+");do git clone $line;done

Cela clonera tous les dépôts dans le dossier actuel

Ceci est un petit programme bash, vous pouvez simplement le coller dans le terminal et appuyer sur Entrée