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

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?

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

Es verwendet:

• git clone --mirror: um alle Referenzen (Commits, Tags, Zweige) zu klonen
• git push --mirror: alles schieben

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 :

• Es ist einfacher, die von MarMass beschriebene Import CodeFunktion von GitHub zu verwenden .
  Siehe https://github.com/new/import
• Es sei denn ... Ihr Repo enthält eine große Datei: Das Problem ist, dass das Import-Tool ohne eine eindeutige Fehlermeldung fehlschlägt. Nur der GitHub-Support kann diagnostizieren, was passiert ist.

Es ist sehr einfach.

1º 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

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

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:
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 ".

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

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:

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        -- deriso@gmail.com
# Contributor -- G. Richard Bellamy -- rbellamy@terradatum.com
# 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 =   "git@bitbucket.org:#{@org}/#{@repo_name}.git"
  @git_github_origin = "git@github.com:#{@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

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/

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 git@github.com: 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.

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 "git@github.com:$GH_USERNAME/$slug.git"
  j=$(( $j + 1 ))
  hr    
  cd ..
  done  
  i=$(( $i + 1 ))
done

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://USER@bitbucket.org/USER/PROJECT.git

2. 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

3. 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!

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