Wie verschiebe ich das Git-Repository mit allen Zweigen von Bitbucket nach Github?

334

Was ist der beste Weg, um ein Git-Repository mit allen Zweigen und der vollständigen Historie von Bitbucket auf Github zu verschieben? Gibt es ein Skript oder eine Liste von Befehlen, die ich verwenden muss?

Swalkner
quelle
9
Github stellt Tools und Dokumentation dafür zur Verfügung: help.github.com/articles/… help.github.com/articles/…
mems
Etwas
inblueswithu

Antworten:

393

Sie können auf die GitHub-Seite " Duplizieren eines Repositorys " verweisen "

Es verwendet:

Das würde geben:

git clone --mirror https://bitbucket.org/exampleuser/repository-to-mirror.git
# Make a bare mirrored clone of the repository

cd repository-to-mirror.git
git remote set-url --push origin https://github.com/exampleuser/mirrored
# Set the push location to your mirror

git push --mirror

Wie in den Kommentaren von LS erwähnt :

VonC
quelle
2
Diese Methode hat ein Problem für mich verursacht (nicht sicher, ob es ein Problem ist). Wenn ich das Repo von Bitbucket zu Github gespiegelt habe, wird es für 5 Zweige in Github als "Compare and Pull Request" angezeigt. Es wird nicht als Zweig in Github angezeigt. Was kann ich tun?
Siddharth
2
Und was ist dann mit Themen und Wikis?
Vladislav Rastrusny
@FractalizeR Wiki ist nur ein weiteres Repo, das Sie ebenfalls replizieren können ( github.com/blog/699-making-github-more-open-git-backed-wikis ). Es gibt jedoch keine einfache Möglichkeit, Probleme zu replizieren. Sie müssen die API verwenden (verschiedene GitHub-Repo-Sicherungsprogramme tun genau das: addyosmani.com/blog/backing-up-a-github-account )
VonC
3
Dies funktioniert, wenn Sie ein Repository auch von Github nach Bitbucket verschieben möchten.
Simeg
1
Ich musste diese Methode verwenden, um ein Repo zu kopieren, da es eine große Datei (> 100 MB) enthielt. GH würde keine großen Dateien in ihren Repos zulassen. Ich habe die große Datei entfernt, bevor ich das Repo an GH gesendet habe. Abgesehen von anderen Problemen ist die Verwendung der Funktion " Repository importieren" von GH in 95% der Fälle die richtige Wahl , wie in einer anderen Antwort beschrieben . Wenn dies jedoch fehlschlägt, werden keine hilfreichen Fehlermeldungen angezeigt, und Sie müssen sich an den GH-Support wenden. Es war der GH-Support, der mich über die Einschränkung der Dateigröße informierte.
LS
411

Es ist sehr einfach.

Erstellen Sie ein neues leeres Repository in GitHub (ohne Readme oder Licesne können Sie diese vorher hinzufügen) und der folgende Bildschirm wird angezeigt

Um die Code- Option zu importieren , fügen Sie das Repo und die Voilà Ihrer Bitbucket-URL ein !!

Klicken Sie in den Importcode

MarMass
quelle
12
Sie beantworten die Frage hier wirklich, da die akzeptierte Antwort nur eine generische Git-bezogene Methode zeigt. Ihre Antwort ist viel einfacher!
Emile Bergeron
6
Diese Antwort ist gut, solange Sie das Repository erstellen und es ist nackt. Wenn jemand anderes das Repository für Sie erstellt hat (wie der Administrator für die Erstellung von Zweigen), funktioniert dies nicht. Akzeptierte Antwort ist in einem solchen Fall der richtige Weg.
Master.Aurora
4
Wenn Sie über diese Methode nachdenken möchten, entfernen Sie Ihre Zwei-Faktor-Authentifizierung auf Ihrem vorherigen Repository-Host, bevor Sie diesen Dienst verwenden. Andernfalls stecken Sie in einer Endlosschleife beim Versuch, das neu erstellte Repository in GitHub zu entfernen Der einzige Weg, um daraus herauszukommen, besteht darin, die /importam Ende der URL zu ersetzen, um auf /settingsdie Einstellungen zuzugreifen und sie zu entfernen.
Dave
1
Kleine Einschränkung - Wenn Sie auf ein Problem stoßen, wird keine beschreibende Fehlermeldung angezeigt.
RobertH
In 95% der Fälle ist die Verwendung der GH-Funktion " Repository importieren " die richtige Wahl . Wenn dies jedoch fehlschlägt, werden keine hilfreichen Fehlermeldungen angezeigt, und Sie müssen sich an den GH-Support wenden. Ich konnte es nicht für ein Repo verwenden, da es eine große Datei (> 100 MB) enthielt. Ich musste die akzeptierte CLI-Methode verwenden und die große Datei entfernen, bevor ich das Repo an GH weiterleitete.
LS
125

