Como fazer backup de um repositório Git local?

Estou usando o git em um projeto relativamente pequeno e acho que compactar o conteúdo do diretório .git pode ser uma boa maneira de fazer backup do projeto. Mas isso é meio estranho, porque, quando eu restauro, a primeira coisa que preciso fazer é git reset --hard.

Há algum problema com o backup de um repositório Git dessa maneira? Além disso, existe alguma maneira melhor de fazê-lo (por exemplo, um formato portátil git ou algo semelhante?)?

Comecei a cortar um pouco o script de Yar e o resultado está no github, incluindo páginas de manual e script de instalação:

https://github.com/najamelan/git-backup

Instalação :

git clone "https://github.com/najamelan/git-backup.git"
cd git-backup
sudo ./install.sh

Congratulando-se com todas as sugestões e solicitações de recebimento no github.

#!/usr/bin/env ruby
#
# For documentation please sea man git-backup(1)
#
# TODO:
# - make it a class rather than a function
# - check the standard format of git warnings to be conform
# - do better checking for git repo than calling git status
# - if multiple entries found in config file, specify which file
# - make it work with submodules
# - propose to make backup directory if it does not exists
# - depth feature in git config (eg. only keep 3 backups for a repo - like rotate...)
# - TESTING



# allow calling from other scripts
def git_backup


# constants:
git_dir_name    = '.git'          # just to avoid magic "strings"
filename_suffix = ".git.bundle"   # will be added to the filename of the created backup


# Test if we are inside a git repo
`git status 2>&1`

if $?.exitstatus != 0

   puts 'fatal: Not a git repository: .git or at least cannot get zero exit status from "git status"'
   exit 2


else # git status success

   until        File::directory?( Dir.pwd + '/' + git_dir_name )             \
            or  File::directory?( Dir.pwd                      ) == '/'


         Dir.chdir( '..' )
   end


   unless File::directory?( Dir.pwd + '/.git' )

      raise( 'fatal: Directory still not a git repo: ' + Dir.pwd )

   end

end


# git-config --get of version 1.7.10 does:
#
# if the key does not exist git config exits with 1
# if the key exists twice in the same file   with 2
# if the key exists exactly once             with 0
#
# if the key does not exist       , an empty string is send to stdin
# if the key exists multiple times, the last value  is send to stdin
# if exaclty one key is found once, it's value      is send to stdin
#


# get the setting for the backup directory
# ----------------------------------------

directory = `git config --get backup.directory`


# git config adds a newline, so remove it
directory.chomp!


# check exit status of git config
case $?.exitstatus

   when 1 : directory = Dir.pwd[ /(.+)\/[^\/]+/, 1]

            puts 'Warning: Could not find backup.directory in your git config file. Please set it. See "man git config" for more details on git configuration files. Defaulting to the same directroy your git repo is in: ' + directory

   when 2 : puts 'Warning: Multiple entries of backup.directory found in your git config file. Will use the last one: ' + directory

   else     unless $?.exitstatus == 0 then raise( 'fatal: unknown exit status from git-config: ' + $?.exitstatus ) end

end


# verify directory exists
unless File::directory?( directory )

   raise( 'fatal: backup directory does not exists: ' + directory )

end


# The date and time prefix
# ------------------------

prefix           = ''
prefix_date      = Time.now.strftime( '%F'       ) + ' - ' # %F = YYYY-MM-DD
prefix_time      = Time.now.strftime( '%H:%M:%S' ) + ' - '
add_date_default = true
add_time_default = false

prefix += prefix_date if git_config_bool( 'backup.prefix-date', add_date_default )
prefix += prefix_time if git_config_bool( 'backup.prefix-time', add_time_default )



# default bundle name is the name of the repo
bundle_name = Dir.pwd.split('/').last

# set the name of the file to the first command line argument if given
bundle_name = ARGV[0] if( ARGV[0] )


bundle_name = File::join( directory, prefix + bundle_name + filename_suffix )


puts "Backing up to bundle #{bundle_name.inspect}"


# git bundle will print it's own error messages if it fails
`git bundle create #{bundle_name.inspect} --all --remotes`


end # def git_backup



# helper function to call git config to retrieve a boolean setting
def git_config_bool( option, default_value )

   # get the setting for the prefix-time from git config
   config_value = `git config --get #{option.inspect}`

   # check exit status of git config
   case $?.exitstatus

      # when not set take default
      when 1 : return default_value

      when 0 : return true unless config_value =~ /(false|no|0)/i

      when 2 : puts 'Warning: Multiple entries of #{option.inspect} found in your git config file. Will use the last one: ' + config_value
               return true unless config_value =~ /(false|no|0)/i

      else     raise( 'fatal: unknown exit status from git-config: ' + $?.exitstatus )

   end
end

# function needs to be called if we are not included in another script
git_backup if __FILE__ == $0

A outra maneira oficial seria usar o pacote git

Isso criará um arquivo compatível git fetche git pullpara atualizar seu segundo repo.
Útil para backup e restauração incrementais.

Mas se você precisar fazer backup de tudo (porque você não possui um segundo repositório com algum conteúdo antigo já existente), o backup é um pouco mais elaborado, como mencionado na minha outra resposta, após o comentário de Kent Fredric :

