Guia de visão · backup de código

Seus repos protegidos contra bloqueio e invasão

Se a sua conta sumir amanhã, o seu código continua seu. Um plano em camadas, simples e quase todo grátis.

Banner: seus repos protegidos — backup em camadas contra bloqueio e invasão
Em resumo

Este é um guia para quem guarda código no GitHub (ou em qualquer serviço parecido) e quer estar pronto para o dia em que a conta for bloqueada ou invadida. Ele explica por que copiar tudo para outra conta do mesmo serviço protege pouco e mostra um desenho em três camadas: uma cópia em outra empresa, fotos datadas num disco seu e, se quiser, um servidor próprio. Traz os comandos do git para cada passo, os limites dos planos grátis e o que mudaria se você saísse do GitHub de vez. Não precisa instalar nada para ler: é a visão e o método, prontos para você aplicar.

Vídeo

Assista ao vídeo

O plano em 3 minutos e meio, do problema aos três passos para hoje.

▶ Abrir no YouTube

O problema

Tudo num lugar só é um ponto único de falha

Código, histórico, páginas publicadas, automações e deploy costumam morar no mesmo serviço. Basta um evento para tirar tudo do ar.

Banner em grade: outra conta não basta, GitLab sem vínculo, fotos datadas, Forgejo na VPS, teste a volta, limites dos planos

🚫 Bloqueio da conta

Uma denúncia, um robô antifraude, um engano de política. A conta fica suspensa e você não consegue nem baixar o que é seu.

🕵️ Invasão

Alguém pega um token ou a senha e apaga repositórios, ou reescreve o histórico com um push --force.

💻 "Tenho as pastas aqui"

Não é backup. Falta o que você não clonou, faltam branches, e o seu computador também pode ser o alvo da invasão.

A primeira ideia: duplicar para outra conta do GitHub

Tecnicamente é fácil, e o --mirror copia tudo: commits, branches e tags. O problema é onde a cópia fica.

git clone --mirror https://github.com/conta-original/projeto.git
cd projeto.git
git push --mirror https://github.com/conta-backup/projeto.git
# antes, crie o repo vazio na conta de backup (o GitHub não cria no push)
# o aviso "deny updating a hidden ref" nos refs/pull/* é esperado: são os PRs

No celular, arraste as tabelas para o lado.

CenárioA outra conta no GitHub salva?Por quê
BloqueioTalvez nãoÉ a mesma empresa. Contas ligadas pelo mesmo e-mail, telefone ou máquina podem cair juntas. E os termos limitam o número de contas grátis por pessoa.
InvasãoNãoSe a mesma máquina guarda os tokens das duas contas, quem invade pega os dois e apaga o original e a cópia.
Estrago no repoNãoUm espelho que sincroniza sozinho copia o estrago (repo apagado, histórico reescrito) na rodada seguinte.
O que vai e o que não vai numa cópia git. Vai: código, histórico, branches e tags. A wiki é um repo à parte (projeto.wiki.git): só vem se você clonar ela também. Não vai: issues, pull requests, comentários, estrelas, releases com anexos, secrets, webhooks e a configuração do Pages. Arquivos em Git LFS precisam de git lfs fetch --all + git lfs push --all.
As camadas

A regra de ouro do backup: 3-2-1

Uma cópia só protege se estiver em outro lugar, com outra chave e com versões antigas guardadas.

3

cópias dos seus dados: a original + 2

2

lugares diferentes: por exemplo, nuvem e disco

1

fora de casa: se a casa pegar fogo, ela sobrevive

E uma quarta regra para invasão: pelo menos uma cópia que a sua máquina do dia a dia não consegue apagar. No desenho abaixo, quem cumpre essa regra é a cópia fora de casa que a VPS puxa (passo 7).

O desenho recomendado

Você continua trabalhando no GitHub como sempre. Todo dia, uma rotina copia tudo para três lugares.

GitHub (onde você trabalha)→ GitLab (outra empresa)+ Fotos datadas no disco+ Forgejo na VPS (opcional)
1

GitLab, numa conta sem vínculo

