¿Cómo mover el repositorio git con todas las ramas desde bitbucket a github?


334

¿Cuál es la mejor manera de mover un repositorio git con todas las ramas e historial completo de bitbucket a github? ¿Hay un script o una lista de comandos que tengo que usar?


99
Github proporciona herramientas y documentación para eso: help.github.com/articles/… help.github.com/articles/…
mems

Poco tarde para la fiesta, pero aquí hay un script para la migración: gist.github.com/chinmaya-n/cff02f1277c811deab2e550f2aad9967
inblueswithu

Respuestas:


394

Puede consultar la página de GitHub " Duplicar un repositorio "

Usa:

Eso daría:

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

Como se señaló en los comentarios de LS :


2
Este método me creó un problema (no estoy seguro si es un problema). Cuando reflejé el repositorio de bitbucket a github, para 5 ramas se muestra como "Solicitud de comparación y extracción" en github. No se muestra como ramas en github. ¿Qué puedo hacer al respecto?
Siddharth

2
¿Y qué hay de los problemas y wikis?
Vladislav Rastrusny

@FractalizeR wiki es solo otro repositorio, que también puedes replicar ( github.com/blog/699-making-github-more-open-git-backed-wikis ). Sin embargo, no hay una manera fácil de replicar problemas. Debe usar la Api (varios programas de respaldo de repositorio de GitHub hacen exactamente eso: addyosmani.com/blog/backing-up-a-github-account )
VonC

3
Esto funciona si desea mover un repositorio de Github a Bitbucket también.
simeg

1
Necesitaba usar este método para copiar un repositorio porque contenía un archivo grande (> 100 MB). GH no permitiría archivos grandes en sus repositorios. Eliminé el archivo grande antes de enviar el repositorio a GH. Sin embargo, salvo otros problemas, usar la función " Depósito de importación " de GH es la opción correcta el 95% del tiempo, como se describe en otra respuesta . Sin embargo, si falla, no da mensajes de error útiles y debe comunicarse con el soporte de GH. Fue el soporte de GH el que me informó sobre la restricción del tamaño del archivo.
LS

412

Es muy simple.

Cree un nuevo repositorio vacío en GitHub (sin readme o licesne, puede agregarlos antes) y la siguiente pantalla mostrará

Dentro de la opción de importar código , pega el repositorio de URL de tu bitbucket y ¡voilà!

Haga clic en el código de importación


12
Realmente estás respondiendo la pregunta aquí, ya que la respuesta aceptada muestra solo un método genérico relacionado con Git. ¡Tu respuesta es mucho más simple!
Emile Bergeron

66
Esta respuesta es buena siempre que usted sea el que cree el repositorio y sea simple. Si alguien más ha creado el repositorio para usted (como la carga administrativa de la creación de sucursales), entonces esto no funciona. La respuesta aceptada es el camino a seguir en tal caso.
Maestro Aurora el

44
Esté atento a cualquier persona que esté pensando en usar este método, elimine su autenticación de dos factores en su host de repositorio anterior antes de usar este servicio, de lo contrario, se quedará atrapado en un bucle interminable de intentar eliminar el repositorio recién creado en GitHub, y la única forma de salir de eso es reemplazar /importel final de la URL con /settingspara acceder a la configuración y eliminarla.
Dave

1
Pequeña advertencia: si se encuentra con un problema, no recibirá un mensaje de error descriptivo.
RobertH

El uso de la función " Depósito de importación " de GH es la elección correcta el 95% del tiempo. Sin embargo, si falla, no da mensajes de error útiles y debe comunicarse con el soporte de GH. No pude usarlo para un repositorio porque contenía un archivo grande (> 100 MB). Necesitaba usar el método CLI aceptado , eliminando el archivo grande justo antes de enviar el repositorio a GH.
LS

125