Falls Sie die Schaltfläche "Code importieren" auf github nicht finden konnten, können Sie:

  1. Öffnen Sie direkt den Github Importer und geben Sie den einurl . Es wird so aussehen:Screenshot des Github-Importeurs
  2. Gib ihm einen Namen (oder er importiert den Namen automatisch)
  3. auswählen Publicoder Privaterepo
  4. Klicken Begin Import

UPDATE: Vor kurzem hat Github die Möglichkeit angekündigt, " Repositorys mit großen Dateien zu importieren ".

biniam
quelle
Leider hat dies bei meinem Versuch, von codebasehq zu git-hub zu wechseln, nicht funktioniert. Es wurde die Meldung "Diese URL wird nicht unterstützt" angezeigt. :(
sjmcdowall
@sjmcdowall Entschuldigung, aber ich glaube, es hätte funktionieren sollen, da die Codebasehq-URL auf ein Git-Repository verweist.
Biniam
URL existiert nicht mehr.
Codierter Container
@CodedContainer Ich habe gerade überprüft und es funktioniert. Ich habe gerade den Screenshot aktualisiert.
Biniam
1
Die URL gibt nur dann einen 404 zurück, wenn Sie nicht bei GitHub angemeldet sind. Wenn Sie angemeldet sind, wird das Import-Tool geladen.
Jason Hurt
41

http://www.blackdogfoundry.com/blog/moving-repository-from-bitbucket-to-github/

Dies hat mir geholfen, von einem Git-Anbieter zu einem anderen zu wechseln. Am Ende befanden sich alle Commits im Ziel-Git. Einfach und unkompliziert.

git remote rename origin bitbucket
git remote add origin https://github.com/edwardaux/Pipelines.git
git push origin master

Sobald ich froh war, dass der Push für GitHub erfolgreich war, konnte ich die alte Fernbedienung löschen, indem ich Folgendes ausgab:

git remote rm bitbucket
Rettel
quelle
2
Bitte fügen Sie die relevanten Teile eines Links in Ihre Antwort ein, da dieser für sich allein stehen sollte.
k0pernikus
Ich erhalte die Fehlermeldung "Fehler: Einige Refs konnten nicht an ' url.gi ' gesendet werden. Hinweis: Aktualisierungen wurden abgelehnt, da die Fernbedienung Arbeit enthält, die Sie nicht lokal haben. Dies wird normalerweise durch ein anderes Repository verursacht, das auf dieselbe Refs pusht . Möglicherweise möchten Sie zuerst die Remote-Änderungen (z. B. Pull ...) integrieren, bevor Sie erneut drücken. Weitere Informationen finden Sie im Hinweis zum Schnellvorlauf in git push --help.
Codierter Container
1
Dies ist die einzige Antwort, die noch am 03.03.2019 funktioniert :)
Wang-Zhao-Liu QM
13

Ich hatte den umgekehrten Anwendungsfall, ein vorhandenes Repository von Github in Bitbucket zu importieren.

Bitbucket bietet ein Import-Tool . Der einzige notwendige Schritt ist das Hinzufügen einer URL zum Repository.

Es sieht aus wie:

Screenshot des Bitbucket-Import-Tools

k0pernikus
quelle
5

Mir ist klar, dass dies eine alte Frage ist. Ich fand es vor einigen Monaten, als ich versuchte, dasselbe zu tun, und war von den gegebenen Antworten überwältigt. Sie alle schienen sich mit dem Import von Bitbucket in GitHub nacheinander zu befassen, entweder über Befehle à la carte oder über den GitHub-Importer.

Ich grabulated den Code aus einem GitHub Projekt namens gitter und an meine Bedürfnisse angepasst.