Outra empresa: um bloqueio no GitHub não chega lá. Conta com e-mail, telefone e 2FA novos, repos privados e um token que envia código mas não apaga projetos.

2

Fotos datadas no seu disco

Um espelho de cada repo num HD seu, mais uma "foto" por dia. Repo apagado ou estragado lá fora não apaga as fotos antigas: você volta ao dia que quiser.

3

Forgejo numa VPS (opcional)

Um "GitHub seu", num servidor alugado. Nenhuma empresa pode bloquear. Pede manutenção, por isso é a terceira cópia, não a única. Instalação (binário ou Docker): forgejo.org/docs; depois, o envio é igual ao do GitLab, só muda o endereço.

Antes de começar

O que você precisa

Nada pago. O git já resolve quase tudo.

git e gh instalados

O git em qualquer Linux, Mac ou Windows. O gh é o programa de linha de comando do GitHub: lista os seus repos e dá acesso aos privados.

git --version
gh auth login

Um disco com espaço

Some o tamanho dos seus repos e reserve umas 3 vezes isso para as fotos. Um HD externo serve. Os exemplos usam a pasta /backup; crie uma vez e torne-a sua.

df -h   # espaço livre
sudo mkdir -p /backup && sudo chown $USER /backup

Uma conta nova no GitLab

Em gitlab.com, com e-mail e telefone que você não usa nas outras contas, e 2FA ligado.

# gitlab.com → Register
Passo a passo

Do zero ao backup testado

Os comandos abaixo usam conta, projeto e /backup como exemplo: troque pelos seus nomes e pastas.

1

Feche as portas antes (prevenção)

É barato e evita a maior parte dos problemas.

  • 2FA em todas as contas, de preferência com app ou chave física, não SMS.
  • Apague tokens e chaves SSH antigos que você não usa mais.
  • Use tokens "fine-grained": só as permissões necessárias e com prazo de validade.
  • Proteção de branch (bloquear push --force e exclusão) nos repos que importam. No GitHub grátis ela só existe em repos públicos; nos privados, exige plano pago. No GitLab, a branch principal já nasce protegida.
2

Crie a conta de backup sem vínculo

No GitLab, com e-mail, telefone e 2FA diferentes das suas outras contas. Nunca a adicione como colaboradora das outras contas, não faça fork e não ative Pages. Você não precisa criar os projetos um por um: no primeiro envio, o GitLab cria o projeto privado sozinho ("push to create").

3

Um token que envia, mas não apaga

No GitLab, clique no seu avatar → Edit profile → Access tokens (Personal access tokens) e crie um token só com os escopos read_repository e write_repository e com data de validade. Sem o escopo api, ele não consegue apagar projetos.

No GitHub, crie também um token fine-grained só de leitura (Settings → Developer settings → Fine-grained tokens, todos os repos, permissão Contents: Read-only). É ele que a rotina usa no cron, onde o login normal do gh (guardado no chaveiro do sistema) não funciona.

Guarde os dois num arquivo que só você lê. O read -s pede o token sem mostrar na tela e sem gravar no histórico do terminal:

mkdir -p ~/.config/backup-repos
read -rs -p "token do GitLab: " T1; echo
read -rs -p "token do GitHub: " T2; echo
printf 'GITLAB_TOKEN=%s\nGH_TOKEN=%s\n' "$T1" "$T2" > ~/.config/backup-repos/tokens.env
chmod 600 ~/.config/backup-repos/tokens.env; unset T1 T2

O que ele não impede: quem invadir a máquina ainda pode enviar commits ou sobrescrever branches não protegidas. No GitLab, só a branch principal nasce protegida (as outras aceitam push --force e podem ser apagadas pelo token). Ela recusa o push --force, e é por isso que a rotina do passo 7 avisa quando o GitLab recusa algo. O resto quem cobre são as fotos datadas do passo 5.

4

Monte o espelho local de cada repo

Um clone --mirror guarda todas as branches e tags. Depois, a rotina diária só atualiza. Para repos privados, rode uma vez gh auth setup-git: o git passa a pedir a senha ao gh, que usa o GH_TOKEN do arquivo.

