push vs. bundle vs. tar zcvf -- to backup entire local .git

I can backup my local .git by pushing it to a repository in two steps:

git push --all ~/gitrepo
git push --tags ~/gitrepo

I can back it up using git bundle.

I can back it up by simply copying the ent开发者_StackOverflow社区ire directory or archiving it (compressed!):

tar -zcvf gitrepo.tgz .git

And there are probably additional ways to backup an entire local .git.

The question now is whether they are really equivalent? (for example, the logs subdirectory isn't pushed)

What are the advantages of the git push method vs. git bundle?

Can tar -zcvf be considered "the perfect git backup"?

I use Git bundle

git bundle create /tmp/backup.git --all --tags --remotes

You can receive it as if it were a repo:

cd myworktree
git pull /tmp/backup.git

But also see

• How to update a git clone --mirror?
• "fetch --all" in a git bare repository doesn't synchronize local branches to the remote ones
• Git doesn't clone all branches on subsequent clones?

Completeness, notes

For complete backup (thing of git-rerere cache, stashes, hooks, configuration files) I suggest using rsync

rsync -hxPavilyzH --stats --delete .git/ backup@remote:/repo/mirror.git/

Alternatively:

• Is it possible to push a git stash to a remote repository?
• copy the rerere cache directory

Regarding tar: It saves everything: the config (remote URLs), the reflogs, etc. You might want the reflogs if you accidentally do something really stupid in your repository and your hard drive crashes shortly afterwards. Far-fetched, but tar is easy and it does everything. Use tar for making backups, use git push for making mirrors. These are different kinds of tasks.

Regarding compression: I have a 27M git repo, almost entirely plain text, and the .tar.gz is... also 27M. That's not a whole lot of savings.

The tar method is a possibility, but it won't check the integrity of the saved repo: you won't know if that compressed repo would work until you uncompress it and try to clone or fetch from it.

I prefer the clone --mirror approach (with reflogs enabled in the resulting bare repo).
And the incremental backups are then simple push.
As debated in this old thread, a git stash before a backup might allow you to save more (index and working tree state)