Guía general · copias de seguridad de código

Tus repos protegidos contra bloqueos e invasiones

Si mañana desaparece tu cuenta, el código sigue siendo tuyo. Un plan por capas, sencillo y casi totalmente gratis.

Banner: tus repos protegidos — copias de seguridad en capas contra bloqueos e invasiones
En resumen

Esta guía es para quienes guardan código en GitHub (o en un servicio parecido) y quieren estar preparados para el día en que bloqueen o vulneren su cuenta. Explica por qué copiar todo a otra cuenta del mismo servicio ofrece poca protección y presenta un plan de tres capas: una copia en otra empresa, copias fechadas en un disco propio y, si quieres, un servidor propio. Incluye los comandos de git para cada paso, los límites de los planes gratis y qué cambiaría si dejaras GitHub de una vez. No hace falta instalar nada para leerla: aquí tienes la idea y el método, listos para ponerlos en práctica.

Video

Ver el video

El plan en tres minutos y medio, del problema a los tres pasos para hoy (en portugués).

▶ Abrir en YouTube

El problema

Tener todo en un solo lugar crea un punto único de falla

El código, el historial, las páginas publicadas, las automatizaciones y el deploy suelen estar en el mismo servicio. Un solo incidente puede dejarlo todo fuera de línea.

Banner en cuadrícula: otra cuenta no basta, GitLab sin vínculos, copias fechadas, Forgejo en la VPS, prueba la restauración, límites de los planes

🚫 Bloqueo de la cuenta

Una denuncia, un robot antifraude, un error de política. La cuenta queda suspendida y ni siquiera puedes descargar lo que es tuyo.

🕵️ Invasión

Alguien obtiene un token o la contraseña y borra repositorios, o reescribe el historial con un push --force.

💻 «Tengo las carpetas aquí»

Eso no es una copia de seguridad. Falta lo que no clonaste, faltan ramas y tu computadora también puede ser el blanco de una invasión.

La primera idea: duplicar todo en otra cuenta de GitHub

Técnicamente es fácil y --mirror copia todo: commits, ramas y etiquetas. El problema es dónde queda la copia.

git clone --mirror https://github.com/conta-original/projeto.git
cd projeto.git
git push --mirror https://github.com/conta-backup/projeto.git
# primero, crea el repo vacío en la cuenta de backup (GitHub no lo crea al hacer push)
# el aviso "deny updating a hidden ref" en refs/pull/* es esperado: son los PR

En el celular, desliza las tablas hacia un lado.

Escenario¿La otra cuenta de GitHub sirve?Por qué
BloqueoTal vez noEs la misma empresa. Las cuentas vinculadas por el mismo correo, teléfono o computadora pueden caer juntas. Además, los términos limitan el número de cuentas gratis por persona.
InvasiónNoSi la misma computadora guarda los tokens de las dos cuentas, quien la invada obtiene ambos y borra el original y la copia.
Daño al repoNoUn espejo que se sincroniza solo copia el daño (repo borrado, historial reescrito) en la siguiente ejecución.
Qué incluye y qué no incluye una copia de git. Incluye: código, historial, ramas y etiquetas. La wiki es un repo aparte (projeto.wiki.git): solo se incluye si también la clonas. No incluye: issues, pull requests, comentarios, estrellas, releases con archivos adjuntos, secrets, webhooks ni la configuración de Pages. Los archivos en Git LFS necesitan git lfs fetch --all + git lfs push --all.
Las capas

La regla de oro de las copias de seguridad: 3-2-1

Una copia solo protege si está en otro lugar, tiene otra clave y conserva versiones anteriores.

3

copias de tus datos: el original + 2

2

lugares diferentes: por ejemplo, la nube y un disco

1

fuera de casa: si la casa se incendia, sobrevive

Y una cuarta regla contra las invasiones: al menos una copia que tu computadora de todos los días no pueda borrar. En el plan de abajo, la copia que cumple esta regla es la copia fuera de casa que descarga la VPS (paso 7).

El plan recomendado

Sigues trabajando en GitHub como siempre. Todos los días, una rutina copia todo en tres lugares.

GitHub (donde trabajas)→ GitLab (otra empresa)+ Copias fechadas en el disco+ Forgejo en la VPS (opcional)
1

GitLab, en una cuenta sin vínculos

Otra empresa: un bloqueo en GitHub no llega hasta allí. Cuenta con correo, teléfono y 2FA nuevos, repos privados y un token que envía código, pero no puede borrar proyectos.

