Git es un sistema de control de versiones que guarda la historia completa de tus archivos. Funciona como una "máquina del tiempo" para tu proyecto. Usa Git como sistema de seguridad y pruebas. Aprende a crear puntos de control, experimentar sin riesgo y gestionar tu repositorio bare local

Git sin miedo: Tu máquina del tiempo personal

Si alguna vez has guardado un archivo como proyecto_final_v2_este_si_bueno.zip, esta guía es para ti. Git no es solo para programadores; es un seguro de vida para cualquier creador de contenido que trabaje con archivos digitales (como tus posts en Zola).

1. El concepto: Git no guarda archivos, guarda "decisiones"

Imagina que tu proyecto es un libro. En lugar de guardar 100 copias del libro, Git anota cada cambio que decides que es "bueno". Si te equivocas, puedes pedirle a Git que deshaga los cambios y te devuelva al minuto exacto en que todo funcionaba.

Los 4 estados de un archivo

Para entender Git, debes entender dónde está tu archivo en cada momento:

  1. Untracked: El archivo existe en la carpeta, pero Git no lo vigila.
  2. Modified: Has hecho cambios en el archivo, pero aún no los has asegurado.
  3. Staged: El archivo está en la "mesa de preparación". Has decidido que estos cambios irán en el próximo guardado.
  4. Committed: El archivo está guardado en la historia de Git. Es un punto seguro.

2. Preparando el terreno: Instalación y Configuración

Antes de empezar, Git necesita saber quién eres para firmar tus "puntos de control".

# Instalación en Linux (Debian/Ubuntu)
sudo apt install git

# Configuración inicial
git config --global user.name "Tu Nombre"
git config --global user.email "tu@email.com"

3. Tu primer flujo de trabajo real

Imagina que estás escribiendo un post en Zola. El flujo siempre será: Escribir → Preparar → Guardar.

Paso 1: Inicializar el proyecto

Entra en tu carpeta y dile a Git que empiece a vigilar.

git init

git init: Crea una carpeta oculta .git donde se guardará toda la historia. Si borras esta carpeta, borras el pasado.

Paso 2: Ver el panel de control

git status

git status: Te dice qué archivos están modificados, cuáles están en la mesa de preparación y cuáles no conoce Git. Úsalo constantemente.

Paso 3: Preparar y Guardar (Commit por tema)

No guardes todo a la vez. Si has arreglado el menú y escrito un post, haz dos guardados distintos.

# 1. Preparamos el archivo
git add content/blog/mi-post.md

git add [archivo]: Mueve el archivo al estado Staged. Es como poner un objeto en una caja antes de cerrarla. Si usas git add ., metes todo lo que haya en la carpeta.

# 2. Guardamos definitivamente
git commit -m "Añadida primera versión del post sobre Git"

git commit: Cierra la "caja" y la guarda en la historia. -m "mensaje": Es obligatorio. Explica qué hiciste. Un buen mensaje te salvará la vida en el futuro.

4. El Laboratorio: Ramas para experimentar

¿Quieres probar un diseño nuevo en tu web de Zola pero te da miedo romper el actual? Usa una Rama.

# Crear y saltar a una rama nueva
git checkout -b prueba-diseno

git checkout: Sirve para saltar entre versiones o ramas. -b: Crea una rama nueva (un universo paralelo). prueba-diseno: El nombre de tu experimento.

Si el experimento sale bien:

git checkout main         # Vuelves a la rama principal
git merge prueba-diseno   # Fusionas el experimento con lo real

Si sale mal:

git checkout main
git branch -D prueba-diseno # Borras el experimento y aquí no ha pasado nada

5. El Repositorio "Bare": Tu Caja Fuerte Local

Un repositorio Bare es un repositorio que no tiene archivos visibles para editar; solo contiene la base de datos de Git. Sirve como backup central.

Crear la caja fuerte

mkdir -p ~/backups/mi-web.git
cd ~/backups/mi-web.git
git init --bare

--bare: Crea un repositorio que solo sirve para recibir y enviar cambios, ideal para copias de seguridad.

Conectar tu trabajo con la caja fuerte

Vuelve a la carpeta de tu proyecto Zola:

git remote add backup ~/backups/mi-web.git

git remote add [nombre] [ruta]: Crea un vínculo entre tu carpeta de trabajo y la caja fuerte.

Enviar los cambios

git push backup main

