¿Cómo Eliminar Archivos en Caché con Git?

Introducción

Git es un potente sistema de control de versiones que ayuda a los desarrolladores a gestionar el historial de archivos de sus proyectos. A veces, los archivos se almacenan en caché en el repositorio y ya no queremos que Git los rastree, pero deseamos conservarlos en nuestro directorio local. El comando git rm --cached nos permite eliminar archivos del sistema de seguimiento de Git mientras los preservamos en nuestro directorio de trabajo. Este tutorial le enseñará cómo usar eficazmente este comando para limpiar su repositorio y optimizar su flujo de trabajo.

Creación de un Repositorio Git de Ejemplo

Para entender cómo eliminar archivos en caché de Git, primero configuraremos un repositorio de ejemplo con algunos archivos. Esto nos ayudará a ver cómo funciona el almacenamiento en caché de Git en la práctica.

Entendiendo el Almacenamiento en Caché de Git

Cuando agrega archivos a Git usando el comando git add, Git almacena estos archivos en su índice (también llamado área de preparación o staging area). Estos archivos ahora están "en caché" o preparados, esperando ser confirmados (commit) en el repositorio. A veces, es posible que desee des-preparar (unstage) estos archivos o eliminarlos del seguimiento de Git sin borrarlos de su sistema de archivos local.

Configurando Nuestro Repositorio

Creemos un repositorio Git simple para trabajar:

1. Abra una ventana de terminal en el entorno de la máquina virtual (VM) de LabEx.
2. Navegue al directorio del proyecto:

cd ~/project

3. Cree un nuevo directorio para nuestro repositorio de prueba:

mkdir git-cache-demo
cd git-cache-demo

4. Inicialice un nuevo repositorio Git:

git init

Debería ver una salida similar a esta:

Initialized empty Git repository in /home/labex/project/git-cache-demo/.git/

5. Configure la información de su usuario de Git (requerido para los commits):

git config user.name "LabEx User"
git config user.email "labex@example.com"

Ahora tenemos un repositorio Git nuevo listo para agregar archivos. En el siguiente paso, crearemos algunos archivos y los agregaremos al sistema de seguimiento de Git, lo que nos permitirá practicar su eliminación de la caché más adelante.

Agregando Archivos al Repositorio

Ahora que hemos configurado nuestro repositorio Git, creemos algunos archivos y agreguémoslos al sistema de seguimiento de Git. Esto nos ayudará a entender qué significa que un archivo esté "en caché" en Git.

Creación y Adición de Archivos

1. Primero, creemos algunos tipos diferentes de archivos en nuestro repositorio:

## Create a text file
echo "This is a sample text file" > sample.txt

## Create a config file
echo "debug=true" > config.ini

## Create a log file (which we typically don't want to track)
echo "2023-01-01: System started" > app.log

2. Verifique el estado de nuestro repositorio:

git status

Debería ver una salida similar a esta:

On branch master

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	app.log
	config.ini
	sample.txt

nothing added to commit but untracked files present (use "git add" to track)

Esto muestra que tenemos tres archivos que Git reconoce, pero que aún no se están rastreando.

3. Agreguemos todos los archivos al área de preparación (caché) de Git:

git add .

4. Verifique el estado nuevamente:

git status

Ahora debería ver:

On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
	new file:   app.log
	new file:   config.ini
	new file:   sample.txt

Observe que Git ahora nos dice que podemos usar git rm --cached <file> para des-preparar (unstage) los archivos. Los archivos ahora están en caché en el área de preparación de Git, esperando ser confirmados (commit).

5. Confirmemos (commit) estos archivos para que formen parte del historial de nuestro repositorio:

git commit -m "Initial commit with sample files"

Ahora ha agregado archivos con éxito al sistema de seguimiento de Git. En el siguiente paso, aprenderemos cómo eliminar archivos específicos de la caché de Git mientras los mantenemos en nuestro directorio local.

Eliminando un Único Archivo de la Caché de Git

Ahora que tenemos archivos rastreados por Git, aprendamos cómo eliminar un archivo específico del seguimiento de Git mientras lo mantenemos en nuestro directorio local. Esta es una necesidad común cuando accidentalmente confirma archivos que deberían ser excluidos, como archivos de registro (log files), archivos temporales o archivos con información sensible.

Por Qué Eliminar Archivos de la Caché de Git

Hay varias razones por las que podría querer eliminar un archivo de la caché de Git:

1. Accidentalmente agregó un archivo que contiene información sensible.
2. Quiere excluir archivos binarios grandes como registros o archivos compilados.
3. Está configurando un archivo .gitignore y necesita eliminar archivos ya rastreados.

