Como mover o repositório git com todas as ramificações do bitbucket para o github?

334

Qual é a melhor maneira de mover um repositório git com todas as ramificações e histórico completo do bitbucket para o github? Existe um script ou uma lista de comandos que tenho que usar?

swalkner
fonte
9
O Github fornece ferramentas e documentação para isso: help.github.com/articles/… help.github.com/articles/…
mems
Um pouco atrasado para a festa, mas aqui está um script para migração: gist.github.com/chinmaya-n/cff02f1277c811deab2e550f2aad9967
inblueswithu

Respostas:

393

Você pode consultar a página do GitHub " Duplicando um Repositório "

Usa:

Isso daria:

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

Conforme observado no comentário de LS :

VonC
fonte
2
Este método criou um problema para mim (não tenho certeza se é problema). Quando eu espelhei o repositório do bitbucket para o github, em 5 ramos, ele é mostrado como "Compare and Pull Request" no github. Não é mostrado como ramificações no github. O que posso fazer sobre isso?
Siddharth
2
E então, o que dizer de problemas e wikis?
Vladislav Rastrusny
O wiki do @FractalizeR é apenas outro repositório, que você pode replicar também ( github.com/blog/699-making-github-more-open-git-backed-wikis ). Porém, não há uma maneira fácil de replicar problemas. Você precisa usar o Api (vários programas de backup de repositório do GitHub fazem exatamente isso: addyosmani.com/blog/backing-up-a-github-account )
VonC
3
Isso funciona se você quiser mover um repositório do Github para o Bitbucket também.
Simeg 24/04/2016
11
Eu precisava usar o método this para copiar um repositório porque ele continha um arquivo grande (> 100 MB). O GH não permitiria arquivos grandes em seus repositórios. Eu removi o arquivo grande antes de enviar o repositório para o GH. No entanto, salvo outros problemas, o uso do recurso " Import repository " do GH é a escolha certa 95% das vezes, conforme descrito em outra resposta . No entanto, se falhar, não fornece mensagens de erro úteis e você deve entrar em contato com o suporte da GH. Foi o suporte do GH que me informou da restrição de tamanho do arquivo.
LS
411

É muito simples.

Crie um novo repositório vazio no GitHub (sem leia-me ou licesne, você pode adicioná-los antes) e a seguinte tela será exibida

Dentro da opção de importação de código, cole o repo do seu URL de bitbucket e pronto!

Click in import code

MarMass
fonte
12
Você está realmente respondendo à pergunta aqui, pois a resposta aceita mostra apenas um método genérico relacionado ao Git. Sua resposta é bem mais simples!
Emile Bergeron
6
Essa resposta é boa desde que você seja quem cria o repositório e ele é vazio. Se outra pessoa criou o repositório para você (como o encargo de administrador da criação de filial), isso não funciona. Resposta aceita é o caminho a seguir nesse caso.
precisa saber é o seguinte
4
Atenção para qualquer pessoa que esteja pensando em usar esse método, remova a autenticação de dois fatores no host do repositório anterior antes de usar este serviço, caso contrário, ficará preso em um ciclo interminável de tentativa de remover o repositório recém-criado no GitHub e a única maneira de sair disso é substituindo o /importno final do URL por /settingspara acessar as configurações e removê-lo.
Dave
11
Advertência pequena - se você encontrar um problema, não receberá uma mensagem de erro descritiva.
Roberth
Usar o recurso " Importar repositório " do GH é a escolha certa 95% do tempo. No entanto, se falhar, não fornece mensagens de erro úteis e você deve entrar em contato com o suporte da GH. Não pude usá-lo para um repo porque continha um arquivo grande (> 100 MB). Eu precisava usar o método CLI aceito , removendo o arquivo grande antes de enviar o repositório para o GH.
LS
125

Caso não encontre o botão "Import code" no github, você pode:

  1. abra diretamente o Importador do Github e digite o url. Será parecido com:Captura de tela do importador do github
  2. dê um nome (ou importará o nome automaticamente)
  3. selecione Publicou Privaterepo
  4. Clique Begin Import

ATUALIZAÇÃO: Recentemente, o Github anunciou a capacidade de " Importar repositórios com arquivos grandes "

biniam
fonte
Infelizmente, isso não funcionou na minha tentativa de mudar do codebasehq para o git-hub, deu um "Este URL não é suportado". :(
sjmcdowall
@sjmcdowall Desculpe, mas não, mas acredito que deveria ter funcionado, pois o URL do codebasehq aponta para um repositório git.
Biniam
O URL não existe mais.
Container codificado
@CodedContainer Acabei de verificar e funciona. Eu até atualizei a captura de tela agora.
Biniam
11
O URL retornará apenas 404 se você não estiver conectado ao GitHub. Se você estiver logado, a ferramenta de importação será carregada.
Jason Hurt
41

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

Isso me ajudou a mudar de um provedor git para outro. No final, todas as confirmações estavam no git de destino. Simples e direto.

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

Quando fiquei feliz que o envio havia sido bem-sucedido no GitHub, pude excluir o controle remoto antigo emitindo:

git remote rm bitbucket
Rettel
fonte
2
Inclua as partes relevantes de um link na sua resposta, pois ele deve ser independente.
K0pernikus
Eu recebo um erro que diz "Erro: falha ao enviar algumas referências à dica ' url.gi ': as atualizações foram rejeitadas porque o controle remoto contém trabalho que você não possui localmente. Isso geralmente é causado por outro repositório que envia para a mesma referência. você pode querer primeiro integrar as alterações remotas (por exemplo, puxar ...) antes de empurrar novamente Veja a nota sobre fast-forwards em --help git push para mais detalhes..
Coded Container
11
esta é a única resposta que ainda está trabalhando em 2019/03/03 :)
Wang-Zhao-Liu QM
13