En caso de que no pueda encontrar el botón "Importar código" en github, puede:

  1. abra directamente Github Importer e ingrese el url. Se verá así:Captura de pantalla del importador de github
  2. darle un nombre (o importará el nombre automáticamente)
  3. seleccionar Publico Privaterepo
  4. Hacer clic Begin Import

ACTUALIZACIÓN: Recientemente, Github anunció la capacidad de " Importar repositorios con archivos grandes "


Desafortunadamente, esto no funcionó para mi intento de pasar de codebasehq a git-hub, dio un "Esta URL no es compatible". :(
sjmcdowall

@sjmcdowall Lo siento, pero creo que debería haber funcionado ya que la URL de codebasehq apunta a un repositorio git.
biniam

La URL ya no existe.
Contenedor codificado

@CodedContainer Acabo de comprobar y funciona. Incluso actualicé la captura de pantalla justo ahora.
biniam

1
La url solo devolverá un 404 si no ha iniciado sesión en GitHub. Si ha iniciado sesión, se cargará la herramienta de importación.
Jason Hurt

41

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

Esto me ayudó a pasar de un proveedor de git a otro. Al final, todos los commits estaban en el git de destino. Simple y directo.

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

Una vez que estuve feliz de que el empuje haya tenido éxito en GitHub, pude eliminar el viejo control remoto emitiendo:

git remote rm bitbucket

2
Incluya las partes relevantes de un enlace en su respuesta, ya que debería ser independiente.
k0pernikus

Recibo un error que dice "Error: no se pudieron enviar algunas referencias a la sugerencia ' url.gi ': las actualizaciones se rechazaron porque el control remoto contiene trabajo que no tiene localmente. Esto generalmente es causado por otro repositorio que empuja a la misma referencia. Es posible que desee integrar primero los cambios remotos (por ejemplo, pull ...) antes de presionar nuevamente. Consulte la nota sobre avance rápido en git push --help para obtener más detalles
Contenedor codificado

1
esta es la única respuesta que todavía funciona en 3/3/2019 :)
Wang-Zhao-Liu QM

13

Tuve el caso de uso inverso de importar un repositorio existente de github a bitbucket.

Bitbucket también ofrece una herramienta de importación . El único paso necesario es agregar URL al repositorio.

Parece que:

Captura de pantalla de la herramienta de importación de bitbucket


5

Me doy cuenta de que esta es una vieja pregunta. Lo encontré hace varios meses cuando intentaba hacer lo mismo, y me decepcionaron las respuestas dadas. Todos parecían lidiar con la importación de Bitbucket a GitHub un repositorio a la vez, ya sea a través de comandos emitidos a la carta o a través del importador de GitHub.

Tomé el código de un proyecto de GitHub llamado gitter y lo modifiqué para satisfacer mis necesidades.

Puede bifurcar la esencia , o tomar el código desde aquí:

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

Luego, para usar el script:

# 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

5

Existe la importación de un repositorio con GitHub Importer

Si tiene un proyecto alojado en otro sistema de control de versiones como Mercurial, puede importarlo automáticamente a GitHub utilizando la herramienta Importador de GitHub.

  1. En la esquina superior derecha de cualquier página, haga clic en y luego haga clic en Importar repositorio.
  2. En "URL de clonación de su antiguo repositorio", escriba la URL del proyecto que desea importar.
  3. Elija su cuenta de usuario o una organización para poseer el repositorio, luego escriba un nombre para el repositorio en GitHub.
  4. Especifique si el nuevo repositorio debe ser público o privado.
    • Los repositorios públicos son visibles para cualquier usuario en GitHub, por lo que puede beneficiarse de la comunidad colaborativa de GitHub.
    • Botones de opción de repositorio público o privado Los repositorios privados solo están disponibles para el propietario del repositorio, así como para cualquier colaborador con el que elija compartir.
  5. Revise la información que ingresó, luego haga clic en Comenzar importación.

Recibirá un correo electrónico cuando el repositorio se haya importado por completo.

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

