Ho un account GitHub aziendale e desidero eseguire il backup di tutti i repository all'interno, tenendo conto di tutto ciò che potrebbe essere creato per scopi di automazione. Speravo qualcosa del genere:

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

o simili funzionerebbero, ma non sembra gradire il carattere jolly.

C'è un modo in Git per clonare e poi estrarre tutto supponendo che uno abbia le autorizzazioni appropriate?

Non credo sia possibile farlo in questo modo. La soluzione migliore è trovare e scorrere un elenco di repository di un'organizzazione utilizzando l'API.

Prova questo:

• Crea un token API andando su Impostazioni account -> Applicazioni
• Chiama a: http://${GITHUB_BASE_URL}/api/v3/orgs/${ORG_NAME}/repos?access_token=${ACCESS_TOKEN}
• La risposta sarà una matrice JSON di oggetti. Ogni oggetto includerà informazioni su uno dei repository di quell'organizzazione. Penso che nel tuo caso cercherai specificamente la ssh_urlproprietà.
• Quindi git cloneognuno di quei ssh_urls.

È un po 'di lavoro extra, ma è necessario che GitHub disponga di un'autenticazione adeguata.

Su Windows e tutti i sistemi UNIX / LINUX , utilizzando Git Bash o qualsiasi altro terminale , sostituisci YOURUSERNAMEcon il tuo nome utente e usa:

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

• Imposta CNTX=userse NAME=yourusername, per scaricare tutti i tuoi repository.
• Imposta CNTX=orgse NAME=yourorgname, per scaricare tutti i repository della tua organizzazione.

La dimensione massima della pagina è 100, quindi devi chiamarla più volte con il numero di pagina corretto per ottenere tutti i tuoi repository (impostati PAGEsul numero di pagina desiderato che desideri scaricare).

Ecco uno script di shell che fa quanto sopra: https://gist.github.com/erdincay/4f1d2e092c50e78ae1ffa39d13fa404e

Repository dell'organizzazione

Per clonare tutti i repository dalla tua organizzazione, prova il seguente one-liner di shell:

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

Repository utente

Clonazione di tutti gli URL del repository Git:

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

Clonare tutto usando Clone URL:

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

Ecco l'utile funzione della shell che può essere aggiunta ai file di avvio dell'utente (usando 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
}

Repository privati

Se devi clonare i repository privati, puoi aggiungere il token di autorizzazione nell'intestazione come:

-H 'Authorization: token <token>'

o passalo nel param ( ?access_token=TOKEN), ad esempio:

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

Appunti:

• Per recuperare solo i repository privati, aggiungili type=privatealla stringa di query.
• Un altro modo è usare hubdopo aver configurato la tua chiave API.

Guarda anche:

• GitHub REST API v3: elenca i tuoi repository
• Come scaricare la versione di GitHub da un repository privato utilizzando la riga di comando .
• Come recuperare l'elenco di tutti i repository GitHub di una persona? .

<sup>Suggerimenti :
- Per aumentare la velocità, impostare il numero di processi paralleli specificando il -Pparametro per xargs( -P4= 4 processi).
- Se devi aumentare i limiti di GitHub, prova ad autenticarti specificando la tua chiave API.
- Aggiungi --recursiveper ricorrere ai sottomoduli registrati e aggiorna eventuali sottomoduli annidati all'interno.</sup>

Questa sintesi esegue l'attività in una riga sulla riga di comando:

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

Sostituisci [your_org]con il nome della tua organizzazione. E imposta il tuo per_pagese necessario.

AGGIORNARE:

Come menzionato da ATutorMe, la dimensione massima della pagina è 100, secondo i documenti di GitHub .

Se hai più di 100 repository, dovrai aggiungere un pageparametro al tuo URL e puoi eseguire il comando per ogni pagina.

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

Nota: il per_pageparametro predefinito è 30.

Vai su Impostazioni account -> Applicazione e crea una chiave API
Quindi inserisci la chiave API, l'URL dell'istanza GitHub e il nome dell'organizzazione nello script sottostante

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

Salvalo in un file, chmod u+xil file, quindi eseguilo.

_{Grazie ad Arnaud per il codice rubino.}

Quindi, aggiungerò anche la mia risposta. :) (ho trovato semplice)

Fetch list (ho usato la compagnia "magento"):

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

Utilizzare clone_urlinvece ssh_urlper utilizzare l'accesso HTTP.

Quindi, cloniamoli tutti! :)

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

Se hai intenzione di recuperare i repository privati, aggiungi semplicemente il parametro GET ?access_token=YOURTOKEN

Ho trovato un commento nella sostanza fornita da @seancdavis per essere molto utile, soprattutto perché, come il poster originale, volevo sincronizzare tutti i repository per un accesso rapido, tuttavia la stragrande maggioranza dei quali era privata.

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

Sostituisci [[USERNAME]] con il tuo nome utente Github e [[ORGANIZATION]] con la tua organizzazione Github. L'output (metadati del repository JSON) verrà passato a un semplice 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

Ho realizzato uno script con Python3 e Github APIv3

https://github.com/muhasturk/gitim

Corri

./gitim

Questo one-liner in pitone farà quello che ti serve. Esso:

• controlla github per i tuoi repository disponibili

• per ciascuno, effettua una chiamata di sistema a 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

Soluzione semplice:

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

Ho provato alcuni dei comandi e degli strumenti sopra, ma ho deciso che erano troppo complicati, quindi ho scritto un altro strumento da riga di comando per farlo, chiamato github-dl.

Per usarlo (supponendo che tu abbia installato nodejs)

npx github-dl -d /tmp/test wires