2

Copias fechadas en tu disco

Un espejo de cada repo en un disco tuyo, más una «foto» por día. Si borran o dañan un repo allá afuera, las fotos antiguas siguen intactas: puedes volver al día que quieras.

3

Forgejo en una VPS (opcional)

Un «GitHub tuyo» en un servidor alquilado. Ninguna empresa puede bloquearlo. Requiere mantenimiento, por eso es la tercera copia y no la única. Instalación (binario o Docker): forgejo.org/docs; después, el envío es igual que en GitLab, solo cambia la dirección.

Antes de empezar

Qué necesitas

No hace falta pagar. git resuelve casi todo.

git y gh instalados

git en cualquier Linux, Mac o Windows. gh es el programa de línea de comandos de GitHub: muestra tus repos y permite acceder a los privados.

git --version
gh auth login

Un disco con espacio

Suma el tamaño de tus repos y reserva unas 3 veces esa cantidad para las fotos. Sirve un disco externo. Los ejemplos usan la carpeta /backup; créala una vez y úsala como propia.

df -h   # espacio libre
sudo mkdir -p /backup && sudo chown $USER /backup

Una cuenta nueva en GitLab

En gitlab.com, con un correo y un teléfono que no uses en tus otras cuentas, y con 2FA activado.

# gitlab.com → Register
Paso a paso

De cero a una copia de seguridad probada

Los comandos de abajo usan conta, projeto y /backup como ejemplo: reemplázalos por tus nombres y carpetas.

Los nombres de carpetas y variables de los comandos están en portugués a propósito; puedes cambiarlos por los que quieras.

1

Cierra las puertas antes (prevención)

Cuesta poco y evita la mayoría de los problemas.

  • Activa 2FA en todas las cuentas, de preferencia con una app o una llave física, no por SMS.
  • Borra los tokens y las claves SSH antiguas que ya no uses.
  • Usa tokens «fine-grained»: solo los permisos necesarios y con fecha de vencimiento.
  • Activa la protección de ramas (bloquear push --force y la eliminación) en los repos importantes. En GitHub gratis solo existe en repos públicos; para los privados se necesita un plan de pago. En GitLab, la rama principal ya viene protegida.
2

Crea una cuenta de copia de seguridad sin vínculos

En GitLab, con un correo, teléfono y 2FA distintos a los de tus otras cuentas. Nunca la agregues como colaboradora de las otras cuentas, no hagas un fork ni actives Pages. No necesitas crear los proyectos uno por uno: con el primer envío, GitLab crea el proyecto privado automáticamente («push to create»).

3

Un token que envía, pero no borra

En GitLab, haz clic en tu avatar → Edit profile → Access tokens (Personal access tokens) y crea un token solo con los permisos read_repository y write_repository, y con fecha de vencimiento. Sin el permiso api, no puede borrar proyectos.

En GitHub, crea también un token fine-grained de solo lectura (Settings → Developer settings → Fine-grained tokens, todos los repos, permiso Contents: Read-only). La rutina lo usa en cron, donde el inicio de sesión normal de gh (guardado en el llavero del sistema) no funciona.

Guarda los dos en un archivo que solo tú puedas leer. read -s pide el token sin mostrarlo en pantalla ni guardarlo en el historial de la 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

Lo que no impide: quien invada tu computadora aún puede enviar commits o sobrescribir ramas sin protección. En GitLab, solo la rama principal viene protegida (las demás aceptan push --force y el token puede borrarlas). La rama principal rechaza el push --force; por eso la rutina del paso 7 avisa cuando GitLab rechaza algo. De lo demás se encargan las copias fechadas del paso 5.

4

Arma el espejo local de cada repo

Un clon --mirror guarda todas las ramas y etiquetas. Después, la rutina diaria solo lo actualiza. Para repos privados, ejecuta una vez gh auth setup-git: git empezará a pedir la contraseña a gh, que usa el GH_TOKEN del archivo.

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

Guarda la copia del día

Un git bundle es un solo archivo con el repo completo. git no crea la carpeta por sí solo, por eso se necesita 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   # verifica el archivo
# alternativa: una instantánea de la carpeta /backup/espelho con restic o borg
6

Envía todo a GitLab