Eliminando app.log del Seguimiento de Git

Imaginemos que nos hemos dado cuenta de que el archivo app.log no debería ser rastreado por Git:

1. Primero, verifiquemos que Git actualmente está rastreando el archivo:

git ls-files

Debería ver los tres archivos listados:

app.log
config.ini
sample.txt

2. Ahora, eliminemos app.log del sistema de seguimiento de Git mientras lo mantenemos en nuestro directorio local:

git rm --cached app.log

Verá un mensaje de confirmación:

rm 'app.log'

3. Verifique el estado nuevamente:

git status

Verá que app.log ahora aparece como un archivo no rastreado:

On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
	deleted:    app.log

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	app.log

Esto significa que Git dejará de rastrear el archivo en el próximo commit, pero el archivo aún existe en su directorio local.

4. Verifiquemos que el archivo aún existe en nuestro directorio de trabajo:

ls -la

Debería ver que app.log todavía está allí.

5. Confirme (commit) este cambio para finalizar la eliminación del archivo del seguimiento de Git:

git commit -m "Remove app.log from Git tracking"

6. Verifique que Git ya no está rastreando el archivo:

git ls-files

Ahora solo debería ver:

config.ini
sample.txt

Pero el archivo app.log aún existe en su directorio local:

cat app.log

Salida:

2023-01-01: System started

¡Felicidades! Ha eliminado con éxito un archivo de la caché de Git mientras lo mantenía en su directorio local. En el siguiente paso, aprenderemos cómo manejar múltiples archivos y mejorar nuestro flujo de trabajo con .gitignore.

Trabajando con Múltiples Archivos y Directorios

Ahora que sabemos cómo eliminar un solo archivo de la caché de Git, exploremos escenarios más complejos como la eliminación de múltiples archivos o directorios completos.

Creando Más Archivos para Practicar

Primero, creemos algunos archivos más y una estructura de directorios para practicar:

1. Cree un directorio y algunos archivos adicionales:

## Create a directory for temporary files
mkdir temp

## Create some files in the temp directory
echo "This is a temporary file" > temp/temp1.txt
echo "Another temporary file" > temp/temp2.txt

## Create another log file in the main directory
echo "2023-01-02: System updated" > system.log

2. Agregue estos nuevos archivos al seguimiento de Git:

git add .

3. Confirme los cambios:

git commit -m "Add temporary files and system log"

4. Verifique que Git esté rastreando todos los archivos:

git ls-files

Debería ver:

app.log
config.ini
sample.txt
system.log
temp/temp1.txt
temp/temp2.txt

Eliminando Múltiples Archivos de la Caché de Git

Ahora digamos que queremos eliminar todos los archivos de registro y todo el directorio temp del seguimiento de Git.

1. Elimine el archivo de registro del seguimiento de Git:

git rm --cached system.log

2. Elimine todos los archivos en el directorio temp recursivamente:

git rm --cached -r temp/

La bandera -r es importante aquí, ya que le dice a Git que elimine recursivamente todos los archivos del directorio de su caché.

3. Verifique el estado:

git status

Verá que tanto el archivo de registro como todos los archivos en el directorio temp están preparados para la eliminación del sistema de seguimiento de Git:

On branch master
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
	deleted:    system.log
	deleted:    temp/temp1.txt
	deleted:    temp/temp2.txt

Untracked files:
(use "git add <file>..." to include in what will be committed)
	system.log
	temp/

4. Confirme estos cambios:

git commit -m "Remove logs and temp directory from Git tracking"

5. Verifique que Git ya no está rastreando estos archivos:

git ls-files

Ahora solo debería ver:

app.log
config.ini
sample.txt

Sin embargo, todos los archivos aún existen en su directorio local:

ls -la
ls -la temp/

Usando .gitignore para Evitar el Seguimiento de Archivos No Deseados

Ahora que hemos eliminado los archivos del seguimiento de Git, configuremos un archivo .gitignore para evitar que se agreguen accidentalmente de nuevo:

1. Cree un archivo .gitignore:

nano .gitignore

2. Agregue los siguientes patrones al archivo:

## Ignore log files
*.log

## Ignore temp directory
temp/

3. Guarde y salga (presione Ctrl+X, luego Y, luego Enter)

4. Agregue y confirme el archivo .gitignore:

git add .gitignore
git commit -m "Add .gitignore file"

Ahora, incluso si intenta agregar todos los archivos a Git, respetará su archivo .gitignore y no rastreará los patrones especificados:

git add .
git status

Debería ver que los archivos de registro y el directorio temp no se están agregando al seguimiento de Git.

