Wie kann man alle Repos auf einmal aus GitHub klonen?

Bei Windows und allen UNIX/LINUX -Systemen mit Git Bash oder jedem anderen Terminal ersetzen Sie YOURUSERNAME durch Ihren Benutzernamen und verwenden Sie:

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

Legen Sie CNTX=users und NAME=yourusername fest, um alle Repositorys herunterzuladen. Legen Sie CNTX = orgs und NAME = yourorgname fest, um alle Repositorys Ihrer Organisation herunterzuladen.

Die maximale Seitengröße beträgt 100, daher müssen Sie dies mehrmals mit der richtigen Seitennummer aufrufen, um alle Repositorys zu erhalten (setzen Sie PAGE auf die gewünschte Seitennummer, die Sie herunterladen möchten).

Hier ist ein Shell-Skript, das die oben genannten Funktionen ausführt: https://Gist.github.com/erdincay/4f1d2e092c50e78ae1ffa39d13fa404e

Organisationsspeicher

Um alle Repos aus Ihrer Organisation zu klonen, versuchen Sie den folgenden Shell-Einzeiler:

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

Benutzer-Repositories

Alle mit Hilfe des Git-Repository-URLs klonen:

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

Alle mit Klon-URL klonen:

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

Hier ist die nützliche Shell-Funktion, die den Startdateien des Benutzers hinzugefügt werden kann (mithilfe von 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
}

Private Repositories

Wenn Sie die privaten Repos klonen müssen, können Sie Authorization Token entweder in Ihrem Header hinzufügen:

-H 'Authorization: token <token>'

oder übergeben Sie es im param (?access_token=TOKEN), zum Beispiel:

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

Eine andere Möglichkeit ist die Verwendung von hub nach der Konfiguration des API-Schlüssels.

Überprüfen Sie ein anderes Beispiel hier:

• So laden Sie GitHub Release vom privaten Repo mithilfe der Befehlszeile herunter .

<sup>Hinweise:
- Um die Geschwindigkeit zu erhöhen, stellen Sie die Anzahl der parallelen Prozesse ein, indem Sie den Parameter -P für xargs (-P4 = 4 Prozesse) angeben.
- Wenn Sie die GitHub-Grenzwerte erhöhen möchten, versuchen Sie die Authentifizierung, indem Sie Ihren API-Schlüssel angeben.
- Fügen Sie --recursive hinzu, um in die registrierten Submodule zu rekursieren, und aktualisieren Sie alle darin geschachtelten Submodule.</sup>

This Gist erledigt die Aufgabe in einer Zeile in der Kommandozeile:

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"]} ]}'

Ersetzen Sie [your_org] durch den Namen Ihrer Organisation. Und legen Sie ggf. Ihren per_page fest.

UPDATE:

Wie ATutorMe erwähnt, beträgt die maximale Seitengröße 100, gemäß den GitHub-Dokumenten .

Wenn Sie mehr als 100 Repos haben, müssen Sie Ihrer URL einen page-Parameter hinzufügen und Sie können den Befehl für jede Seite ausführen.

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"]} ]}'

Hinweis: Der Standardparameter per_page ist 30.

Gehen Sie zu Kontoeinstellungen -> Anwendung und erstellen Sie einen API-Schlüssel
.__ Fügen Sie anschließend den API-Schlüssel, die github-Instanz-URL und den Organisationsnamen in das nachstehende Skript ein

#!/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"]} ]}'

Speichern Sie das in einer Datei, chmod u+x die Datei, und führen Sie sie aus.

_{Dank an Arnaud für den Ruby-Code.}

Ich fand einen Kommentar in the Gist @seancdavis als sehr hilfreich, vor allem, weil ich, wie das Originalposter, alle Repos für einen schnellen Zugriff synchronisieren wollte, wobei die große Mehrheit jedoch privat war.

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"]} ]}'

Ersetzen Sie [[USERNAME]] durch Ihren Github-Benutzernamen und [[ORGANIZATION]] durch Ihre Github-Organisation. Die Ausgabe (JSON-Repo-Metadaten) wird an ein einfaches Ruby-Skript übergeben:

# 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

Ich habe ein Skript mit Python3 und Github APIv3 erstellt

https://github.com/muhasturk/gitim

Renn einfach

./gitim

Ich habe einige der oben genannten Befehle und Tools ausprobiert, aber festgestellt, dass sie zu umständlich sind. Deshalb habe ich ein anderes Befehlszeilen-Tool namens github-dl geschrieben.

Verwendung (vorausgesetzt, Sie haben nodejs installiert)

_npx github-dl -d /tmp/test wires
_

Dies würde eine Liste aller Repos von wires abrufen und Informationen in das Verzeichnis test schreiben, wobei die Autorisierungsdetails (Benutzer/Pass) verwendet werden, die Sie in der CLI angeben.

Im Detail ist es