Sie können das Wesentliche teilen oder den Code von hier übernehmen:

#!/usr/bin/env ruby
require 'fileutils'

# Originally  -- Dave Deriso        -- [email protected]
# Contributor -- G. Richard Bellamy -- [email protected]
# If you contribute, put your name here!
# To get your team ID:
# 1. Go to your GitHub profile, select 'Personal Access Tokens', and create an Access token
# 2. curl -H "Authorization: token <very-long-access-token>" https://api.github.com/orgs/<org-name>/teams
# 3. Find the team name, and grabulate the Team ID
# 4. PROFIT!

#----------------------------------------------------------------------
#your particulars
@access_token = ''
@team_id = ''
@org = ''


#----------------------------------------------------------------------
#the verison of this app
@version = "0.2"

#----------------------------------------------------------------------
#some global params
@create = false
@add = false
@migrate = false
@debug = false
@done = false
@error = false

#----------------------------------------------------------------------
#fancy schmancy color scheme

class String; def c(cc); "\e[#{cc}m#{self}\e[0m" end end
#200.to_i.times{ |i| print i.to_s.c(i) + " " }; puts
@sep = "-".c(90)*95
@sep_pref = ".".c(90)*95
@sep_thick = "+".c(90)*95

#----------------------------------------------------------------------
# greetings

def hello
  puts @sep
  puts "BitBucket to GitHub migrator -- v.#{@version}".c(95)
  #puts @sep_thick
end

def goodbye
  puts @sep
  puts "done!".c(95)
  puts @sep
  exit
end

def puts_title(text)
   puts  @sep, "#{text}".c(36), @sep
end

#----------------------------------------------------------------------
# helper methods

def get_options
  require 'optparse'

  n_options = 0
  show_options = false

  OptionParser.new do |opts|
    opts.banner = @sep +"\nUsage: gitter [options]\n".c(36)
    opts.version = @version
    opts.on('-n', '--name [name]', String, 'Set the name of the new repo') { |value| @repo_name = value; n_options+=1 }
    opts.on('-c', '--create', String, 'Create new repo') { @create = true; n_options+=1 }
    opts.on('-m', '--migrate', String, 'Migrate the repo') { @migrate = true; n_options+=1 }
    opts.on('-a', '--add', String, 'Add repo to team') { @add = true; n_options+=1 }
    opts.on('-l', '--language [language]', String, 'Set language of the new repo') { |value| @language = value.strip.downcase; n_options+=1 }
    opts.on('-d', '--debug', 'Print commands for inspection, doesn\'t actually run them') { @debug = true; n_options+=1 }
    opts.on_tail('-h', '--help', 'Prints this little guide') { show_options = true; n_options+=1 }
    @opts = opts
  end.parse!

  if show_options || n_options == 0
    puts @opts
    puts "\nExamples:".c(36)
    puts 'create new repo: ' + "\t\tgitter -c -l javascript -n node_app".c(93)
    puts 'migrate existing to GitHub: ' + "\tgitter -m -n node_app".c(93)
    puts 'create repo and migrate to it: ' + "\tgitter -c -m -l javascript -n node_app".c(93)
    puts 'create repo, migrate to it, and add it to a team: ' + "\tgitter -c -m -a -l javascript -n node_app".c(93)
    puts "\nNotes:".c(36)
    puts "Access Token for repo is #{@access_token} - change this on line 13"
    puts "Team ID for repo is #{@team_id} - change this on line 14"
    puts "Organization for repo is #{@org} - change this on line 15"
    puts 'The assumption is that the person running the script has SSH access to BitBucket,'
    puts 'and GitHub, and that if the current directory contains a directory with the same'
    puts 'name as the repo to migrated, it will deleted and recreated, or created if it'
    puts 'doesn\'t exist - the repo to migrate is mirrored locally, and then created on'
    puts 'GitHub and pushed from that local clone.'
    puts 'New repos are private by default'
    puts "Doesn\'t like symbols for language (ex. use \'c\' instead of \'c++\')"
    puts @sep
    exit
  end
end

#----------------------------------------------------------------------
# git helper methods