git push: Envía tus puntos de control guardados al repositorio remoto (en este caso, tu carpeta de backup).

Ampliando estos pasos:

Donde pongo la copia de seguridad bare ?

Para que tu sistema de seguridad sea realmente efectivo, el repositorio Bare (la copia de seguridad) debe estar fuera de la carpeta de tu proyecto.

Si lo pones dentro, y borras la carpeta del proyecto por error, perderías tanto el trabajo como el backup.

Aquí tienes las dos mejores opciones dependiendo de dónde quieras guardar ese "seguro de vida":

Opción A: En el mismo PC (Copia de seguridad local)

Es ideal para tener una "caja fuerte" en otra parte de tu disco duro. Una ruta muy común y limpia es crear una carpeta llamada repos o backups en tu carpeta de usuario.

La ruta recomendada sería:

        ~/repos/cadizpro.git

Cómo crearla y conectarla:

  • Crea el repositorio Bare:

          mkdir -p ~/repos/cadizpro.git
      cd ~/repos/cadizpro.git
      git init --bare

  • Conéctalo desde tu proyecto:

          cd ~/web/cadizpro.com
      git remote add backup ~/repos/cadizpro.git

  • Haz tu primer envío:

          git push backup main
Opción B: En un disco externo o USB (Máxima seguridad)

Si tienes un pendrive o disco duro externo montado, es el mejor sitio. Si por ejemplo tu disco se monta en

  /media/usuario/mi-disco,

podrías ponerlo allí.

La ruta sería:

  /media/usuario/mi-disco/git-backups/cadizpro.git

¿Por qué hacerlo así?

Es importante explicar la arquitectura de esta "Caja Fuerte":

Directorio de trabajo

~/web/cadizpro.com

Es tu taller. Aquí los archivos se pueden tocar, borrar y modificar. Tiene una carpeta .git que es la "caja negra" del avión.

Repositorio Bare

  ~/repos/cadizpro.git

Es la caja fuerte. No tiene archivos sueltos, solo la base de datos de Git. Si tu "taller" sale ardiendo (borras la carpeta accidentalmente), puedes reconstruirlo todo desde aquí con un simple comando git clone.

Cómo se vería tu estructura final:

  /home/usuario/
  ├── repos/                  <-- Tu zona de CAJAS FUERTES
  │   └── cadizpro.git/       <-- Repositorio Bare (Backup)
  └── web/                    <-- Tu zona de TRABAJO
  └── cadizpro.com/       <-- Tu proyecto Zola
        └── .git/           <-- El historial local

El "Salvavidas" en caso de desastre

Si mañana borras

  ~/web/cadizpro.com

por error, solo tendrías que hacer esto para recuperar todo tu historial y archivos:

  git clone ~/repos/cadizpro.git ~/web/cadizpro.com

6. Emergencias: ¿Cómo volver al pasado?

"He borrado un párrafo por error y no he guardado"

git restore archivo.md

git restore: Recupera la versión del archivo tal como estaba en el último guardado (commit).

"Me he equivocado en el último commit (el mensaje o un archivo)"

git reset --soft HEAD~1

git reset: Mueve la línea del tiempo. --soft: Borra el punto de guardado pero mantiene tus cambios intactos en la carpeta para que los corrijas. HEAD~1: Significa "vuelve atrás un paso".

"He roto todo y quiero volver a ayer" (CUIDADO)

git reset --hard abc1234

--hard: Borra todo lo que hayas hecho después de ese punto. Es irreversible. abc1234: Es el código (hash) que sale al escribir git log --oneline.

7. El botón del pánico: Cómo recuperar todo tras un desastre

Imagina el peor escenario: ejecutas un comando por error, un script borra tu carpeta de trabajo o simplemente quieres empezar de cero en otro ordenador.

Si has estado haciendo git push backup main con frecuencia, no tienes de qué preocuparte.

Paso 1: El desastre

Imaginemos que tu carpeta de trabajo ha desaparecido:

  # CUIDADO: Esto es solo un ejemplo de desastre
  # rm -rf ~/web/cadizpro.com
Paso 2: La recuperación (El milagro de clone)

Para recuperar absolutamente todo tu contenido, tus imágenes y, lo más importante, toda tu historia de cambios, solo tienes que pedirle a Git que clone tu "caja fuerte": Bash

  git clone ~/repos/cadizpro.git ~/web/cadizpro.com