$ git bundle create /tmp/foo master
$ git bundle create /tmp/foo-all --all
$ git bundle list-heads /tmp/foo
$ git bundle list-heads /tmp/foo-all

(É uma operação atômica , em vez de criar um arquivo da .gitpasta, como comentado por fantabolous )

Aviso: eu não recomendaria a solução de Pat Notz , que está clonando o repositório. Fazer backup de muitos arquivos é sempre mais complicado do que fazer backup ou atualizar ... apenas um.

Se você olhar para o histórico de edições da resposta do OP Yar , verá que Yar usou no início a , ... com a edição:clone --mirror

Usar isso com o Dropbox é uma bagunça total .
Você terá erros de sincronização e NÃO PODE ROLAR UM DIRETÓRIO DE VOLTA NA DROPBOX.
Use git bundlese você deseja fazer backup na sua caixa de depósito.

A solução atual de Yar usa git bundle.

Eu descanso meu caso.

A maneira como faço isso é criar um repositório remoto (vazio) (em uma unidade separada, chave USB, servidor de backup ou mesmo github) e depois usá push --mirror-lo para fazer com que o repositório remoto pareça exatamente com o meu local (exceto que o controle remoto é vazio) repositório).

Isso enviará todas as referências (ramificações e tags), incluindo atualizações de avanço rápido. Eu uso isso para criar backups do meu repositório local.

A página do manual descreve assim:

Em vez de nomear cada árbitro para empurrar, especifica que todos os refs sob $GIT_DIR/refs/(o que inclui, mas não está limitado a refs/heads/, refs/remotes/, e refs/tags/) ser espelhado para o repositório remoto. As refs locais recém-criadas serão enviadas para a extremidade remota, as refs atualizadas localmente serão atualizadas à força na extremidade remota e as refs excluídas serão removidas da extremidade remota. Esse é o padrão se a opção de configuração remote.<remote>.mirrorestiver definida.

Fiz um alias para fazer o push:

git config --add alias.bak "push --mirror github"

Então, eu apenas corro git baksempre que quero fazer um backup.

[Apenas deixando isso aqui para minha própria referência.]

Meu script de pacote chamado se git-backupparece com isso

#!/usr/bin/env ruby
if __FILE__ == $0
        bundle_name = ARGV[0] if (ARGV[0])
        bundle_name = `pwd`.split('/').last.chomp if bundle_name.nil? 
        bundle_name += ".git.bundle"
        puts "Backing up to bundle #{bundle_name}"
        `git bundle create /data/Dropbox/backup/git-repos/#{bundle_name} --all`
end

Às vezes eu uso git backupe às vezes uso, o git backup different-nameque me dá a maioria das possibilidades de que preciso.

As duas respostas para essas perguntas estão corretas, mas ainda estava faltando uma solução completa e curta para fazer backup de um repositório do Github em um arquivo local. A essência está disponível aqui, sinta-se à vontade para usar ou se adaptar às suas necessidades.

backup.sh:

#!/bin/bash
# Backup the repositories indicated in the command line
# Example:
# bin/backup user1/repo1 user1/repo2
set -e
for i in $@; do
  FILENAME=$(echo $i | sed 's/\//-/g')
  echo "== Backing up $i to $FILENAME.bak"
  git clone git@github.com:$i $FILENAME.git --mirror
  cd "$FILENAME.git"
  git bundle create ../$FILENAME.bak --all
  cd ..
  rm -rf $i.git
  echo "== Repository saved as $FILENAME.bak"
done

restore.sh:

#!/bin/bash
# Restore the repository indicated in the command line
# Example:
# bin/restore filename.bak
set -e

FOLDER_NAME=$(echo $1 | sed 's/.bak//')
git clone --bare $1 $FOLDER_NAME.git

Você pode fazer backup do repositório git com git-copy . O git-copy salvou o novo projeto como um repositório simples, significa custo mínimo de armazenamento.

git copy /path/to/project /backup/project.backup

Em seguida, você pode restaurar seu projeto com git clone

git clone /backup/project.backup project

Encontre o caminho oficial simples, depois de percorrer as paredes do texto acima, que faria você pensar que não há.

Crie um pacote completo com:

$ git bundle create <filename> --all

Restaure-o com:

$ git clone <filename> <folder>

Esta operação é AFAIK atômica. Verifique os documentos oficiais para obter detalhes detalhados.

Em relação ao "zip": os pacotes configuráveis ​​do git são compactados e surpreendentemente pequenos em comparação com o tamanho da pasta .git.

chegou a esta pergunta via google.

Aqui está o que eu fiz da maneira mais simples.

git checkout branch_to_clone

crie um novo ramo git a partir deste ramo

git checkout -b new_cloned_branch
Switched to branch 'new_cloned_branch'

volte ao ramo original e continue:

git checkout branch_to_clone

Supondo que você tenha estragado tudo e precise restaurar algo do ramo de backup:

git checkout new_cloned_branch -- <filepath>  #notice the space before and after "--"

Melhor parte, se algo estiver errado, você pode simplesmente excluir o ramo de origem e voltar ao ramo de backup !!