1. Fragt nach Authentifizierung (unterstützt 2FA)
2. Ruft eine Liste der Repos für Benutzer/Organisationen über die Github-API ab
3. Hat Paginierung dafür, so dass mehr als 100 Repos unterstützt werden

Es klont die Repos nicht wirklich, sondern schreibt stattdessen eine _.txt_ -Datei, die Sie an xargs übergeben können, um das Klonen durchzuführen. Beispiel:

_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
_

Vielleicht ist das nützlich für Sie; es sind nur ein paar Zeilen von JS, daher sollte es einfach sein, sich an Ihre Bedürfnisse anzupassen

Also werde ich auch meine Antwort hinzufügen. :) (Ich fand es einfach)

Abrufliste (ich habe "Magento" verwendet):

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

Verwenden Sie clone_url statt ssh_url, um den HTTP-Zugriff zu verwenden.

Also lass uns alle klonen! :)

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

Wenn Sie private Repos abrufen möchten, fügen Sie einfach den GET-Parameter ?access_token=YOURTOKEN hinzu.

Dieser Python One-Liner wird das tun, was Sie brauchen. Es:

• prüft github auf verfügbare Repos

• ruft für jeden einen Systemaufruf an git clone auf

  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'))]"
  

Ich habe dazu ein Pip-Modul erstellt. Funktioniert unter Windows, Linux und OSX. 

https://github.com/zeusofjuice/starclone

Kann Ihre Repos klonen, indem Sie Folgendes verwenden:

starclone <user> 

Es gibt einige Flags, die Sie in der Hilfedatei oder in der Readme-Datei angeben können. 

Falls jemand nach einer Windows-Lösung sucht, gibt es hier eine kleine Funktion in PowerShell, um den Trick auszuführen (dies könnte ein Alias ​​sein, wenn nicht die Tatsache, dass ich es brauche, um sowohl mit als auch ohne Proxy zu arbeiten).

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() }
}

Wenn Sie also in der Praxis alle Repos aus der Organisation FOO klonen möchten, die mit BAR übereinstimmen, können Sie den folgenden Einzeiler verwenden, der jq und die üblichen Cli-Dienstprogramme erfordert

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

Es gibt auch ein sehr nützliches npm-Modul , um dies zu tun. Sie kann nicht nur klonen, sondern auch ziehen (um bereits vorhandene Daten zu aktualisieren).

Sie erstellen einfach eine Konfiguration wie folgt:

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

und gitall clone zum Beispiel. Oder gitall pull

Wenn Sie eine Liste von Repositorys in einer solchen Liste haben, funktioniert dieses Shell-Skript:

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

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

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

do

   echo $user"$i"

   git clone $user"$i"

done 

Sie können eine Liste der Repositorys abrufen, indem Sie curl verwenden, und dann diese Liste mit einer Bash-Schleife durchlaufen:

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

Sie können das Open-Source-Tool verwenden, um mehrere Github-Repositorys zu klonen: https://github.com/artiomn/git_cloner

Beispiel:

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

Verwenden Sie die JSON-API von api.github.com. Sie finden das Codebeispiel in der github-Dokumentation: https://developer.github.com/v3/

Oder dort:

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

Einfache Lösung:

NUM_REPOS=1000
DW_FOLDER="Github_${NUM_REPOS}_repos"
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

Um nur private Repos zu klonen, die über einen Zugriffsschlüssel verfügen und das Modul Python 3 und Requests installiert ist:

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;

Eine Python3-Lösung mit umfassender Paginierung über Link Header.

Voraussetzungen:

• Github-API "Persönlicher Zugriffstoken"
• pip3 install links-from-link-header
• hub

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])

Dann können Sie xargs oder parallel und: cat repolist | parallel -I% hub clone % verwenden.

Die vorherrschenden Antworten hier berücksichtigen nicht, dass die Github-API trotz der in per_page angegebenen Werte nur maximal 100 Repositorys zurückgibt. Wenn Sie eine Github-Organisation mit mehr als 100 Repositorys klonen, müssen Sie den Paging-Links in der API-Antwort folgen.

Ich schrieb ein CLI-Tool, um genau das zu tun :

clone-github-org -o myorg

Dadurch werden alle Repositorys in der Organisation myorg in das aktuelle Arbeitsverzeichnis geklont.

Ich habe ein Beispielstapelskript erstellt. Sie können alle privaten/öffentlichen Repositories von github.com herunterladen. Nachdem ein Repository heruntergeladen wurde, wird es automatisch in eine ZIP-Datei konvertiert.

@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 ..
)

Hinweis:files.txt-Datei sollte nur Repository-Namen enthalten wie: 

repository1
repository2

Update vom 19. Mai

benutze diesen bash Befehl für eine Organisation (privates Repo inklusive)

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

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

Ein weiteres Shell-Skript mit Kommentaren, die alle Repositorys (öffentlich und privat) eines Benutzers klonen:

#!/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