Eu tive o caso de uso reverso de importar um repositório existente do github para o bitbucket.

O Bitbucket também oferece uma ferramenta de importação . A única etapa necessária é adicionar URL ao repositório.

Parece que:

Captura de tela da ferramenta de importação de bitbucket

k0pernikus
fonte
5

Sei que essa é uma pergunta antiga. Eu o encontrei há vários meses, quando estava tentando fazer a mesma coisa, e fiquei desapontado com as respostas dadas. Todos pareciam lidar com a importação do Bitbucket para o GitHub, um repositório de cada vez, seja por comandos emitidos à la carte ou pelo importador do GitHub.

Peguei o código de um projeto do GitHub chamado gitter e o modifiquei para atender às minhas necessidades.

Você pode bifurcar a essência , ou pegar o código aqui:

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

Então, para usar o 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
rbellamy
fonte
5

Existe o Importando um Repositório com o GitHub Importador

Se você tiver um projeto hospedado em outro sistema de controle de versão como Mercurial, poderá importá-lo automaticamente para o GitHub usando a ferramenta Importador do GitHub.

  1. No canto superior direito de qualquer página, clique em Importar repositório.
  2. Em "URL de clone do seu repositório antigo", digite a URL do projeto que você deseja importar.
  3. Escolha sua conta de usuário ou uma organização como proprietária do repositório e digite um nome para o repositório no GitHub.
  4. Especifique se o novo repositório deve ser público ou privado.
    • Os repositórios públicos são visíveis para qualquer usuário no GitHub, para que você possa se beneficiar da comunidade colaborativa do GitHub.
    • Botões de opção do repositório público ou privado Os repositórios privados estão disponíveis apenas para o proprietário do repositório, bem como para todos os colaboradores com quem você optar por compartilhar.
  5. Revise as informações inseridas e clique em Iniciar importação.

Você receberá um email quando o repositório tiver sido completamente importado.

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

Caso você queira mover seu repositório git local para outro upstream, você também pode fazer isso:

para obter o URL remoto atual:

origem de get-url remota git

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

para definir um novo repositório remoto:

origem remota do conjunto de URLs git [email protected]: folder / myrepo.git

agora empurre o conteúdo do ramo atual (desenvolvimento):

origem git push --set-upstream

Agora você tem uma cópia completa da ramificação no novo controle remoto.

opcionalmente, retorne ao git-remote original para esta pasta local:

origem do conjunto de URLs remotos do git https://bitbucket.com/git/myrepo

Agora, você pode obter seu novo repositório git no github em outra pasta, para que você tenha duas pastas locais apontando para os diferentes controles remotos, o anterior (bitbucket) e o novo, ambos disponíveis.

Hace
fonte
2

Criei o seguinte script bash para clonar TODOS os meus repositórios Bitbucket (usuário) no GitHub como repositórios privados .


Requisitos:

  • jq (processador JSON da linha de comandos) | Mac OS:brew install jq

Passos:

  1. Vá para https://github.com/settings/tokens e crie um token de acesso. Nós precisamos apenas do escopo "repo".

  2. Salve o move_me.shscript em uma pasta de trabalho e edite o arquivo conforme necessário.

  3. Não esqueça de CHMOD 755

  4. Corre! ./move_me.sh

  5. Aproveite o tempo que você economizou.


Notas:

  • Ele clonará os repositórios do BitBucket dentro do diretório em que o script reside (seu diretório de trabalho).

  • Este script não exclui seus repositórios do BitBucket.


Precisa mudar para repositórios públicos no GitHub?

Encontre e altere "private": truepara "private": falseabaixo.

Mover repositórios de uma organização?

Confira o guia do desenvolvedor , a algumas edições de distância.


Feliz em movimento.

#!/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
fonte
11
Script interessante, combinado com um token. Arrumado. Votado.
VonC 11/12/19
@VonC Obrigado!
cenk
1

Aqui estão as etapas para mover um repositório Git privado:

Etapa 1: Criar repositório Github

Primeiro, crie um novo repositório privado no Github.com. É importante manter o repositório vazio, por exemplo, não marque a opção Inicialize este repositório com um README ao criar o repositório.

Etapa 2: mover o conteúdo existente

Em seguida, precisamos preencher o repositório do Github com o conteúdo do nosso repositório Bitbucket:

  1. Confira o repositório existente no Bitbucket:
    $ git clone https://[email protected]/USER/PROJECT.git
  1. Adicione o novo repositório Github como remoto upstream do repositório retirado do Bitbucket:
    $ cd PROJECT
    $ git remote add upstream https://github.com:USER/PROJECT.git
  1. Envie todos os branches (abaixo: apenas master) e as tags para o repositório do Github:
    $ git push upstream master
    $ git push --tags upstream

Etapa 3: limpar o repositório antigo

Finalmente, precisamos garantir que os desenvolvedores não fiquem confusos com dois repositórios para o mesmo projeto. Aqui está como excluir o repositório Bitbucket:

  1. Verifique se o repositório do Github tem todo o conteúdo

  2. Vá para a interface web do antigo repositório Bitbucket

  3. Selecione a opção de menu Configuração> Excluir repositório

  4. Adicione o URL do novo repositório do Github como URL de redirecionamento

Com isso, o repositório se estabeleceu completamente em sua nova casa no Github. Informe todos os desenvolvedores!

Ryan
fonte
-1

Maneira mais simples de fazer isso:

git remote rename origin repo_bitbucket

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

git push origin master

Quando o envio ao GitHub for bem-sucedido, exclua o controle remoto antigo executando:

git remote rm repo_bitbucket
RahulMohan Kolakandy
fonte