2

En caso de que desee mover su repositorio git local a otro ascendente, también puede hacer esto:

para obtener la URL remota actual:

origen de get-url remoto de git

mostrará algo como: https://bitbucket.com/git/myrepo

configurar un nuevo repositorio remoto:

git remote set-url origin git@github.com: carpeta / myrepo.git

ahora empuje el contenido de la rama actual (desarrollo):

git push: se desarrolla el origen ascendente

Ahora tiene una copia completa de la rama en el nuevo control remoto.

opcionalmente regrese a git-remote original para esta carpeta local:

origen de set-url remoto de git https://bitbucket.com/git/myrepo

Le da el beneficio de que ahora puede obtener su nuevo repositorio git de github en otra carpeta para que tenga dos carpetas locales que apuntan a los diferentes controles remotos, el anterior (bitbucket) y el nuevo disponibles.


2

Hice el siguiente script bash para clonar TODOS mis repositorios de Bitbucket (usuario) a GitHub como repositorios privados .


Requisitos:

  • jq (procesador JSON de línea de comandos) | Mac OS:brew install jq

Pasos:

  1. Vaya a https://github.com/settings/tokens y cree un token de acceso. Solo necesitamos el alcance "repo".

  2. Guarde el move_me.shscript en una carpeta de trabajo y edite el archivo según sea necesario.

  3. No te olvides de CHMOD 755

  4. ¡Correr! ./move_me.sh

  5. Disfruta el tiempo que has ahorrado.


Notas:

  • Clonará los repositorios de BitBucket dentro del directorio donde reside el script (su directorio de trabajo).

  • Este script no elimina sus repositorios de BitBucket.


¿Necesita pasar a repositorios públicos en GitHub?

Buscar y cambiar el "private": truea "private": falsecontinuación.

¿Mover los repositorios de una organización?

Consulte la guía del desarrollador , está a un par de ediciones.


Feliz mudanza

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

1
Guión interesante, combinado con un token. Ordenado. Votado
VonC

@VonC ¡Gracias!
cenk

1

Estos son los pasos para mover un repositorio privado de Git:

Paso 1: crear el repositorio de Github

Primero, cree un nuevo repositorio privado en Github.com. Es importante mantener el repositorio vacío, por ejemplo, no marque la opción Inicializar este repositorio con un archivo README al crear el repositorio.

Paso 2: mover contenido existente

Luego, necesitamos llenar el repositorio de Github con el contenido de nuestro repositorio de Bitbucket:

  1. Echa un vistazo al repositorio existente de Bitbucket:
    $ git clone https://USER@bitbucket.org/USER/PROJECT.git
  1. Agregue el nuevo repositorio de Github como remoto remoto del repositorio extraído de Bitbucket:
    $ cd PROJECT
    $ git remote add upstream https://github.com:USER/PROJECT.git
  1. Empuje todas las ramas (abajo: solo master) y las etiquetas al repositorio de Github:
    $ git push upstream master
    $ git push --tags upstream

Paso 3: limpiar el repositorio antiguo

Finalmente, debemos asegurarnos de que los desarrolladores no se confundan al tener dos repositorios para el mismo proyecto. Aquí se explica cómo eliminar el repositorio de Bitbucket:

  1. Verifique que el repositorio de Github tenga todo el contenido

  2. Vaya a la interfaz web del antiguo repositorio de Bitbucket

  3. Seleccione la opción de menú Configuración> Eliminar repositorio

  4. Agregue la URL del nuevo repositorio de Github como URL de redireccionamiento

Con eso, el repositorio se instaló por completo en su nuevo hogar en Github. ¡Que todos los desarrolladores lo sepan!


-1

La forma más simple de hacerlo:

git remote rename origin repo_bitbucket

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

git push origin master

Una vez que el envío a GitHub sea exitoso, elimine el control remoto anterior ejecutando:

git remote rm repo_bitbucket
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.