¿Qué acaba de pasar?

  • Git ha creado la carpeta cadizpro.com.
  • Ha descargado todos los archivos en su última versión conocida.
  • Ha reconstruido toda la base de datos de seguridad (.git).
  • Ha reconectado automáticamente tu carpeta de trabajo con el backup.
Paso 3: Seguir trabajando

Entras en tu carpeta y todo está tal cual lo dejaste en el último push:

  cd ~/web/cadizpro.com
  zola serve

Checklist final: Tu rutina de seguridad

Para que este sistema sea infalible, grábate este flujo diario: Antes de empezar: Haz un git status para ver dónde te quedaste. Al terminar una tarea:

  git add . 
  y 
  git commit -m "Mensaje descriptivo".

Al apagar el ordenador:

  git push backup main.

Git no es una herramienta para expertos, es una herramienta para personas que valoran su tiempo. La curva de aprendizaje se paga sola el primer día que recuperas un archivo que creías perdido para siempre.

8. Publicación segura en tu VPS. Automatización: Tu botón de "Publicar Todo"

Para Zola, no necesitas subir todo tu código Git al servidor. Solo necesitas la carpeta public/ que genera Zola.

Estrategia recomendada (rsync): Mantén Git para tu seguridad local y usa rsync para subir solo el resultado final:

zola build
rsync -avz --delete public/ usuario@tu-vps:/var/www/html/

Esto mantiene tu historial de Git y tus borradores privados y seguros en tu ordenador, lejos de ojos ajenos en el servidor.

Hacer git add, git commit, git push y luego zola build uno por uno es tedioso. Podemos crear un pequeño script (un archivo de texto con órdenes) que lo haga todo por nosotros. Crear el script de despliegue

Crea un archivo llamado desplegar.sh en la raíz de tu proyecto:

  nano desplegar.sh

Copia y pega este contenido (ajustándolo a tus necesidades):

  #!/bin/bash

  # 1. Detener el script si hay algún error
  set -e

  echo "Iniciando proceso de guardado y publicación..."

  # 2. Guardar cambios en Git
  git add .
  # Le pedimos al usuario que escriba un mensaje para el commit
  read -p "Escribe el mensaje del commit: " mensaje
  git commit -m "$mensaje"

  # 3. Subir a nuestra "Caja Fuerte" (Bare repo local)
  echo "Haciendo backup en repositorio bare..."
  git push backup main

  # 4. Generar el sitio estático con Zola
  echo "Generando sitio con Zola..."
  zola build

  # 5. (Opcional) Subir al VPS con rsync
  # echo "Subiendo al servidor..."
  # rsync -avz --delete public/ usuario@tu-vps:/var/www/html/

  echo "¡Todo listo! Proyecto guardado y sitio actualizado."

Darle permisos para ejecutarse

Para que el ordenador te deje ejecutar este archivo, debes darle permiso: Bash

  chmod +x desplegar.sh

Cómo usarlo ahora

La próxima vez que termines de escribir, solo tienes que escribir en tu terminal: Bash

  ./desplegar.sh

El script te preguntará qué has hecho, lo guardará en Git, hará la copia de seguridad y generará la web de Zola. Todo en un segundo.

¿Por qué este script es parte de tu seguridad?

  • Consistencia: Siempre se ejecutan los pasos en el mismo orden.
  • Obligación: Te obliga a poner un mensaje de commit, evitando que dejes cambios "en el aire".
  • Tranquilidad: Sabes que lo que está en tu carpeta de backup (backup) es exactamente lo mismo que se acaba de convertir en HTML en tu carpeta public.

Resumen de comandos para el día a día

  | Comando                   | ¿Qué hace realmente?                      |
  | :------------------------ | :---------------------------------------- |
  | `git init`                | Iniciar. Crea la "caja negra"             |
  |                           | (carpeta `.git`) del proyecto.            |
  | `git status`              | Estado. Te dice qué archivos han cambiado.|
  |                           | **Úsalo siempre.**                        |
  | `git add .`               | Preparar. Pon todos los cambios actuales  |
  |                           | en la mesa de preparación.                |
  | `git commit -m "..."`     | Guardar. Crea un punto de control         |
  |                           | permanente con un mensaje.                |
  | `git log --oneline`       | Historial. Muestra tu lista de puntos     |
  |                           | de control (historia compacta).           |
  | `git restore <archivo>`   | Deshacer. Borra cambios actuales          |
  |                           | y vuelve al último commit guardado.       |
  | `git rm <archivo>`        | Borrar. Elimina el archivo de tu          |
  |                           | carpeta física y del rastro de Git.       |
  | `git push backup main`    | Backup. Envía toda tu historia a          |
  |                           | la "caja fuerte" (repositorio bare)       |
  | `git clone <ruta_bare>`   | Rescatar. Recupera el proyecto            |
  |                           | si la carpeta de trabajo muere.           |