mkdir -p /backup/espelho
git clone --mirror https://github.com/conta/projeto.git /backup/espelho/projeto.git
# todo dia:
git -C /backup/espelho/projeto.git remote update --prune
5

Tire a foto do dia

Um git bundle é um arquivo único com o repo inteiro. O git não cria a pasta sozinho, por isso o mkdir -p.

DIA=$(date +%F)                          # ex.: 2026-11-05
mkdir -p /backup/fotos/$DIA
git -C /backup/espelho/projeto.git bundle create /backup/fotos/$DIA/projeto.bundle --all
git -C /backup/espelho/projeto.git bundle verify /backup/fotos/$DIA/projeto.bundle   # confere o arquivo
# alternativa: um snapshot da pasta /backup/espelho com restic ou borg
6

Envie para o GitLab

Envie as branches e as tags (--all + --tags), e não o --mirror. Assim, uma branch apagada no GitHub não é apagada na cópia, e as referências internas de pull request (refs/pull/*), que dariam erro, ficam de fora.

set -a; source ~/.config/backup-repos/tokens.env; set +a
U="https://oauth2:$GITLAB_TOKEN@gitlab.com/conta-backup/projeto.git"
git -C /backup/espelho/projeto.git push "$U" --all
git -C /backup/espelho/projeto.git push "$U" --tags
7

Junte tudo numa rotina para todos os repos

Um script percorre a lista de repos da sua conta, faz os passos 4 a 6 em cada um, apaga fotos antigas e registra as falhas. Salve como /backup/rotina-diaria.sh e rode chmod +x nele. Troque as duas contas no topo.

#!/usr/bin/env bash
# rotina-diaria.sh — espelho + foto do dia + envio ao GitLab
set -u
CONTA=sua-conta-github; GL=sua-conta-gitlab
set -a; source ~/.config/backup-repos/tokens.env; set +a   # GITLAB_TOKEN e GH_TOKEN
BASE=/backup; DIA=$(date +%F); FALHAS=0
mkdir -p "$BASE/espelho" "$BASE/fotos/$DIA"
# se a lista falhar ou vier vazia, para e registra: nunca grava "0 falha(s)" sem ter copiado nada
LISTA=$(gh repo list "$CONTA" --limit 2000 --json name -q '.[].name') && [ -n "$LISTA" ] || { echo "$DIA: ERRO gh repo list falhou" >> "$BASE/rotina.log"; exit 1; }
for R in $LISTA; do
  E="$BASE/espelho/$R.git"
  [ -d "$E" ] || git clone -q --mirror "https://github.com/$CONTA/$R.git" "$E"
  git -C "$E" remote update --prune >/dev/null || { echo "falhou atualizar $R"; FALHAS=$((FALHAS+1)); continue; }
  [ -n "$(git -C "$E" for-each-ref)" ] || continue          # repo vazio: nada a guardar
  git -C "$E" bundle create -q "$BASE/fotos/$DIA/$R.bundle" --all || { echo "foto falhou $R"; FALHAS=$((FALHAS+1)); }
  U="https://oauth2:$GITLAB_TOKEN@gitlab.com/$GL/$R.git"
  { git -C "$E" push -q "$U" --all && git -C "$E" push -q "$U" --tags; } || { echo "GitLab recusou $R"; FALHAS=$((FALHAS+1)); }
done
# rotação: apaga fotos com mais de 35 dias, menos as do dia 01 (ficam como mensais; apague à mão as muito antigas)
find "$BASE/fotos" -mindepth 1 -maxdepth 1 -type d -mtime +35 ! -name '*-01' -exec rm -rf {} +
echo "$DIA: $FALHAS falha(s)" >> "$BASE/rotina.log"

Antes da primeira cópia completa, duas conferências. Primeiro, teste com 3 repos: faça os passos 4 a 6 à mão em 3 deles e a volta do passo 8; só siga se os números baterem. Depois, veja os maiores repos: o GitLab grátis aceita até 10 GiB por projeto e 5 GiB por envio. O comando abaixo lista os 5 maiores, em KB (estimativa do próprio GitHub). Um repo acima do limite fica só nas fotos e na cópia fora de casa, e a rotina vai registrar "GitLab recusou" para ele todo dia.

gh repo list sua-conta-github --limit 2000 --json name,diskUsage -q '.[] | "\(.diskUsage) \(.name)"' | sort -n | tail -5

Aí sim, rode a rotina uma vez à mão (/backup/rotina-diaria.sh) antes de pôr no relógio: com centenas de repos, a primeira vez pode levar horas. Depois, no cron (crontab -e), com o PATH na primeira linha, porque o cron não carrega o do terminal:

PATH=/usr/local/bin:/usr/bin:/bin
0 3 * * * /backup/rotina-diaria.sh >> /backup/cron.log 2>&1

Para ver se rodou: tail /backup/cron.log e tail /backup/rotina.log.

Repos de organização ou de clientes: o gh repo list "$CONTA" só lista os repos que são da sua conta. Os de uma organização (ou de clientes que te deram acesso) ficam de fora sem aviso. Rode o script uma vez para cada dono (troque CONTA pelo nome da organização) e, no token do GitHub, escolha cada dono em Resource owner ou crie um token por dono.

Fora de casa, sem dar a chave ao invasor: quem copia é a VPS, puxando as fotos da sua máquina uma vez por semana. Assim a sua máquina não tem acesso nenhum à VPS e não consegue apagar essa cópia. A VPS precisa alcançar a sua máquina por SSH (por exemplo, pelo Tailscale). Este cron fica na VPS:

0 5 * * 0 rsync -a usuario@sua-maquina:/backup/fotos/ /backup/fotos/

Cuidado: a VPS passa a entrar na sua máquina. Na chave dela (no ~/.ssh/authorized_keys da sua máquina), restrinja a só leitura das fotos com command="rrsync -ro /backup/fotos"; com essa trava, o caminho passa a ser relativo à pasta liberada e o cron da VPS fica 0 5 * * 0 rsync -a usuario@sua-maquina:/ /backup/fotos/. O rrsync vem com o rsync 3.2.4 ou mais novo (/usr/bin/rrsync); em versões antigas, fica em /usr/share/doc/rsync/scripts/rrsync.gz. Crie antes a pasta /backup/fotos na VPS. Como o rsync roda sem --delete, a VPS nunca apaga fotos: o disco dela só cresce, então limpe de tempos em tempos.

Se a VPS não alcança a sua máquina, a alternativa é o restic com um rest-server --append-only na VPS: a sua máquina consegue acrescentar fotos, mas não apagar.

Olhe o /backup/rotina.log de vez em quando: "0 falha(s)" é o que você quer ver. Se o GitLab recusar um repo todo dia, quase sempre é um push --force legítimo no GitHub (um rebase, por exemplo): confira se foi você e, se foi, libere o force-push daquela branch no GitLab só por uma rodada. Três observações: a rotina não guarda as wikis (para guardar, repita o clone com $R.wiki.git); nem os arquivos em Git LFS (para eles, git lfs fetch --all no espelho); e o token na URL aparece na lista de processos da máquina, então, se ela for compartilhada, use um credential helper do git.

8

Teste a volta (a parte que todo mundo esquece)

Escolha 3 repos, restaure num lugar novo e compare. Backup que nunca foi restaurado é só uma esperança.

git clone --mirror /backup/fotos/2026-11-05/projeto.bundle projeto.git
cd projeto.git
git log --oneline --all | wc -l       # nº de commits: compare com o espelho em /backup/espelho
git for-each-ref | wc -l              # nº de branches + tags: compare também com o espelho
git push https://gitlab.com/conta-nova/projeto.git --all    # sobe as branches para qualquer serviço
git push https://gitlab.com/conta-nova/projeto.git --tags   # e as tags

Compare com o espelho, não com o repo no GitHub: o espelho e a foto carregam também os refs/pull/*, que o repo normal não mostra. Pelo mesmo motivo, a volta usa --all + --tags e não --mirror.

Todo mês, repita. Sorteie 3 repos e restaure da foto mais recente. Um teste só, no começo, não avisa se a rotina quebrou depois.

ls /backup/espelho | shuf -n 3     # sorteia 3 repos para o teste do mês
E as issues, PRs e releases? O git não leva. Para guardar também: o GitHub exporta tudo da sua conta em Settings → Account → Export account data; o gh salva por repo (gh issue list --state all --json number,title,body,comments > issues.json); e o importador do GitLab (New project → Import project → GitHub) traz issues e PRs de um repo de uma vez. Atenção: o importador pede um token do GitHub dentro da conta do GitLab, o que liga as duas contas; se for usar, faça numa terceira conta, não na de backup.
Comparação

Os limites dos planos grátis

Conferido em novembro de 2026. GitHub, GitLab e Codeberg vêm das páginas oficiais; o Bitbucket, de sites de terceiros. Limites mudam: confira antes de decidir.

GitHubGitLab.comCodebergBitbucketForgejo na sua VPS
Tamanho por repo~1 GB recomendado, arquivo máx. 100 MB10 GiB por projeto~750 MiB (acima, pedir)não confirmado: confira o limite atual por workspaceo disco da VPS
Push máximo2 GB5 GiB——sem limite
Repos privadosilimitadosilimitadossó 100 MB no totalilimitadosilimitados
CI (minutos/mês)2.000 em privados, ilimitado em públicos400pequeno, sob pedido50ilimitado
Pages1 GB por site1 GB, domínio própriosimsim (workspace.bitbucket.io)você monta
Usuáriosilimitados5 por grupo privado—5ilimitados
Regras de conteúdogeraisgeraissó software livre; conteúdo de IA restrito; backup não é bem-vindogeraisas suas

✅ GitLab: o lugar da cópia na nuvem

Cabe tudo de quem tem centenas de repos. Os 400 minutos de CI não importam: a cópia não roda CI.

⛔ Codeberg: ótimo, mas não para backup

Feito para software livre. Os termos atuais restringem conteúdo gerado por IA, aceitam pouco privado e não gostam de uso como backup.

🟡 Bitbucket: dá, mas não ganha

Serve para backup puro, mas 50 minutos de CI e 5 usuários não fazem dele uma casa definitiva.

🏠 Forgejo: o mais independente

Sem conta em empresa nenhuma. O preço é cuidar do servidor: atualizações e segurança.

Duas palavras que aparecem muito

⚙️ CI (integração contínua)

Automação que roda sozinha a cada git push: publica a página, roda testes, faz o build. No GitHub chama-se Actions. Quem executa é um "runner": a máquina do serviço gasta "minutos por mês"; a sua própria, não. Para backup, CI não importa.

🏗️ Forgejo

Programa livre que funciona como um "GitHub seu", instalado no seu servidor: repos, issues, pull requests, wiki e releases. É o que roda por trás do Codeberg. Leve: cabe numa VPS pequena. Tem CI próprio (Forgejo Actions), quase igual ao Actions do GitHub.

E se eu quiser sair de vez?

O que muda numa migração definitiva

É possível, mas mexe em tudo que foi montado em cima do GitHub. Exemplo real de um criador de conteúdo com cerca de 860 repos:

O que existe hojeO que muda
~690 links usuario.github.io/... no site, em grupos e em descrições de vídeoViram usuario.gitlab.io/projeto. Os links antigos quebram, e descrição de vídeo e mensagem de grupo não se corrigem em massa.
Páginas bem posicionadas no GoogleRecomeçam do zero no endereço novo.
~320 repos com workflows do ActionsNo GitLab, cada um vira .gitlab-ci.yml; no plano grátis são só 400 minutos/mês, a menos que você rode um runner próprio.
~20 sites com deploy pelo VercelO Vercel aceita GitLab, mas é preciso religar um por um. O Codeberg não conecta.
~70 scripts que usam o ghTrocam para glab (GitLab) ou para a API do Forgejo.
Comunidade, estrelas, descoberta de projetosFicam no GitHub.

➕ Ganhos de migrar

Independência de uma empresa só; CI, registro de imagens e Pages num só lugar no GitLab; a opção de hospedar o próprio servidor depois; outra política de dados.

🎯 A conclusão

Para quem já está grande no GitHub, migrar de vez custa muito para um ganho que o backup em camadas já entrega. Faça o backup e mude o que realmente prende você: o endereço das páginas.

O passo que tira a dependência de verdade: domínio próprio. Coloque as páginas novas atrás de um endereço seu (ex.: guias.seudominio.com/projeto). Se um dia trocar de serviço, você muda o DNS e nenhum link quebra.
Glossário

Os termos, em uma linha

Para quem está começando.

Repositório (repo)
A pasta do projeto com todo o histórico de mudanças, gerenciada pelo git.
Espelho (--mirror)
Cópia completa de um repo, com todas as branches e tags, que pode ser atualizada.
Bundle
Um arquivo único que contém um repo inteiro; dá para clonar a partir dele.
Token
Uma "senha de máquina" com permissões limitadas, usada por scripts.
Fine-grained token
Token em que você escolhe o que ele pode fazer, em quais repos e até quando.
2FA
Verificação em duas etapas: senha + app ou chave física.
CI / runner
Automação a cada push / a máquina que executa essa automação.
Pages
Hospedagem grátis de site estático a partir de um repo.
Forgejo
Programa livre para ter o seu próprio "GitHub" num servidor.
VPS
Servidor alugado na nuvem, só seu.
push --force
Envio que sobrescreve o histórico do outro lado; é como um invasor apaga trabalho.
Branch protegida
Branch em que o serviço recusa push --force e exclusão.
Git LFS
Extensão do git para arquivos grandes (vídeo, modelo, dataset), guardados à parte.
cron / timer do systemd
O "despertador" do Linux: roda um comando sozinho no horário marcado.
restic / borg
Programas de backup que guardam fotos datadas de uma pasta sem repetir o que não mudou.
SSH / rsync
Acesso seguro a outro computador / cópia de pastas que só envia o que mudou.
gh / glab
Programas de linha de comando do GitHub / do GitLab.
Deploy / Vercel
Publicar o site no ar / um serviço que publica sites a cada push.
DNS / domínio próprio
O "catálogo de endereços" da internet / um endereço seu (ex.: seudominio.com) que você aponta para onde quiser.
Escopo do token
O que o token pode fazer: read_repository lê, write_repository envia, api faz tudo (inclusive apagar).
Push to create
No GitLab, enviar para um endereço que ainda não existe cria o projeto, privado.
refs/pull/*
Referências internas que o GitHub cria para cada pull request; vêm no --mirror e não podem ser enviadas de volta.
remote update --prune
Atualiza o espelho e remove dele as branches que sumiram do original (as fotos antigas ainda as têm).
Fork / colaborador
Cópia ligada ao repo original / pessoa com acesso ao repo de outra conta. Os dois criam vínculo entre contas.
Append-only
Destino de backup que aceita coisas novas, mas não deixa apagar nem alterar as antigas.
Tailscale
Rede privada que liga os seus aparelhos pela internet como se estivessem na mesma casa.
Chave SSH
Par de arquivos que substitui a senha no acesso a outro computador.
Credential helper
Recurso do git que guarda e entrega a senha/token sem deixá-la na linha de comando.
Rebase
Reescrever o histórico de uma branch para reorganizar commits; depois dele, o envio precisa de push --force.
3-2-1
3 cópias, 2 lugares, 1 fora de casa.
Próximos passos

Como aplicar sem se perder

A ordem que dá resultado mais rápido.

Hoje
Prevenção2FA em tudo, faxina de tokens e chaves, proteção de branch nos repos importantes.
Semana 1
Espelho + fotos no discoEspelho local de todos os repos, foto diária e o primeiro teste de restauração com 3 repos.
Semana 2
Cópia no GitLabConta sem vínculo, token só de envio (read_repository + write_repository) e envio diário; o GitLab cria cada projeto privado no primeiro envio.
Depois
Fora de casa e domínio próprioA VPS puxando as fotos toda semana (ou um Forgejo), e as páginas novas atrás de um domínio seu.

Fontes: GitLab.com settings · GitLab Storage · Codeberg FAQ · Codeberg Termos de Uso · GitHub: arquivos grandes · Codeberg e conteúdo de IA · Forgejo