Ahora ha aprendido cómo eliminar múltiples archivos y directorios de la caché de Git y cómo evitar que archivos específicos sean rastreados en el futuro utilizando un archivo .gitignore.

Técnicas Avanzadas y Mejores Prácticas

Ahora que comprende los conceptos básicos de la eliminación de archivos de la caché de Git, exploremos algunas técnicas avanzadas y mejores prácticas para mejorar su flujo de trabajo.

Eliminar e Ignorar Archivos en un Solo Paso

Si tiene archivos que ya están rastreados por Git y desea tanto eliminarlos del rastreo como agregarlos a su archivo .gitignore, puede usar este enfoque eficiente:

1. Creemos un nuevo tipo de archivo que queremos ignorar:

## Create a build directory with some compiled files
mkdir build
echo "Compiled binary data" > build/app.bin
echo "Configuration for build" > build/build.conf

2. Agregue estos archivos a Git:

git add build/
git commit -m "Add build files temporarily"

3. Ahora, eliminémoslos del seguimiento de Git y actualicemos nuestro archivo .gitignore en un solo flujo de trabajo:

## First, edit the .gitignore file to add the build directory
echo "## Ignore build directory" >> .gitignore
echo "build/" >> .gitignore

## Now remove the tracked files from Git's cache
git rm --cached -r build/

## Commit both changes together
git add .gitignore
git commit -m "Remove build directory from tracking and add to .gitignore"

4. Verifique que los archivos ya no se rastrean pero aún existen localmente:

git ls-files
ls -la build/

Manejo de Información Sensible

Si accidentalmente confirmó un archivo con información sensible como contraseñas o claves API, eliminarlo de la caché de Git es solo el primer paso. Git mantiene un historial de todos los commits, por lo que la información sensible aún existe en el historial de su repositorio.

Para información sensible, necesitaría:

1. Eliminar el archivo de la caché de Git como hemos aprendido.
2. Cambiar cualquier contraseña o clave comprometida.
3. Considerar el uso de herramientas como git filter-branch o BFG Repo-Cleaner para eliminar los datos sensibles del historial.

Esto está fuera del alcance de este tutorial, pero es importante ser consciente de esta limitación.

Mejores Prácticas para la Gestión de la Caché de Git

Aquí hay algunas mejores prácticas a seguir:

1. Cree un buen archivo .gitignore al principio de su proyecto: Esto evita rastrear accidentalmente archivos no deseados.

2. Use archivos .gitignore globales para patrones comunes: Puede configurar un archivo .gitignore global que se aplica a todos sus repositorios:

git config --global core.excludesfile ~/.gitignore_global

3. Tenga cuidado con git add .: Este comando agrega todos los archivos no rastreados. Use comandos más específicos como git add <file> cuando sea posible.

4. Revise los cambios antes de confirmar (commit): Siempre use git status y git diff --cached para revisar lo que está a punto de confirmar.

5. Use alias para operaciones comunes: Por ejemplo, podría configurar un alias para eliminar archivos en caché:

git config --global alias.uncache 'rm --cached'

Entonces podría usar:

git uncache <file>

Con estas técnicas y mejores prácticas, ahora tiene una comprensión integral de cómo administrar la caché de Git de manera efectiva para mantener un repositorio limpio y eficiente.

Resumen

En este tutorial, aprendió a usar eficazmente el comando git rm --cached para eliminar archivos del sistema de seguimiento de Git mientras los mantiene en su directorio local. Esto es lo que logró:

1. Configuró un repositorio Git y aprendió sobre el concepto de caché de Git.
2. Agregó archivos al sistema de seguimiento de Git.
3. Eliminó archivos individuales de la caché de Git usando git rm --cached.
4. Gestionó múltiples archivos y directorios con la opción recursiva (-r).
5. Usó .gitignore para evitar que se rastrearan archivos no deseados.
6. Exploró técnicas avanzadas y mejores prácticas para administrar la caché de Git.

Estas habilidades le ayudarán a mantener un repositorio Git limpio y eficiente, evitar el seguimiento de archivos no deseados y proteger información sensible. Al administrar adecuadamente qué archivos rastrea Git, puede concentrarse en el código y los archivos de configuración importantes, ignorando los archivos temporales, los registros y los artefactos de compilación.

Recuerde que eliminar archivos de la caché de Git no los borra de su sistema de archivos local; simplemente le dice a Git que deje de rastrearlos. Esta es una herramienta poderosa para administrar el contenido de su repositorio y garantizar que solo los archivos necesarios se incluyan en el historial de su proyecto.