Recuerda: Git no es una herramienta difícil, es un hábito. Haz un commit cada vez que termines una idea pequeña y dormirás mucho mejor.

Ejemplo de uso:

  git status

Git nos responde con la siguiente frase

  En la rama main
  Cambios no rastreados para el commit:
  (usa "git add/rm <archivo>..." para actualizar a lo que se le va a hacer commit)
  (usa "git restore <archivo>..." para descartar los cambios en el directorio de trabajo)
        modificados:     content/blog/2026/guia-git/index.md
        borrados:        content/blog/2026/servidor-linux-100/index.md...
        borrados:        content/blog/2026/servidor-linux-106/images/servidor-linux-106@blur.webp
        borrados:        content/blog/2026/servidor-linux-106/index.md

  Archivos sin seguimiento:
  (usa "git add <archivo>..." para incluirlo a lo que será confirmado)
        content/blog/2026/VPS-servidor-linux-debian/
        content/series/linux/

  sin cambios agregados al commit (usa "git add" y/o "git commit -a")

Se ha hecho una limpieza importante o una reestructuración de carpetas. Lo que ves en tu git status es el comportamiento normal de Git cuando mueves archivos mediante el explorador de archivos o el comando mv de la terminal sin avisarle a él.

Aquí tienes la explicación de por qué "no aparecen" y cómo solucionarlo:

1. ¿Qué ha pasado?

Para Git, un "movimiento" de archivos no existe como tal. Git ve que:

Han desaparecido archivos de sus rutas originales (por eso salen como borrados).

Han aparecido archivos nuevos en rutas que no conoce (por eso salen bajo Archivos sin seguimiento o Untracked).

Tus archivos sí están en las nuevas carpetas (content/blog/2026/VPS-servidor-linux-debian/ y content/series/linux/), pero Git todavía los ve como "desconocidos".

2. Cómo arreglarlo ahora mismo

Para que Git entienda que has movido los archivos y no que has borrado todo el trabajo anterior, sigue estos pasos:

Paso A: Añadir todos los cambios
  git add .

Al hacer git add ., Git comparará los archivos borrados con los archivos nuevos. Si el contenido es el mismo, Git es lo suficientemente inteligente para marcar la operación automáticamente como renombrado (renamed) en lugar de borrar/crear.

Paso B: Verificar el estado

Vuelve a ejecutar:

  git status

Ahora deberías ver algo como:

  renombrado: viejo/archivo.md -> nuevo/archivo.md

Efectivamente:

  En la rama main
  Cambios a ser confirmados:
  (usa "git restore --staged <archivo>..." para sacar del área de stage)

        renombrados:     content/blog/2026/servidor-linux-100/foto.webp -> content/blog/2026/VPS-servidor-linux-debian/images/fotowebp
        ...
        renombrados:     content/blog/2026/servidor-linux-106/index.md -> content/series/linux/servidor-linux-106/index.md
Paso C: Guardar el movimiento
  git commit -m "Reestructuración de posts de servidor Linux y series"

Y

  git commit -m "Reestructuración de posts de servidor Linux y series"
  [main 50dce06] Reestructuración de posts de servidor Linux y series
  62 files changed, 823 insertions(+), 3 deletions(-)
  ....
  rename content/{blog/2026 => series/linux}/servidor-linux-106/index.md (100%)

3. Explicación de los comandos

Esto sirve para explicar:

git add .

-> Es el "pegamento". No solo sirve para archivos nuevos, sirve para decirle a Git: "He terminado de organizar las piezas del puzzle, mira cómo ha quedado la mesa ahora".

Archivos sin seguimiento (Untracked): Son archivos que Git ve pero de los que no tiene "memoria". Hasta que no hagas git add, es como si no existieran para el sistema de seguridad.

Truco para la próxima vez: Si quieres mover archivos y que Git se entere al instante, usa el comando bash git mv:

git mv carpeta-vieja carpeta-nueva

Esto hace el movimiento físico y el git add al mismo tiempo.