Questo otterrebbe un elenco di tutti i repository da wirese scriverebbe informazioni nella testdirectory, utilizzando i dettagli di autorizzazione (utente / passaggio) forniti sulla CLI.

In dettaglio, esso

1. Chiede l'autenticazione (supporta 2FA)
2. Ottiene l'elenco dei repository per utente / organizzazione tramite l'API Github
3. Impaginazione per questo, quindi sono supportati più di 100 repository

In realtà non clona i repository, ma scrive invece un .txtfile che puoi passare xargsper eseguire la clonazione, ad esempio:

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

Forse questo ti è utile; sono solo poche righe di JS, quindi dovrebbe essere facile adattarsi alle tue esigenze

C'è anche un modulo npm molto utile per farlo. Non solo può clonare, ma anche estrarre (per aggiornare i dati che hai già).

Devi solo creare una configurazione in questo modo:

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

e fai gitall cloneper esempio. Ogitall pull

Nel caso qualcuno cerchi una soluzione Windows, ecco una piccola funzione in PowerShell per fare il trucco (potrebbe essere oneliner / alias se non il fatto che mi serve per funzionare sia con che senza 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() }
}

Quindi, in pratica, se vuoi clonare tutti i repository dell'organizzazione FOOche corrispondono BAR, puoi usare la riga di seguito, che richiede jq e utilità cli comuni

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

Un altro script di shell con commenti che clona tutti i repository (pubblici e privati) da un utente:

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

Crea un bash alias / func nel tuo file ~/.bashrc file

Ho risolto questo problema per il mio team creando un alias / bash func nel mio file ~/.bashrc file

passi

apri un terminale o una shell di Linux e apri il tuo ~/.bashrc file:

sudo nano ~/.bashrc

aggiungi questa funzione:

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
}

salva e chiudi il tuo ~ / .bashrc flile e poi chiudi il terminale - devi farlo o la nuova funzione non si inizializzerà:

apri un nuovo terminale e provalo:

CloneAll <your_github_org_name>

esempio : se l'URL del repository github personale si chiama https://github.com/awesome-async il comando sarebbe

CloneAll awesome-async

Importante

alla per_page=200fine della prima variabile ORG_URLimposta il numero di pronti contro termine che verranno clonati, in modo da prestare particolare attenzione a quanto segue:

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

Spero che questo ti aiuti! :)

È possibile ottenere un elenco dei repository utilizzando curle quindi iterare su tale elenco con un ciclo 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

Puoi utilizzare uno strumento open source per clonare un gruppo di repository Github: https://github.com/artiomn/git_cloner

Esempio:

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

Utilizza l'API JSON da api.github.com. Puoi vedere l'esempio di codice nella documentazione di github: https://developer.github.com/v3/

Oppure lì:

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

Per clonare solo repository privati, data una chiave di accesso e dato python 3 e modulo delle richieste installato:

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;

Una soluzione Python3 che include l'impaginazione esaustiva tramite LinkHeader.

Prerequisiti:

• API Github "Token di accesso personale"
• pip3 install links-from-link-header
• centro

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

Quindi, puoi usare xargso parallel e:cat repolist | parallel -I% hub clone %

Se hai un elenco di repository in un elenco come questo, allora questo script di shell funziona:

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

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

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

do

   echo $user"$i"

   git clone $user"$i"

done 

Ho creato uno script batch di esempio. Puoi scaricare tutti i repository privati ​​/ pubblici da github.com. Dopo aver scaricato un repository, viene automaticamente convertito in un file 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 ..
)

Nota: il file files.txt dovrebbe contenere solo nomi di repository come:

repository1
repository2

Aggiornamento dal 19 maggio

usa questo comando bash per un'organizzazione (repository privato incluso)

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

Le risposte prevalenti qui non tengono conto del fatto che l'API Github restituirà solo un massimo di 100 repository nonostante ciò che puoi specificare in per_page. Se stai clonando un'organizzazione Github con più di 100 repository, dovrai seguire i link di paging nella risposta API.

Ho scritto uno strumento CLI per fare proprio questo :

clone-github-org -o myorg

Questo clonerà tutti i repository myorgnell'organizzazione nella directory di lavoro corrente.

Per le organizzazioni a cui hai accesso con repository privati:

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

Utilizza il html_url, quindi non è necessario access_tokeninserire la password di GitHub quando richiesto.

Clona tutti i tuoi repository che non sono fork:

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

Clona le tue sintesi:

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

Questo jqcomando è complesso perché i nomi dei repository dei gist sono hash, quindi il comando concatena tutti i nomi dei file in modo che siano il nome del repository

Puoi filtrare il JSON utilizzando arbitrariamente jq

installare: sudo apt-get install jq

Nell'esempio sopra, ho filtrato i fork usando questo: curl ... | jq -r 'map(select(.fork == false))' ...- utile per non clonare i repository in cui hai effettuato richieste pull casuali

jq supporta alcune funzionalità molto avanzate. man jqÈ tuo amico

Puoi autenticarti con curl -u "username" ... per accedere a repository privati

URL API di Guthub

• I tuoi repository (necessita di autenticazione): https://api.github.com/user/repos\?page\=1\&per_page\=100
• Qualsiasi utente: https://api.github.com/users/other_username/repos\?page\=1\&per_page\=100
• Organizzazioni: https://api.github.com/orgs/orgname/repos\?page\=1\&per_page\=100

Documenti dell'API Github per i repository

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

Per clonare tutti i tuoi repository privati ​​e pubblici, genera un nuovo token di accesso con accesso ai repository e usa questo:

(sostituire con il proprio token di accesso e nome utente)

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

Questo clonerà tutti i repository nella cartella corrente

Questo è un piccolo programma bash, puoi semplicemente incollarlo nel terminale e premere invio