Envía las ramas y las etiquetas (--all + --tags), y no uses --mirror. Así, si borran una rama en GitHub, no se borra en la copia, y las referencias internas de pull request (refs/pull/*), que darían error, quedan fuera.

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

Reúne todo en una rutina para todos tus repos

Un script recorre la lista de repos de tu cuenta, completa los pasos 4 al 6 para cada uno, borra las fotos antiguas y registra los errores. Guárdalo como /backup/rotina-diaria.sh y ejecuta chmod +x. Cambia las dos cuentas de la parte superior.

#!/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 de la primera copia completa, haz dos comprobaciones. Primero, prueba con 3 repos: haz los pasos 4 a 6 a mano en 3 de ellos y la restauración del paso 8; continúa solo si las cifras coinciden. Después, revisa los repos más grandes: GitLab gratis acepta hasta 10 GiB por proyecto y 5 GiB por envío. El comando de abajo muestra los 5 más grandes, en KB (estimación del propio GitHub). Un repo que supere el límite se queda solo en las fotos y en la copia fuera de casa, y la rutina registrará "GitLab recusou" (GitLab rechazó) para él cada día.

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

Ahora sí, ejecuta el script a mano una vez (/backup/rotina-diaria.sh) antes de programarlo: con cientos de repos, la primera vez puede tardar horas. Después, en cron (crontab -e), agrega el PATH en la primera línea, porque cron no carga el del terminal:

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

Para saber si se ejecutó: tail /backup/cron.log y tail /backup/rotina.log.

Repositorios de una organización o de clientes: gh repo list "$CONTA" solo muestra los repos de tu cuenta. Los de una organización (o de clientes que te dieron acceso) quedan fuera sin aviso. Ejecuta el script una vez por cada propietario (cambia CONTA por el nombre de la organización) y, en el token de GitHub, elige cada propietario en Resource owner o crea un token por propietario.

Fuera de casa, sin darle la llave a quien invada: la VPS descarga las fotos de tu computadora una vez por semana. Así, tu computadora no tiene ningún acceso a la VPS y no puede borrar esa copia. La VPS necesita conectarse a tu computadora por SSH (por ejemplo, con Tailscale). Este cron va en la VPS:

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

Ten en cuenta que la VPS pasa a tener acceso a tu computadora. En su clave (en el ~/.ssh/authorized_keys de tu computadora), limita el acceso a solo lectura de las fotos con command="rrsync -ro /backup/fotos"; con esa restricción, la ruta pasa a ser relativa a la carpeta autorizada y el cron de la VPS queda 0 5 * * 0 rsync -a usuario@sua-maquina:/ /backup/fotos/. rrsync viene con rsync 3.2.4 o posterior (/usr/bin/rrsync); en las versiones anteriores, está en /usr/share/doc/rsync/scripts/rrsync.gz. Primero crea la carpeta /backup/fotos en la VPS. Como rsync se ejecuta sin --delete, la VPS nunca borra fotos: su disco solo crece, así que límpialo de vez en cuando.

Si la VPS no puede conectarse a tu computadora, la alternativa es usar restic con un rest-server --append-only en la VPS: tu computadora puede agregar fotos, pero no borrarlas.

Revisa el archivo /backup/rotina.log de vez en cuando: lo que quieres ver es «0 falha(s)». Si GitLab rechaza un repo todos los días, casi siempre se debe a un push --force legítimo en GitHub (un rebase, por ejemplo): confirma que lo hiciste tú y, si fue así, permite el force-push de esa rama en GitLab solo durante una ejecución. Tres observaciones: la rutina no guarda las wikis (para guardarlas, repite el clon con $R.wiki.git); tampoco guarda los archivos en Git LFS (para eso, ejecuta git lfs fetch --all en el espejo); además, el token de la URL aparece en la lista de procesos de la computadora, así que, si es compartida, usa un credential helper de git.

8

Prueba la restauración (la parte que todos olvidan)

Elige 3 repos, restáuralos en un lugar nuevo y compara. Una copia de seguridad que nunca se ha restaurado es solo una esperanza.

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

Compara con el espejo, no con el repo de GitHub: el espejo y la copia también contienen los refs/pull/*, que el repo normal no muestra. Por la misma razón, la restauración usa --all + --tags y no --mirror.

Repítelo cada mes. Elige 3 repos al azar y restáuralos desde la foto más reciente. Una sola prueba al principio no te avisa si la rutina falla después.

ls /backup/espelho | shuf -n 3     # elige 3 repos para la prueba del mes
¿Y las issues, los PR y los releases? git no los incluye. Para guardarlos también: GitHub exporta todos los datos de tu cuenta en Settings → Account → Export account data; gh guarda los datos por repo (gh issue list --state all --json number,title,body,comments > issues.json); y el importador de GitLab (New project → Import project → GitHub) trae las issues y los PR de un repo de una vez. Atención: el importador pide un token de GitHub dentro de la cuenta de GitLab, lo que vincula ambas cuentas; si lo usas, hazlo en una tercera cuenta, no en la de copia de seguridad.
Comparación

Los límites de los planes gratis

Verificado en noviembre de 2026. Los datos de GitHub, GitLab y Codeberg vienen de sus páginas oficiales; los de Bitbucket, de sitios de terceros. Los límites cambian: compruébalos antes de decidir.

GitHubGitLab.comCodebergBitbucketForgejo en tu VPS
Tamaño por repo~1 GB recomendado, archivo máx. 100 MB10 GiB por proyecto~750 MiB (para más, hay que pedirlo)no confirmado: consulta el límite actual por workspaceel disco de la VPS
Push máximo2 GB5 GiB——sin límite
Repos privadosilimitadosilimitadossolo 100 MB en totalilimitadosilimitados
CI (minutos/mes)2.000 en privados, ilimitado en públicos400pocos, bajo solicitud50ilimitado
Pages1 GB por sitio1 GB, dominio propiosísí (workspace.bitbucket.io)tú lo configuras
Usuariosilimitados5 por grupo privado—5ilimitados
Reglas de contenidogeneralesgeneralessolo software libre; restringe el contenido de IA; las copias de seguridad no son bienvenidasgeneraleslas tuyas

✅ GitLab: el lugar de la copia en la nube

Hay espacio para quienes tienen cientos de repos. Los 400 minutos de CI no importan: la copia no ejecuta CI.

⛔ Codeberg: excelente, pero no para copias

Está pensado para software libre. Sus términos actuales restringen el contenido generado por IA, permiten poco contenido privado y no favorecen su uso como copia de seguridad.

🟡 Bitbucket: funciona, pero no destaca

Sirve para copias puras, pero 50 minutos de CI y 5 usuarios no lo convierten en un hogar definitivo.

🏠 Forgejo: la opción más independiente

No necesitas una cuenta en ninguna empresa. El costo es encargarte del servidor: actualizaciones y seguridad.

Dos términos que aparecen mucho

⚙️ CI (integración continua)

Automatización que se ejecuta sola con cada git push: publica la página, ejecuta pruebas y compila. En GitHub se llama Actions. La ejecuta un «runner»: la máquina del servicio consume «minutos por mes»; la tuya, no. Para las copias de seguridad, CI no importa.

🏗️ Forgejo

Programa libre que funciona como un «GitHub tuyo», instalado en tu servidor: repos, issues, pull requests, wiki y releases. Es lo que funciona detrás de Codeberg. Es ligero: cabe en una VPS pequeña. Tiene su propio CI (Forgejo Actions), casi igual que GitHub Actions.

¿Y si quiero irme definitivamente?

Qué cambia con una migración definitiva

Es posible, pero afecta todo lo que se construyó sobre GitHub. Ejemplo real de un creador de contenido con unos 860 repos:

Lo que existe hoyQué cambia
~690 enlaces usuario.github.io/... en el sitio, en grupos y en descripciones de videosSe convierten en usuario.gitlab.io/projeto. Los enlaces antiguos dejan de funcionar, y no se pueden corregir en bloque las descripciones de videos ni los mensajes de grupo.
Páginas bien posicionadas en GoogleEmpiezan desde cero en la nueva dirección.
~320 repos con workflows de ActionsEn GitLab, cada uno se convierte en .gitlab-ci.yml; el plan gratis da solo 400 minutos al mes, a menos que uses tu propio runner.
~20 sitios con deploy mediante VercelVercel acepta GitLab, pero hay que volver a conectar cada sitio. Codeberg no se conecta.
~70 scripts que usan ghSe cambian por glab (GitLab) o por la API de Forgejo.
Comunidad, estrellas y descubrimiento de proyectosSe quedan en GitHub.

➕ Ventajas de migrar

Independencia de una sola empresa; CI, registro de imágenes y Pages en un solo lugar en GitLab; la opción de alojar tu propio servidor más adelante; otra política de datos.

🎯 La conclusión

Para quienes ya tienen una presencia grande en GitHub, migrar por completo cuesta mucho para obtener algo que las copias en capas ya ofrecen. Haz la copia de seguridad y cambia lo que realmente te ata: la dirección de las páginas.

El paso que de verdad elimina la dependencia: un dominio propio. Publica las páginas nuevas en una dirección tuya (ej.: guias.seudominio.com/projeto). Si algún día cambias de servicio, modificas el DNS y ningún enlace se rompe.
Glosario

Los términos, en una línea

Para quienes están empezando.

Repositorio (repo)
La carpeta del proyecto con todo el historial de cambios, administrada por git.
Espejo (--mirror)
Copia completa de un repo, con todas sus ramas y etiquetas, que se puede actualizar.
Bundle
Un solo archivo que contiene un repo completo; permite clonar desde él.
Token
Una «contraseña de máquina» con permisos limitados, que usan los scripts.
Fine-grained token
Token que te permite elegir qué puede hacer, en qué repos y hasta cuándo.
2FA
Verificación en dos pasos: contraseña + app o llave física.
CI / runner
Automatización que se ejecuta con cada push / la máquina que ejecuta esa automatización.
Pages
Alojamiento gratis de un sitio estático desde un repo.
Forgejo
Programa libre para tener tu propio «GitHub» en un servidor.
VPS
Servidor alquilado en la nube, solo para ti.
push --force
Envío que sobrescribe el historial del otro lado; así puede borrar trabajo quien invade una cuenta.
Rama protegida
Rama en la que el servicio rechaza push --force y la eliminación.
Git LFS
Extensión de git para archivos grandes (video, modelo, dataset), guardados aparte.
cron / timer do systemd
El «despertador» de Linux: ejecuta un comando por sí solo a la hora programada.
restic / borg
Programas de copias de seguridad que guardan copias fechadas de una carpeta sin repetir lo que no cambió.
SSH / rsync
Acceso seguro a otra computadora / copia de carpetas que solo envía lo que cambió.
gh / glab
Programas de línea de comandos de GitHub / GitLab.
Deploy / Vercel
Publicar el sitio en línea / un servicio que publica sitios con cada push.
DNS / dominio propio
El «catálogo de direcciones» de internet / una dirección tuya (ej.: seudominio.com) que puedes apuntar donde quieras.
Permisos del token
Lo que puede hacer el token: read_repository lee, write_repository envía, api hace todo (incluso borrar).
Push to create
En GitLab, enviar a una dirección que todavía no existe crea el proyecto como privado.
refs/pull/*
Referencias internas que GitHub crea para cada pull request; vienen con --mirror y no se pueden volver a enviar.
remote update --prune
Actualiza el espejo y elimina las ramas que desaparecieron del original (las copias antiguas aún las conservan).
Fork / colaborador
Copia vinculada al repo original / persona con acceso al repo de otra cuenta. Ambas cosas crean un vínculo entre cuentas.
Append-only
Destino de copia de seguridad que acepta cosas nuevas, pero no permite borrar ni modificar las antiguas.
Tailscale
Red privada que conecta tus dispositivos por internet como si estuvieran en la misma casa.
Clave SSH
Par de archivos que reemplaza la contraseña para acceder a otra computadora.
Credential helper
Recurso de git que guarda y entrega la contraseña o el token sin dejarlos en la línea de comandos.
Rebase
Reescribir el historial de una rama para reorganizar commits; después, el envío necesita push --force.
3-2-1
3 copias, 2 lugares, 1 fuera de casa.
Próximos pasos

Cómo ponerlo en práctica sin perderte

El orden que da resultados más rápido.

Hoy
Prevención2FA en todo, limpieza de tokens y claves, protección de ramas en los repos importantes.
Semana 1
Espejo + copias en el discoEspejo local de todos los repos, copia diaria y primera prueba de restauración con 3 repos.
Semana 2
Copia en GitLabCuenta sin vínculos, token que solo permite enviar (read_repository + write_repository) y envío diario; GitLab crea cada proyecto privado con el primer envío.
Después
Fuera de casa y dominio propioLa VPS descarga las copias cada semana (o puedes instalar Forgejo) y las páginas nuevas se publican en tu propio dominio.

Fuentes: GitLab.com settings · GitLab Storage · Codeberg FAQ · Términos de uso de Codeberg · GitHub: archivos grandes · Codeberg y el contenido de IA · Forgejo