def gitter_create(repo)
  if @language
    %q[curl https://api.github.com/orgs/] + @org + %q[/repos -H "Authorization: token ] + @access_token + %q[" -d '{"name":"] + repo + %q[","private":true,"language":"] + @language + %q["}']
  else
    %q[curl https://api.github.com/orgs/] + @org + %q[/repos -H "Authorization: token ] + @access_token + %q[" -d '{"name":"] + repo + %q[","private":true}']
  end
end

def gitter_add(repo)
  if @language
    %q[curl https://api.github.com/teams/] + @team_id + %q[/repos/] + @org + %q[/] + repo + %q[ -H "Accept: application/vnd.github.v3+json" -H "Authorization: token ] + @access_token + %q[" -d '{"permission":"pull","language":"] + @language + %q["}']
  else
    %q[curl https://api.github.com/teams/] + @team_id + %q[/repos/] + @org + %q[/] + repo + %q[ -H "Accept: application/vnd.github.v3+json" -H "Authorization: token ] + @access_token + %q[" -d '{"permission":"pull"}']
  end
end

def git_clone_mirror(bitbucket_origin, path)
  "git clone --mirror #{bitbucket_origin}"
end

def git_push_mirror(github_origin, path)
  "(cd './#{path}' && git push --mirror #{github_origin} && cd ..)"
end

def show_pwd
  if @debug
    Dir.getwd()
  end
end

def git_list_origin(path)
  "(cd './#{path}' && git config remote.origin.url && cd ..)"
end

# error checks

def has_repo
  File.exist?('.git')
end

def has_repo_or_error(show_error)
  @repo_exists = has_repo
  if !@repo_exists
    puts 'Error: no .git folder in current directory'.c(91) if show_error
    @error = true
  end
  "has repo: #{@repo_exists}"
end

def has_repo_name_or_error(show_error)
  @repo_name_exists = !(defined?(@repo_name)).nil?
  if !@repo_name_exists
    puts 'Error: repo name missing (-n your_name_here)'.c(91) if show_error
    @error = true
  end
end

#----------------------------------------------------------------------
# main methods
def run(commands)
  if @debug
    commands.each { |x| puts(x) }
  else
    commands.each { |x| system(x) }
  end
end

def set_globals

  puts_title 'Parameters'

  @git_bitbucket_origin =   "[email protected]:#{@org}/#{@repo_name}.git"
  @git_github_origin = "[email protected]:#{@org}/#{@repo_name}.git"

  puts 'debug: ' + @debug.to_s.c(93)
  puts 'working in: ' + Dir.pwd.c(93)
  puts 'create: ' + @create.to_s.c(93)
  puts 'migrate: ' + @migrate.to_s.c(93)
  puts 'add: ' + @add.to_s.c(93)
  puts 'language: ' + @language.to_s.c(93)
  puts 'repo name: '+ @repo_name.to_s.c(93)
  puts 'bitbucket: ' + @git_bitbucket_origin.to_s.c(93)
  puts 'github: ' + @git_github_origin.to_s.c(93)
  puts 'team_id: ' + @team_id.to_s.c(93)
  puts 'org: ' + @org.to_s.c(93)
end

def create_repo
  puts_title 'Creating'

  #error checks
  has_repo_name_or_error(true)
  goodbye if @error

  puts @sep

  commands = [
      gitter_create(@repo_name)
  ]

  run commands
end


def add_repo
  puts_title 'Adding repo to team'

  #error checks
  has_repo_name_or_error(true)
  goodbye if @error

  puts @sep

  commands = [
      gitter_add(@repo_name)
  ]

  run commands
end

def migrate_repo

  puts_title "Migrating Repo to #{@repo_provider}"

  #error checks
  has_repo_name_or_error(true)
  goodbye if @error

  if Dir.exists?("#{@repo_name}.git")
    puts "#{@repo_name} already exists... recursively deleting."
    FileUtils.rm_r("#{@repo_name}.git")
  end

  path = "#{@repo_name}.git"
  commands = [
    git_clone_mirror(@git_bitbucket_origin, path),
    git_list_origin(path),
    git_push_mirror(@git_github_origin, path)
  ]

  run commands
end

#----------------------------------------------------------------------
#sequence control
hello
get_options

#do stuff
set_globals
create_repo if @create
migrate_repo if @migrate
add_repo if @add

#peace out
goodbye

So verwenden Sie das Skript:

# create a list of repos
foo
bar
baz

# execute the script, iterating over your list
while read p; do ./bitbucket-to-github.rb -a -n $p; done<repos

# good nuff
Rbellamie
quelle
5

Es gibt das Importieren eines Repositorys mit GitHub Importer

Wenn Sie ein Projekt auf einem anderen Versionskontrollsystem als Mercurial gehostet haben, können Sie es mit dem GitHub Importer-Tool automatisch in GitHub importieren.

  1. Klicken Sie in der oberen rechten Ecke einer Seite auf und dann auf Repository importieren.
  2. Geben Sie unter "Klon-URL Ihres alten Repositorys" die URL des Projekts ein, das Sie importieren möchten.
  3. Wählen Sie Ihr Benutzerkonto oder eine Organisation aus, der das Repository gehören soll, und geben Sie dann einen Namen für das Repository auf GitHub ein.
  4. Geben Sie an, ob das neue Repository öffentlich oder privat sein soll.
    • Öffentliche Repositorys sind für jeden Benutzer auf GitHub sichtbar, sodass Sie von der kollaborativen Community von GitHub profitieren können.
    • Optionsfelder für öffentliche oder private Repositorys Private Repositorys stehen nur dem Repository-Eigentümer sowie allen Mitarbeitern zur Verfügung, die Sie freigeben möchten.
  5. Überprüfen Sie die eingegebenen Informationen und klicken Sie dann auf Import starten.

Sie erhalten eine E-Mail, wenn das Repository vollständig importiert wurde.

  1. https://help.github.com/categories/importing-your-projects-to-github
  2. https://help.github.com/articles/importing-a-repository-with-github-importer/
Benutzer
quelle
2

Wenn Sie Ihr lokales Git-Repository in ein anderes Upstream verschieben möchten, können Sie dies auch tun:

So erhalten Sie die aktuelle Remote-URL:

Git Remote Get-URL Ursprung

zeigt etwas wie: https://bitbucket.com/git/myrepo

So legen Sie ein neues Remote-Repository fest:

git remote set-url origin [email protected]: Ordner / myrepo.git

Drücken Sie jetzt den Inhalt des aktuellen (Entwicklungs-) Zweigs:

Git Push - Set-Upstream-Ursprung entwickeln

Sie haben jetzt eine vollständige Kopie des Zweigs in der neuen Fernbedienung.

Optional kehren Sie für diesen lokalen Ordner zur ursprünglichen Git-Remote zurück:

git remote set-url origin https://bitbucket.com/git/myrepo

Bietet den Vorteil, dass Sie Ihr neues Git-Repository jetzt von github in einem anderen Ordner herunterladen können, sodass zwei lokale Ordner auf die verschiedenen Fernbedienungen verweisen, die vorherige (Bitbucket) und die neue, beide verfügbar.

Hace
quelle
2

Ich habe das folgende Bash-Skript erstellt, um ALLE meine Bitbucket (Benutzer) -Repositorys als private Repositorys auf GitHub zu klonen .


Bedarf:

  • jq (Befehlszeilen-JSON-Prozessor) | Mac OS:brew install jq

Schritte:

  1. Gehen Sie zu https://github.com/settings/tokens und erstellen Sie ein Zugriffstoken. Wir brauchen nur den "Repo" -Bereich.

  2. Speichern Sie das move_me.shSkript in einem Arbeitsordner und bearbeiten Sie die Datei nach Bedarf.

  3. Vergiss es nicht CHMOD 755

  4. Lauf! ./move_me.sh

  5. Genießen Sie die Zeit, die Sie gespart haben.


Anmerkungen:

  • Es klont die BitBucket-Repositorys in das Verzeichnis, in dem sich das Skript befindet (Ihr Arbeitsverzeichnis).

  • Dieses Skript löscht Ihre BitBucket-Repositorys nicht.


Müssen Sie in öffentliche Repositories auf GitHub wechseln?

Suchen und ändern Sie die "private": truezu"private": false unten.

Verschieben der Repositorys einer Organisation?

Schauen Sie sich das Entwicklerhandbuch an , es ist ein paar Änderungen entfernt.


Viel Spaß beim Umzug.

#!/bin/bash

BB_USERNAME=your_bitbucket_username 
BB_PASSWORD=your_bitbucket_password

GH_USERNAME=your_github_username
GH_ACCESS_TOKEN=your_github_access_token

###########################

pagelen=$(curl -s -u $BB_USERNAME:$BB_PASSWORD https://api.bitbucket.org/2.0/repositories/$BB_USERNAME | jq -r '.pagelen')

echo "Total number of pages: $pagelen"

hr () {
  printf '%*s\n' "${COLUMNS:-$(tput cols)}" '' | tr ' ' -  
}

i=1

while [ $i -le $pagelen ]
do
  echo
  echo "* Processing Page: $i..."
  hr  
  pageval=$(curl -s -u $BB_USERNAME:$BB_PASSWORD https://api.bitbucket.org/2.0/repositories/$BB_USERNAME?page=$i)

  next=$(echo $pageval | jq -r '.next')
  slugs=($(echo $pageval | jq -r '.values[] | .slug'))
  repos=($(echo $pageval | jq -r '.values[] | .links.clone[1].href'))

  j=0
  for repo in ${repos[@]}
  do
    echo "$(($j + 1)) = ${repos[$j]}"
    slug=${slugs[$j]}
  git clone --bare $repo 
  cd "$slug.git"
  echo
  echo "* $repo cloned, now creating $slug on github..."  
  echo  

  read -r -d '' PAYLOAD <<EOP
  {
    "name": "$slug",
    "description": "$slug - moved from bitbucket",
    "homepage": "https://github.com/$slug",
    "private": true
  }
  EOP

  curl -H "Authorization: token $GH_ACCESS_TOKEN" --data "$PAYLOAD" \
      https://api.github.com/user/repos
  echo
  echo "* mirroring $repo to github..."  
  echo
  git push --mirror "[email protected]:$GH_USERNAME/$slug.git"
  j=$(( $j + 1 ))
  hr    
  cd ..
  done  
  i=$(( $i + 1 ))
done
cenk
quelle
1
Interessantes Skript, kombiniert mit einem Token. Ordentlich. Upvoted.
VonC
@VonC Danke!
Cenk
1

Hier sind die Schritte zum Verschieben eines privaten Git-Repositorys:

Schritt 1: Erstellen Sie ein Github-Repository

Erstellen Sie zunächst ein neues privates Repository auf Github.com. Es ist wichtig, das Repository leer zu halten, z. B. nicht die Option Dieses Repository beim Erstellen des Repositorys mit einer README-Datei initialisieren.

Schritt 2: Verschieben Sie vorhandene Inhalte

Als nächstes müssen wir das Github-Repository mit dem Inhalt aus unserem Bitbucket-Repository füllen:

  1. Überprüfen Sie das vorhandene Repository von Bitbucket:
    $ git clone https://[email protected]/USER/PROJECT.git
  1. Fügen Sie das neue Github-Repository als Upstream-Remote des von Bitbucket ausgecheckten Repositorys hinzu :
    $ cd PROJECT
    $ git remote add upstream https://github.com:USER/PROJECT.git
  1. Schieben Sie alle Zweige (unten: nur Master) und Tags in das Github-Repository:
    $ git push upstream master
    $ git push --tags upstream

Schritt 3: Bereinigen Sie das alte Repository

Schließlich müssen wir sicherstellen, dass Entwickler nicht durch zwei Repositorys für dasselbe Projekt verwirrt werden. So löschen Sie das Bitbucket-Repository:

  1. Stellen Sie sicher, dass das Github-Repository den gesamten Inhalt enthält

  2. Gehen Sie zur Weboberfläche des alten Bitbucket-Repositorys

  3. Wählen Sie die Menüoption Einstellung> Repository löschen

  4. Fügen Sie die URL des neuen Github-Repositorys als Umleitungs-URL hinzu

Damit hat sich das Endlager vollständig in seinem neuen Zuhause in Github niedergelassen. Lassen Sie alle Entwickler wissen!

Ryan
quelle
-1

Einfachste Art und Weise:

git remote rename origin repo_bitbucket

git remote add origin https://github.com/abc/repo.git

git push origin master

Wenn der Push zu GitHub erfolgreich ist, löschen Sie die alte Fernbedienung, indem Sie Folgendes ausführen:

git remote rm repo_bitbucket
RahulMohan Kolakandy
quelle