SenseiTeoría desde cero0/59

6 · Herramientas del oficioLección 4 de 6

Git: versiones del código

Git: versioning your code

Cómo guarda Git cada versión de un proyecto con un nombre que no se puede falsificar, cómo trabajan varias personas en el mismo código sin pisarse y cómo se vuelve a la versión de ayer cuando la de hoy truena.

⏱ 59 min lo esencial · 71 min todo16 conceptos nuevos2 calculadoras9 ejerciciosContenedor
Secciones14
  1. 01Qué es Git y qué guarda un repositorio
  2. 02El commit: una foto con nombre de hash
  3. 03Ramas y merge
  4. 04Conflictos y rebase
  5. 05Remotos, pull requests y revisión de código
  6. 06Lo que no entra: .gitignore, secretos y archivos grandes
  7. 07Tags, revert y la trazabilidad de Alba
  8. 08Cómo trabaja un equipo: trunk-based, monorepo y GitOps extra
  9. 09Errores comunes
  10. 10En la vida real extra
  11. 11Ejercicios
  12. 12Lo que sigue
  13. 13Palabras que vas a oír
  14. 14Chequeo
La pregunta

El modelo de Alba que está en producción salió de cierto código; ¿cómo sé exactamente cuál era, cómo trabajamos cinco personas en el mismo gateway sin pisarnos y cómo regreso a la versión de ayer si la de hoy falla?

Alba, la empresa que seguimos en todo el curso, es un marketplace: recibe ≈ 2.5 millones de publicaciones al día y le sugiere a quien vende la categoría de cada foto, entre 500 posibles. El modelo corre en Triton, un servidor de modelos, y delante tiene un gateway: un programa en Python que recibe los bytes de la foto que manda la app, los convierte en un tensor de 602,112 bytes y se lo manda a Triton. Lo mantienen las cinco personas del equipo de ML de Alba, y cada semana cambia algo: un timeout (cuánto espera a Triton antes de rendirse), un límite, una línea de log.

Un martes a las 11 de la noche, la versión nueva empieza a responder errores. Para arreglarlo hay que contestar tres preguntas, y rápido. ¿Qué código exacto está corriendo? ¿Qué cambió desde ayer, y quién lo cambió? ¿Cómo vuelvo a lo de ayer sin perder lo de hoy?

Sin una herramienta, la respuesta es una carpeta llena de copias: gateway_final.py, gateway_final2.py, gateway_ahora_si.py. Nadie sabe cuál está en el servidor ni en qué se distinguen. La herramienta que usa casi todo el mundo para no llegar ahí se llama Git.

En esta lección vas a armar repositorios desde cero, con comandos que puedes copiar a tu terminal: guardar versiones, crear ramas, unirlas, chocar con un conflicto y resolverlo, subir a un servidor, marcar una versión y deshacer un error. Al final vas a poder seguir el hilo del sistema de Alba de punta a punta: del modelo que está en producción al commit exacto que lo produjo.

01

Qué es Git y qué guarda un repositorio

Esencial

What Git is and what a repository holds

Git es un programa que guarda la historia de un proyecto. Cada vez que se lo pides, toma una foto completa de todos sus archivos y la agrega a la lista, con quién la tomó, cuándo y por qué. Lo escribió Linus Torvalds, el creador de Linux, en abril de 2005 para el código de Linux, y hoy es, por mucho, el más usado.

Dos ideas lo distinguen:

  • Guarda fotos, no diferencias. Cada versión es el proyecto entero, tal como estaba. Si un archivo no cambió, la foto nueva no lo vuelve a copiar: apunta al mismo contenido de antes. Por eso mil versiones no ocupan mil veces el espacio.
  • Es distribuido (distributed). Cada persona tiene en su computadora la historia completa, no solo la última versión. Puede ver versiones viejas, compararlas y guardar nuevas sin internet. El servidor (GitHub, por ejemplo, un sitio que guarda proyectos en internet) es una copia más: la que el equipo acuerda usar para juntar su trabajo.

«Foto» es una manera de decirlo, y se rompe en dos puntos. No es una imagen: son los bytes de cada archivo, tal como estaban. Y una foto de verdad se puede retocar; en Git, como vas a ver en la sección 2, retocar una foto vieja le cambia el nombre a ella y a todas las que siguen.

El repositorio y sus tres lugares

Un repositorio (repository, o repo) es la carpeta de un proyecto que Git vigila. Se reconoce porque adentro tiene una carpeta oculta llamada .git: en la lección del sistema operativo viste que los nombres que empiezan con punto no aparecen en un ls normal. Ahí vive toda la historia. Si borras .git, tus archivos se quedan, pero la historia desaparece.

Un cambio del repositorio pasa por tres lugares:

  1. El área de trabajo (working tree): los archivos que ves y editas, como en cualquier carpeta. No la confundas con el directorio de trabajo de la terminal, que es la carpeta donde estás parado.
  2. El staging (staging area, también llamado index): una zona de preparación con lo que va a entrar en la próxima foto. Se llena con git add.
  3. El historial (history): las fotos ya guardadas, dentro de .git. Cada foto nueva se toma con git commit.

¿Para qué el paso de en medio? Porque casi nunca quieres guardar todo lo que cambiaste. Arreglaste un bug y, de paso, dejaste un print para depurar: con el staging metes el arreglo a la foto y dejas el print fuera. Así cada foto tiene un solo propósito, y es fácil de leer y de deshacer.

Los tres lugares de un cambio en un repositorio de Git. Arriba, el área de trabajo: los archivos que ves y editas; ahí un archivo nuevo aparece en git status --short como dos signos de interrogación, y uno cambiado como una M en la segunda columna. Con git add, el cambio pasa al staging, también llamado index: lo que va a entrar en la próxima foto; ahí un archivo nuevo aparece como A en la primera columna y uno cambiado como M en la primera columna. Con git commit, el cambio pasa al historial, dentro de la carpeta .git: las fotos guardadas, una tras otra, como 1e53ceb y 139f652, con la rama main apuntando a la última. Si todo está en el historial, git status no muestra nada. LOS TRES LUGARES DE UN CAMBIO Área de trabajo Los archivos que ves y editas. ? ? sin seguir M cambiado git add Staging (index) Lo que va a entrar en la próxima foto. A nuevo M cambiado git commit Historial (.git) Las fotos guardadas, una tras otra. 1e53ceb 139f652 main Si todo está aquí, git status no muestra nada.
Los tres lugares de un cambio. Editas en el área de trabajo, eliges con git add lo que va a la próxima foto y la tomas con git commit. Las dos letras de git status --short dicen dónde está cada archivo.

Tu primer repositorio

Antes de usar Git en tu computadora, dile quién eres: ese nombre y ese correo van en cada foto que tomes. --global quiere decir «para todos los repositorios de esta computadora». La tercera línea pide que la primera rama de cada repositorio nuevo se llame main (en la sección 3 ves qué es una rama). Sin ella, Git la llama master y los bloques de esta lección que dicen main fallan en tu máquina. Es una ilustración, sin salida, y se hace una sola vez:

Terminal
git config --global user.name "Ana"
git config --global user.email "ana@ejemplo.mx"
git config --global init.defaultBranch main

Ahora arma un repositorio con un archivo de configuración del gateway. git status --short dice en qué lugar está cada archivo con dos letras: la primera habla del staging y la segunda, del área de trabajo.

Terminal
git init -q gateway && cd gateway          # una carpeta nueva, con su .git adentro
echo 'INFER_TIMEOUT_S = 0.15' > config.py  # el primer archivo del proyecto
echo "1) archivo nuevo:";   git status --short
git add config.py
echo "2) en el staging:";   git status --short
git commit -q -m "Agrega el timeout"
echo "3) en el historial:"; git status --short
echo 'INFER_TIMEOUT_S = 0.20' > config.py
echo "4) cambiado:";        git status --short
git add config.py
echo "5) en el staging:";   git status --short
git commit -q -m "Sube el timeout a 0.20 s"
git log --oneline
Salida
1) archivo nuevo:
?? config.py
2) en el staging:
A  config.py
3) en el historial:
4) cambiado:
 M config.py
5) en el staging:
M  config.py
139f652 Sube el timeout a 0.20 s
1e53ceb Agrega el timeout

Cómo se lee:

  • ??: Git ve el archivo, pero no lo sigue (untracked). Todavía no es parte del proyecto.
  • A en la primera columna: el archivo nuevo ya está en el staging, listo para la foto.
  • Nada: todo lo del área de trabajo ya está en el historial. Se dice que el árbol está limpio (clean).
  • M en la segunda columna: cambiaste un archivo que Git ya seguía, pero el cambio no está en el staging.
  • M en la primera columna: el cambio ya está en el staging.

git log --oneline lista las fotos de la más nueva a la más vieja: un id de 7 caracteres y el mensaje. La opción -q (quiet) solo calla los avisos. Sin --short, git status dice lo mismo en frases completas, en inglés, como todos los mensajes de Git.

02

El commit: una foto con nombre de hash

Esencial

The commit: a snapshot named by its hash

Cada foto del historial es un commit, del inglés to commit, comprometerse: «esto queda así». Un commit guarda cinco cosas:

  1. El árbol (tree): la lista de archivos de esa versión, cada uno con el id de su contenido.
  2. El padre (parent): el id del commit anterior. El primero de un repositorio no tiene.
  3. El autor, con su correo y la fecha.
  4. Quién lo guardó (committer): casi siempre, el mismo autor a la misma hora.
  5. El mensaje: una línea que dice qué cambió, y de preferencia por qué.

Git te deja ver un commit tal como lo guarda. Este bloque repite los dos commits de la sección anterior y abre el último. (-am es -a, «mete al staging lo que cambió en archivos que ya sigues», más -m, el mensaje.)

Terminal
git init -q gateway && cd gateway
echo 'INFER_TIMEOUT_S = 0.15' > config.py && git add . && git commit -q -m "Agrega el timeout"
echo 'INFER_TIMEOUT_S = 0.20' > config.py && git commit -q -am "Sube el timeout a 0.20 s"
git cat-file -p HEAD                 # el commit, tal como Git lo guarda
echo ---
git cat-file -p 'HEAD^{tree}'        # su árbol: la lista de archivos
git hash-object config.py            # el id que Git le da a ese contenido
Salida
tree 06f54d93eba2a182c98eedd0a401b6af0deb0763
parent 1e53cebd92b55f3f6e95e4b929fc481844a9e5d5
author Ana <ana@ejemplo.mx> 1793988000 -0600
committer Ana <ana@ejemplo.mx> 1793988000 -0600

Sube el timeout a 0.20 s
---
100644 blob 6f61d2c5f6c20d3b99d7e5e6fa317328c9a8a07c	config.py
6f61d2c5f6c20d3b99d7e5e6fa317328c9a8a07c

El commit entero son unas cuantas líneas de texto. La fecha va en tiempo Unix, los segundos desde 1970 de la lección de tiempo y hashes: 1793988000 es el 6 de noviembre de 2026 a las 12:00, y -0600 dice la zona. HEAD es «el commit donde estás»; lo ves a fondo en la sección siguiente. El árbol tiene una sola línea: config.py, con el id de su contenido (100644 dice que es un archivo normal, que no se ejecuta). A ese contenido, los bytes del archivo sin su nombre, Git le dice blob (un nombre que viene de las bases de datos, donde blob es binary large object, un objeto binario grande).

El id es la huella de todo lo anterior

¿De dónde sale el id? Git junta el tipo de objeto, su tamaño en bytes y su contenido, y les calcula un hash criptográfico, la huella de la lección de tiempo y hashes: id=SHA-1(encabezado+contenido), donde el encabezado es el tipo, un espacio, el tamaño y un byte en cero. Por omisión usa SHA-1, de 160 bits, que se escribe con 40 caracteres hexadecimales (cada uno, del 0 al 9 o de la a a la f, vale 4 bits). Si cambia un solo byte, cambia toda la huella.

Lo puedes comprobar sin Git, con hashlib, que viene con Python:

Python
import hashlib

def id_git(tipo, contenido):              # así nombra Git cada objeto que guarda
    encabezado = f"{tipo} {len(contenido)}\0".encode()   # texto → bytes; \0 es un byte en cero
    return hashlib.sha1(encabezado + contenido).hexdigest()

archivo = b"INFER_TIMEOUT_S = 0.20\n"     # b"…" son bytes; \n, el salto de línea del final
print("blob   ", id_git("blob", archivo))

commit = (b"tree 06f54d93eba2a182c98eedd0a401b6af0deb0763\n"
          b"parent 1e53cebd92b55f3f6e95e4b929fc481844a9e5d5\n"
          b"author Ana <ana@ejemplo.mx> 1793988000 -0600\n"
          b"committer Ana <ana@ejemplo.mx> 1793988000 -0600\n"
          b"\n"
          b"Sube el timeout a 0.20 s\n")
print("commit ", id_git("commit", commit)[:7], f"({len(commit)} bytes)")
otro = commit.replace(b"0.20 s", b"0.2 s")        # un solo carácter menos en el mensaje
print("otro   ", id_git("commit", otro)[:7])
Salida
blob    6f61d2c5f6c20d3b99d7e5e6fa317328c9a8a07c
commit  139f652 (213 bytes)
otro    c27a81e

El blob coincide con el de git hash-object, y el commit, con el 139f652 de la sección 1: el id de un commit es el SHA-1 de esos 213 bytes, precedidos por commit 213 y un byte en cero (\0). Con un carácter menos en el mensaje, el id es otro.

De aquí sale la propiedad más importante de Git. Dentro de cada commit va el id de su padre; el padre lleva el del abuelo, y así hasta el primero. Cambiar cualquier cosa del pasado cambia el id de ese commit y el de todos los que vienen después. Mira dos historias con los mismos archivos, que solo difieren en el mensaje del primer commit:

Terminal
historia() {    # una función: arma el mismo proyecto; $1 es la carpeta y $2 el primer mensaje
  git init -q "$1" && cd "$1"
  echo 'INFER_TIMEOUT_S = 0.15' > config.py && git add . && git commit -q -m "$2"
  echo 'PREPROCESS_CONCURRENCY = 2' >> config.py && git commit -q -am "Limita el preprocesamiento"
  echo 'TOP_K = 5' >> config.py && git commit -q -am "Regresa el top-5"
  git log --oneline && cd ..
}
historia original "Agrega el timeout"
echo ---
historia corregida "Agrega el timeout de Triton"
echo ---
cmp original/config.py corregida/config.py && echo "config.py es idéntico en las dos"
Salida
19fc2c8 Regresa el top-5
811804c Limita el preprocesamiento
1e53ceb Agrega el timeout
---
68c0bfe Regresa el top-5
529d5c3 Limita el preprocesamiento
c4d6f12 Agrega el timeout de Triton
---
config.py es idéntico en las dos

historia es una función de bash: un nombre para un grupo de comandos, que aquí se usa dos veces; $1 y $2 son los argumentos con que se llama. >> agrega una línea al final del archivo, y cmp compara dos archivos byte por byte.

Dos historias de tres commits cada una, con los mismos archivos. Cada commit apunta a su padre con una flecha hacia la izquierda. En la original, los commits son 1e53ceb (el timeout), 811804c (el preprocesamiento) y 19fc2c8 (el top-5). En la segunda solo cambia el mensaje del primer commit, y los tres ids son otros: c4d6f12, 529d5c3 y 68c0bfe. Como cada commit guarda el id de su padre, un cambio en el primero cambia todos los que vienen después. CADA COMMIT GUARDA EL ID DE SU PADRE Original 1e53ceb timeout 811804c preproceso 19fc2c8 top-5 Con el primer mensaje corregido c4d6f12 timeout 529d5c3 preproceso 68c0bfe top-5 otro mensaje config.py es idéntico en las dos historias. Cambió un mensaje y cambió el primer id; los otros dos guardan ese id: también cambian.
Cada commit guarda el id de su padre. Si cambias el mensaje del primero, cambia su id; el segundo guarda ese id nuevo y también cambia, y así hasta el último. Los archivos son idénticos en las dos historias.

Fíjate en otra cosa: «Agrega el timeout» se llama 1e53ceb aquí y en la sección 1. Mismo archivo, mismo autor, misma fecha, mismo mensaje y ningún padre: es el mismo commit. El id no es un número de turno que alguien reparte; es la huella del contenido. Por eso dos personas en dos países pueden crear commits sin preguntarle a nadie, y por eso un id dice sin ambigüedad de qué código hablas. Nadie puede cambiar el código de 3f9c2ab y conservar el nombre.

El hash corto

Nadie escribe 40 caracteres. Git acepta el principio del id mientras ningún otro objeto empiece igual, y casi siempre muestra 7: 1e53ceb. El gateway de Alba usa esos 7 caracteres como nombre de su imagen (el paquete del que nacen sus contenedores, de la lección del sistema operativo): se llama classifier-gateway:3f9c2ab.

¿Cuántos ids caben en 7 caracteres?La cuenta
Un carácter hexadecimaldel 0 al 9 y de la a a la f
16 valores
4 bits
Bits de k = 7 caracteresk: los caracteres del id corto
4×k = 7 × 4 bits
28 bits
Combinaciones Mlos prefijos distintos que caben en k caracteres
M=16k = 16⁷
268,435,456
El id completo40 caracteres
16⁴⁰ = 2¹⁶⁰
≈ 1.5 × 10⁴⁸
Resultado
Con 7 caracteres caben ≈ 268 millones de prefijos distintos. Parece muchísimo, pero en un proyecto grande dos objetos empiezan igual antes de lo que crees: lo ves en el bloque de abajo.
Para ir más hondo¿Cuándo dejan de alcanzar 7 caracteres?

Es el problema del cumpleaños: en un salón de 23 personas, la probabilidad de que dos cumplan el mismo día ya pasa de 50 %, porque lo que crece rápido es el número de parejas. Con n objetos hay P parejas, y cada pareja empieza igual con probabilidad 1/M. La probabilidad de que alguna pareja choque es, muy aproximadamente:

Probabilidad de que dos ids cortos empiecen igual
M=16k
P=n×(n−1)2
Pr≈1−e−P/M
donde
k
los caracteres del id corto (7 casi siempre)
M
los prefijos distintos que caben en k caracteres
n
los objetos del repositorio (commits, árboles y blobs)
P
las parejas de objetos que se pueden formar
Pr
la probabilidad de que al menos una pareja empiece igual, de 0 a 1
e
el número 2.718…, la base de los logaritmos naturales

Con n = 10,000 objetos y k = 7: P = 10,000 × 9,999 ÷ 2 = 49,995,000 parejas; P/M = 49,995,000 ÷ 268,435,456 ≈ 0.186, y Pr≈1−e−0.186 ≈ 17 %. Con 50,000 objetos, ≈ 99 % (el ejercicio de los 50,000 objetos lo hace paso a paso). Y los objetos no son solo commits: cada versión de cada archivo es un blob y cada carpeta de cada commit es un árbol, así que un proyecto con unos miles de commits ya tiene decenas de miles.

Cuando dos objetos empiezan igual, Git alarga el id de esos dos lo necesario. Además, desde la versión 2.11 elige solo cuántos caracteres mostrar según el tamaño del repositorio: en uno enorme, como el de Linux, muestra unos 12. Por eso git rev-parse --short=7 HEAD, el comando con el que Alba nombra sus imágenes, da 7 caracteres, o más si otro objeto empieza igual. (CI es el sistema que prueba y empaqueta solo cada cambio; lo ves en la lección siguiente.)

Y el SHA-1 de 40 caracteres, ¿no está roto? En la lección de hashes viste que en 2017 se fabricó el primer choque. Git respondió ese mismo año (en la versión 2.13, de mayo de 2017) con una versión de SHA-1 que detecta los choques fabricados así. Además, desde la 2.29 (2020) puede crear repositorios con SHA-256, que desde la 2.42 (2023) ya no se marcan como experimentales; pero los repositorios de SHA-1 y los de SHA-256 todavía no se hablan entre sí, y GitHub aún no los acepta (noviembre de 2026). Git 3.0, que todavía no tiene fecha, planea usar SHA-256 por omisión en los repositorios nuevos. Para que dos commits distintos tengan el mismo id completo por accidente, haría falta una cantidad de objetos que ningún repositorio va a tener.

¿Alcanzan 7 caracteres?Calculadora

Con n objetos en el repositorio (commits, árboles y blobs) y prefijos de k caracteres hexadecimales, ¿qué tan probable es que dos empiecen igual? Es el problema del cumpleaños: lo que crece rápido es el número de parejas. La calculadora aplica M=16k, P=n×(n−1)/2 y Pr≈1−e−P/M. Arranca con 10,000 objetos y 7 caracteres.

Bits del prefijo4×k: cada carácter hexadecimal vale 4 bits28
Prefijos posibles, MM=16k2.68 × 10^8
Parejas de objetos, PP=n×(n−1)/25.00 × 10^7
Probabilidad de que al menos dos empiecen igual, PrPr≈1−e−P/M17.0 %
Probabilidad de que un objeto nuevo choque con algunon/M, como máximo 100 %: la fracción de los prefijos que ya están ocupados0.0037 %

Con 10,000 objetos y 7 caracteres, la probabilidad de un choque ya es ≈ 17 %; con 50,000, ≈ 99 %. Por eso Git alarga los ids que chocan y, en repositorios grandes, muestra más de 7 caracteres.

Prueba con 50,000 objetos y sube los caracteres de uno en uno: ¿con cuántos baja la probabilidad de un choque a menos de 1 %?

03

Ramas y merge

Esencial

Branches and merge

Una rama (branch) es un nombre que apunta a un commit. Nada más. main es el nombre que casi todos usan para la primera rama: GitHub lo usa por omisión desde 2020. Git, hasta la versión 2.x, todavía la llama master si no le configuras init.defaultBranch (por eso la tercera línea de la sección 1), y Git 3.0 planea cambiar a main. En repositorios viejos vas a ver master. Cuando haces un commit estando en una rama, el nombre avanza solo al commit nuevo: por eso se dice que una rama es una etiqueta que se mueve.

Git guarda cada rama como un archivo de texto dentro de .git/refs/heads/, con el id completo de su commit:

Lo que ocupa una ramaLa cuenta
El archivo de la ramaen .git/refs/heads/
40 caracteres del id + un salto de línea
41 bytes
HEADref: refs/heads/main
20 caracteres + un salto de línea
21 bytes
Cien ramas
100 × 41 bytes
4,100 bytes ≈ 4 KB
Resultado
Crear una rama es escribir 41 bytes. No copia ni un archivo del proyecto: por eso se crean ramas para cualquier cosa, aunque vivan una hora.

(Cuando hace limpieza, Git junta las ramas en un solo archivo, .git/packed-refs. Y Git 3.0 planea guardar las ramas por omisión en un formato nuevo, reftable, en archivos binarios. La idea es la misma: una rama es un nombre y un id.)

HEAD es como Git sabe dónde estás. Es otro archivo, .git/HEAD, que casi siempre dice el nombre de una rama: ref: refs/heads/main. El commit al que apunta esa rama es el «actual»: de ahí sale lo que ves en tu área de trabajo, y ahí se cuelga el próximo commit.

git switch -c top-k crea la rama top-k y te pasa a ella. git switch existe desde Git 2.23 (2019); en tutoriales viejos vas a ver git checkout -b top-k, que hace lo mismo. Cambiar de rama sí toca tus archivos: Git deja el área de trabajo como está en el commit de esa rama.

Unir dos ramas

Trabajas en tu rama hasta que el cambio está listo y entonces lo unes a main: eso es un merge (unir, fusionar). Hay dos casos:

  • Fast-forward («adelantar»): si main no se movió desde que saliste, no hay nada que mezclar. Git solo adelanta la etiqueta main hasta tu último commit.
  • Commit de merge (merge commit): si main avanzó mientras tanto, cada rama tiene commits que la otra no tiene. Git crea un commit nuevo que junta las dos versiones, y ese commit tiene dos padres.
Terminal
git init -q gateway && cd gateway
echo 'INFER_TIMEOUT_S = 0.15' > config.py && git add . && git commit -q -m "Agrega el timeout"
git switch -c top-k                        # crea la rama y te pasa a ella
echo 'TOP_K = 5' >> config.py && git commit -q -am "Regresa el top-5"
git switch -q main
git merge top-k                            # main no se movió: basta con adelantar su etiqueta
git log --oneline --graph
echo "--- otra vez, pero ahora main avanza mientras tanto"
git switch -q -c logs
echo 'LOG_LEVEL = "info"' > logs.py && git add . && git commit -q -m "Agrega el nivel de log"
git switch -q main
echo 'PREPROCESS_CONCURRENCY = 2' >> config.py && git commit -q -am "Limita el preprocesamiento"
git merge -q -m "Une la rama logs" logs    # aquí sí hace falta un commit que una las dos
git log --oneline --graph
git cat-file -p HEAD | grep parent         # el commit de merge tiene dos padres
Salida
Switched to a new branch 'top-k'
Updating 1e53ceb..821910a
Fast-forward
 config.py | 1 +
 1 file changed, 1 insertion(+)
* 821910a Regresa el top-5
* 1e53ceb Agrega el timeout
--- otra vez, pero ahora main avanza mientras tanto
*   9341d8a Une la rama logs
|\
| * 26b7ad8 Agrega el nivel de log
* | 60006fd Limita el preprocesamiento
|/
* 821910a Regresa el top-5
* 1e53ceb Agrega el timeout
parent 60006fd5a144430dbf67599b7dd649b79150c264
parent 26b7ad82f63f926d4144ebc4c244d8a21f69e8ee

--graph dibuja la historia con letras: cada * es un commit y las rayas unen cada commit con sus padres. La primera unión fue un fast-forward («Updating 1e53ceb..821910a», de un commit al otro): no se creó ningún commit, y las dos líneas que siguen dicen que cambió un archivo, con una línea nueva. La segunda creó 9341d8a, con dos líneas parent. grep parent se queda solo con las líneas que dicen parent.

Las dos formas de unir una rama. Arriba, un fast-forward: la rama top-k tiene el commit 821910a encima de 1e53ceb, y main seguía en 1e53ceb; como main no se movió, su etiqueta solo avanza de 1e53ceb a 821910a, sin crear ningún commit. Abajo, un commit de merge: main avanzó a 60006fd y la rama logs a 26b7ad8, las dos desde 821910a; el merge crea el commit 9341d8a, que tiene dos padres, 60006fd y 26b7ad8, y main apunta a él. FAST-FORWARD main no se movió: solo avanza su etiqueta. top-k 1e53ceb 821910a main main antes después COMMIT DE MERGE Las dos avanzaron: un commit nuevo con dos padres. 821910a 60006fd 9341d8a 26b7ad8 main logs 9341d8a tiene dos padres: 60006fd y 26b7ad8.
Arriba, un fast-forward: main no se había movido, así que su etiqueta solo avanza al commit de la rama. Abajo, un commit de merge: las dos ramas avanzaron por separado y 9341d8a las junta con dos padres.

¿Cómo junta Git dos versiones? Busca el último commit que las dos ramas tienen en común, la base (aquí, 821910a), y compara cada rama contra ella. Una rama cambió config.py y la otra creó logs.py: no se estorban, así que Git toma los dos cambios sin preguntar. Lo mismo si las dos cambian líneas distintas del mismo archivo, siempre que no estén pegadas. El problema llega cuando las dos cambian la misma línea, o dos líneas vecinas: Git no sabe en qué orden ponerlas.

04

Conflictos y rebase

Esencial

Merge conflicts and rebase

Hay un conflicto de merge (merge conflict) cuando las dos ramas cambiaron las mismas líneas del mismo archivo (o líneas pegadas), cada una a su manera, desde la base. Git no adivina cuál quieres. Se detiene, marca el pedazo en disputa dentro del archivo y te deja decidir.

En este bloque, Luis sube el timeout en su rama y Ana lo baja en main:

Terminal
git init -q gateway && cd gateway
echo 'INFER_TIMEOUT_S = 0.15' > config.py && git add . && git commit -q -m "Agrega el timeout"
git switch -q -c luis                      # Luis sube el timeout en su rama
echo 'INFER_TIMEOUT_S = 0.25' > config.py && git commit -q -am "Sube el timeout a 0.25 s"
git switch -q main                         # y Ana, en main, lo baja
echo 'INFER_TIMEOUT_S = 0.10' > config.py && git commit -q -am "Baja el timeout a 0.10 s"
git merge luis
echo "--- así quedó config.py:"
cat config.py
git status --short                         # UU: los dos lados cambiaron esta línea
echo 'INFER_TIMEOUT_S = 0.15' > config.py  # Ana y Luis lo hablan y deciden
git add config.py && git commit -q --no-edit
git log --oneline --graph
Salida
Auto-merging config.py
CONFLICT (content): Merge conflict in config.py
Automatic merge failed; fix conflicts and then commit the result.
--- así quedó config.py:
<<<<<<< HEAD
INFER_TIMEOUT_S = 0.10
=======
INFER_TIMEOUT_S = 0.25
>>>>>>> luis
UU config.py
*   c31841c Merge branch 'luis'
|\
| * f6f8c36 Sube el timeout a 0.25 s
* | 82105c2 Baja el timeout a 0.10 s
|/
* 1e53ceb Agrega el timeout

Los marcadores de conflicto (conflict markers) parten el pedazo en dos:

  • De <<<<<<< HEAD a =======: tu versión, la de la rama donde estás parado (main).
  • De ======= a >>>>>>> luis: la versión de la rama que estás uniendo.

Para resolverlo:

  1. 1

    Decide

    Abre el archivo y elige: tu versión, la otra o una tercera, como aquí. Si no sabes, pregunta: un conflicto es una conversación pendiente.

  2. 2

    Borra los marcadores

    Un archivo con <<<<<<< adentro no es Python válido. Si llega así a un commit, el gateway ni siquiera arranca.

  3. 3

    Avisa que ya quedó

    git add config.py le dice a Git que el archivo está resuelto.

  4. 4

    Termina el merge

    git commit crea el commit de merge; con --no-edit acepta el mensaje que Git propone. Si te arrepientes antes, git merge --abort deja todo como estaba.

Lo difícil de un conflicto casi nunca es Git: es la decisión. Que el gateway espere a Triton 0.10 o 0.25 segundos antes de rendirse es una pregunta de diseño, y se contesta hablando, no eligiendo al azar. Aquí lo dejaron en 0.15, el valor que usa Alba: 150 ms. Y los conflictos se evitan con ramas cortas, cambios chicos y trayendo lo nuevo de main seguido: dos ramas que se separan una semana chocan mucho más que dos que se separan una hora.

Rebase: poner tus commits encima

Hay otra forma de traer lo nuevo de main a tu rama. Rebase (cambiar la base) toma tus commits y los vuelve a aplicar, uno por uno, encima del último commit de otra rama. La historia queda en línea recta, como si hubieras empezado tu trabajo hoy. main..logs quiere decir «los commits de logs que main no tiene».

Terminal
git init -q gateway && cd gateway
echo 'INFER_TIMEOUT_S = 0.15' > config.py && git add . && git commit -q -m "Agrega el timeout"
git switch -q -c logs
echo 'LOG_LEVEL = "info"' > logs.py && git add . && git commit -q -m "Agrega el nivel de log"
echo 'LOG_FORMAT = "json"' >> logs.py && git commit -q -am "Escribe los logs en JSON"
git switch -q main
echo 'TOP_K = 5' >> config.py && git commit -q -am "Regresa el top-5"
git switch -q logs
echo "antes:";   git log --oneline main..logs
git rebase -q main
echo "después:"; git log --oneline main..logs
git log --oneline --graph
Salida
antes:
707221d Escribe los logs en JSON
0750449 Agrega el nivel de log
después:
a8b1758 Escribe los logs en JSON
26b7ad8 Agrega el nivel de log
* a8b1758 Escribe los logs en JSON
* 26b7ad8 Agrega el nivel de log
* 821910a Regresa el top-5
* 1e53ceb Agrega el timeout

Mira los ids: los dos commits traen los mismos cambios y los mismos mensajes, pero ids nuevos. Ya sabes por qué: cambió su padre. Rebase no mueve commits. Crea copias nuevas y deja los originales sin ninguna rama que los nombre.

Un rebase, antes y después. Antes: main tiene 1e53ceb y encima 821910a; la rama logs sale de 1e53ceb con dos commits, 0750449 y 707221d. Después de git rebase main, los dos commits de logs se rehacen encima de 821910a como 26b7ad8 y a8b1758: los mismos cambios y mensajes, con ids nuevos, porque cambió el padre de cada uno. La historia queda en línea recta. Los originales, 0750449 y 707221d, se quedan sin ninguna rama que los nombre. ANTES DEL REBASE 1e53ceb 821910a main 0750449 707221d logs DESPUÉS DE GIT REBASE MAIN 1e53ceb 821910a 26b7ad8 a8b1758 main logs Los originales, sin rama que los nombre: 0750449 707221d Mismos cambios y mensajes, ids nuevos: cambió el padre de cada uno.
Antes, la rama logs salía de 1e53ceb. Después del rebase, sus dos commits se rehicieron encima de 821910a, con ids nuevos. Los originales siguen en .git un tiempo, pero ya ninguna rama los nombra.

De ahí sale la regla de oro: no hagas rebase de commits que otros ya bajaron. Si Luis tiene 0750449 en su computadora y tú lo reemplazas por 26b7ad8, ahora hay dos historias con el mismo trabajo. Al juntarlas, los cambios aparecen dos veces y los conflictos se multiplican. En tu rama, antes de compartirla, rebase lo que quieras. En main, nunca.

Para ir más hondo¿Merge o rebase?

Las dos traen lo mismo: el código final es idéntico. Cambia cómo se ve la historia.

  • Merge conserva lo que pasó de verdad: cuándo se separó cada rama y cuándo volvió. A cambio, en un equipo grande la historia se llena de commits de merge y de rayas cruzadas.
  • Rebase deja una línea recta, fácil de leer y de recorrer con git log. A cambio, reescribe commits, con la regla de oro de arriba.

Muchos equipos combinan: rebase en tu rama para ponerla al día, y al final, al unirla en GitHub con el botón del pull request (la sección siguiente), una de sus tres opciones: un commit de merge, squash (todos los commits de la rama se aplastan en uno solo) o rebase. git rebase -i (de interactive) además te deja reescribir tus commits antes de compartirlos: juntar en uno tres commits de «arreglo un error de dedo» (typo) o corregir un mensaje.

05

Remotos, pull requests y revisión de código

Esencial

Remotes, pull requests and code review

Hasta aquí todo pasó en una sola carpeta. Para que cinco personas trabajen juntas, cada una tiene su copia del repositorio y se ponen de acuerdo en una copia central. Una copia de tu repositorio en otro lugar es un remoto (remote), y por costumbre el principal se llama origin. Casi siempre vive en un servicio como GitHub (de Microsoft) o GitLab, que guardan repositorios en internet y les agregan herramientas para trabajar en equipo.

Cuatro comandos mueven commits entre tu copia y el remoto:

ComandoQué hace
git cloneBaja el repositorio completo, con toda su historia, y apunta origin a esa dirección
git fetchBaja los commits nuevos del remoto sin tocar tus ramas: quedan en origin/main
git pullUn fetch y después une origin/main a tu rama. Si tu rama no tiene commits propios, solo la adelanta; si los tiene, el Git de hoy se niega hasta que elijas: --rebase o --no-rebase (merge)
git pushSube tus commits y mueve la rama del remoto

push tiene una protección: solo mueve la rama del remoto hacia adelante. Si alguien subió algo que tú no tienes, tu push se rechaza, porque si entrara borraría el trabajo de esa persona. Este bloque arma un GitHub de juguete en la misma máquina, un repositorio sin área de trabajo (bare), y dos personas que suben casi a la vez:

Terminal
git init -q --bare servidor.git            # hace de GitHub: un repositorio sin área de trabajo
git init -q ana && cd ana
echo 'INFER_TIMEOUT_S = 0.15' > config.py && git add . && git commit -q -m "Agrega el timeout"
git remote add origin ../servidor.git      # «origin» es un apodo para esa dirección
git push -q origin main
cd .. && git clone -q servidor.git luis && cd luis
echo 'TOP_K = 5' > respuesta.py && git add . && git commit -q -m "Regresa el top-5"
git push -q origin main                    # Luis sube primero
cd ../ana
echo 'PREPROCESS_CONCURRENCY = 2' >> config.py && git commit -q -am "Limita el preprocesamiento"
git push origin main                       # a Ana le falta el commit de Luis
echo "--- Ana baja lo nuevo, pone su commit encima y vuelve a subir"
git pull -q --rebase origin main
git push -q origin main
git log --oneline
Salida
To ../servidor.git
 ! [rejected]        main -> main (fetch first)
error: failed to push some refs to '../servidor.git'
hint: Updates were rejected because the remote contains work that you do not
hint: have locally. This is usually caused by another repository pushing to
hint: the same ref. If you want to integrate the remote changes, use
hint: 'git pull' before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.
--- Ana baja lo nuevo, pone su commit encima y vuelve a subir
4903ba0 Limita el preprocesamiento
32c5e47 Regresa el top-5
1e53ceb Agrega el timeout

El rechazo dice, en resumen: «el remoto tiene trabajo que tú no tienes; bájalo primero». Ana lo baja con git pull --rebase, que pone su commit encima del de Luis, y su segundo push entra. El rebase es seguro aquí porque su commit nunca se había subido. Con una dirección de GitHub en lugar de ../servidor.git, los comandos son los mismos.

Existe git push --force, que sobrescribe la rama del remoto aunque se pierdan commits. En una rama que solo usas tú, después de un rebase, a veces hace falta. En main borra el trabajo de otros. Si lo necesitas, usa --force-with-lease, que se niega si el remoto cambió desde la última vez que lo viste. Y casi todos los equipos protegen main en GitHub, para que nadie pueda forzarla ni subir directo.

El pull request

En un equipo, casi nadie hace push directo a main. Cada cambio va en su rama, la rama se sube y se abre un pull request (PR): una página en GitHub que dice «quiero unir mi rama a main». En GitLab se llama merge request (MR), y es lo mismo.

El PR muestra el diff (las diferencias: en rojo las líneas que salen y en verde las que entran), los commits, la conversación y el resultado de las pruebas. Si alguien pide cambios, haces más commits en la misma rama y el PR se actualiza solo. Cuando se aprueba, un botón hace el merge.

La revisión de código

La revisión de código (code review) es que otra persona lea el cambio antes de unirlo. Lo que se revisa:

  • ¿Hace lo que dice? ¿Hay un caso que lo rompe, como una foto vacía o Triton caído?
  • ¿Se entiende? Quien lo lea en seis meses no va a poder preguntarte.
  • ¿Tiene pruebas, y cubren lo que cambió?
  • ¿Mete algo que no debe? Una contraseña, un archivo de pesos, una dependencia nueva sin razón.
  • En ML, además: ¿cambia el preprocesamiento? Si cambia en el gateway y no en el entrenamiento, el modelo recibe entradas distintas de las que vio al aprender: el training-serving skew.

Lo que puede revisar una máquina, lo revisa una máquina. En cada PR corren solas las pruebas automáticas, la integración continua (CI) de la lección siguiente; en Alba, las 26 pruebas automáticas (tests) del gateway. La persona se concentra en lo que la máquina no ve.

El camino de un cambio: de la laptop de Luis a producción · El camino de un cambio en un equipo. Toca cada caja para ver por qué está ahí, o usa «Recorrer» para seguir un cambio que entra y uno que se detiene en la revisión.
  • Luis · rama fix-timeout
    Luis trabaja en su propia rama, fix-timeout, y hace commits en su laptop. main no se toca: las otras cuatro personas siguen trabajando sin enterarse.
  • Su rama en GitHub · origin/fix-timeout
    git push sube la rama al remoto. Ahora hay una copia fuera de su laptop, pero todavía no es parte de main.
  • Pull request · main ← fix-timeout
    El pull request pide unir la rama a main. Muestra el diff, los commits y la conversación, y no se puede unir hasta que la revisión y CI digan que sí.
  • Revisión · Ana lee el diff
    La revisión de código: otra persona lee el cambio. ¿Hace lo que dice? ¿Tiene pruebas? ¿Mete un secreto o un archivo de pesos? ¿Cambia el preprocesamiento?
  • CI · los 26 tests del gateway
    La integración continua corre sola en cada PR: en Alba, los 26 tests del gateway. Si uno falla, el botón de merge se queda bloqueado. Es el tema de la lección siguiente.
  • main · un commit nuevo
    Con la aprobación y CI en verde, el botón hace el merge. main avanza a un commit nuevo, con su id: el nombre exacto de esta versión del código.
  • Imagen del gateway · tag = hash corto
    CI construye la imagen y la nombra con el commit: classifier-gateway: más los 7 caracteres de git rev-parse --short=7 HEAD. Así se sabe siempre qué código lleva adentro.
  • Repo de despliegue · un PR cambia el tag
    Con GitOps, otro PR cambia el tag de la imagen en el repositorio de despliegue, y Argo CD lo aplica en el clúster. Si truena, el rollback es un git revert aquí.
Para ir más hondoLas reglas de main

En GitHub, una regla de protección (branch protection rule) sobre main puede pedir que todo entre por PR, que al menos una persona lo apruebe, que CI esté en verde y que nadie haga push con --force. Un archivo llamado CODEOWNERS dice quién tiene que aprobar los cambios de cada carpeta: por ejemplo, que el equipo de ML apruebe todo lo que toque preprocess/.

Y el tamaño importa. Un PR de 50 líneas se lee con calma en minutos; uno de 2,000 se aprueba sin leer de verdad. Los PRs chicos se revisan mejor, chocan menos y son más fáciles de revertir.

06

Lo que no entra: .gitignore, secretos y archivos grandes

Esencial

What stays out: .gitignore, secrets and large files

No todo lo que hay en la carpeta del proyecto debe entrar al historial. Lo que casi nunca entra:

  • .venv/: el entorno virtual con las librerías instaladas. Se reconstruye en cualquier máquina a partir del lock file, que sí se versiona.
  • __pycache__/: archivos que Python genera solo para arrancar más rápido.
  • .env: el archivo .env, con ajustes del programa y muchas veces con contraseñas (la lección de configuración lo presenta).
  • Pesos: *.pt (el formato de PyTorch), *.onnx y model.plan (el modelo exportado para servirlo: ONNX y el engine de TensorRT, de la lección «Export, engine y paridad»). Alba, por ejemplo, no versiona su model.plan en Git.
  • Datos: fotos, CSV, Parquet.

El archivo .gitignore, en la raíz del repositorio, lista patrones de lo que Git debe hacer como que no existe. Una línea que termina en / ignora una carpeta entera; con el comodín *, *.pyc ignoraría todo lo que termine en .pyc. git check-ignore -v dice qué línea ignora a cada archivo.

Terminal
git init -q gateway && cd gateway
mkdir -p .venv/bin __pycache__ pesos datos
touch app.py .env .venv/bin/python __pycache__/app.cpython-313.pyc pesos/resnet50.pt datos/fotos.csv
printf '%s\n' '.venv/' '__pycache__/' '.env' 'pesos/' 'datos/' > .gitignore
git status --short --untracked-files=all   # solo aparecen dos archivos
git check-ignore -v .env pesos/resnet50.pt __pycache__/app.cpython-313.pyc
git check-ignore app.py || echo "app.py no se ignora"
echo "--- ignorar no saca lo que ya entró"
echo 'S3_KEY=clave-de-prueba' > llaves.txt
git add . && git commit -q -m "Primer gateway"   # llaves.txt entró por error
echo 'llaves.txt' >> .gitignore
git rm -q --cached llaves.txt && git commit -q -am "Deja de versionar llaves.txt"
git status --short                         # limpio: llaves.txt ya se ignora
git show HEAD~1:llaves.txt                 # pero el commit anterior todavía la tiene
Salida
?? .gitignore
?? app.py
.gitignore:3:.env	.env
.gitignore:4:pesos/	pesos/resnet50.pt
.gitignore:2:__pycache__/	__pycache__/app.cpython-313.pyc
app.py no se ignora
--- ignorar no saca lo que ya entró
S3_KEY=clave-de-prueba

touch crea archivos vacíos, printf '%s\n' escribe cada patrón en su línea y --untracked-files=all lista cada archivo suelto en vez de solo su carpeta. S3_KEY hace de llave de S3, el object storage de Amazon (es de mentira). De los siete archivos (los seis de touch y .gitignore), git status solo muestra dos. Cada línea de check-ignore -v dice el archivo .gitignore, el número de línea, el patrón y la ruta ignorada. Para app.py no hay patrón: check-ignore termina con un código de salida distinto de 0 y || corre el echo.

La segunda mitad es la trampa: ignorar no saca lo que ya entró. .gitignore solo actúa sobre archivos que Git todavía no sigue. llaves.txt ya estaba en un commit, así que agregarlo a .gitignore no basta: hay que sacarlo con git rm --cached, que lo quita del repositorio pero deja el archivo en tu carpeta. Y aun así, git show HEAD~1:llaves.txt (el archivo tal como estaba en el padre de HEAD) lo enseña completo.

Archivos grandes: por qué los pesos no van en Git

Git guarda cada versión completa de cada archivo, y cada clone baja toda la historia. Con código no importa: un archivo de Python pesa kilobytes y se comprime muy bien. Con los pesos de un modelo, sí. Lo que pesa esa historia sale de tres multiplicaciones:

Lo que pesa la historia de los pesos
s=w×d
V=v×a
H=V×s
donde
w
los parámetros del modelo
d
los bytes de cada parámetro (4 en FP32)
s
lo que pesa una versión de los pesos, en MB
v
las versiones nuevas por año
a
los años de historia
V
las versiones guardadas
H
lo que pesa el historial de ese archivo, en MB; es también lo que baja cada clone
Los pesos de Alba dentro de Git, dos añosLa cuenta
Una versión sla ResNet-50 de Alba en FP32: 24.5 millones de parámetros con su capa final de 500 categorías, 4 bytes cada uno
s=w×d = 24.5 millones × 4 bytes
≈ 98 MB
Versiones Vun fine-tune al mes (v = 12) durante dos años (a = 2)
V=v×a = 12 × 2
24
El historial Hlos pesos casi no se comprimen: son números que parecen al azar
H=V×s = 24 × 98 MB
≈ 2.35 GB
Lo que baja cada cloneuna persona nueva, o CI: toda la historia
H
≈ 2.35 GB
Resultado
Para usar los 98 MB de los pesos de hoy, cada clone baja 24 veces más. Y la historia nunca adelgaza: borrar el archivo no borra sus versiones.

GitHub, además, pone límites (según su documentación, en noviembre de 2026): avisa cuando subes un archivo de más de 50 MiB, rechaza los de más de 100 MiB y recomienda que el repositorio completo pese idealmente menos de 1 GB, y de preferencia menos de 5 GB. Los ≈ 2.35 GB de la cuenta ya se pasan del primero. Un MiB son 1,048,576 bytes (2²⁰), un poco más que un MB (1,000,000), así que los pesos de Alba, s = 98 MB = 98,000,000 bytes, son 98,000,000 ÷ 1,048,576 ≈ 93.5 MiB: entrarían, con aviso. Los pesos de casi cualquier LLM, no.

Git LFS (Large File Storage, almacén de archivos grandes) es una extensión de Git para estos archivos. El repositorio guarda, en lugar del archivo, un puntero: un texto de tres líneas con el hash SHA-256 del archivo y su tamaño. El archivo de verdad vive en un servidor aparte, y Git LFS lo baja solo cuando pides esa versión. Ojo: ese servidor sí guarda todas las versiones, y GitHub las cobra aparte. En noviembre de 2026, el plan gratuito incluye 10 GiB de almacenamiento y 10 GiB de descargas al mes, y cada archivo puede pesar hasta 2 GB (5 GB en el plan más caro).

Para ir más hondoCómo se ve un puntero de LFS

Así se arma un puntero, con Python:

Python
import hashlib

pesos = bytes(range(256)) * 4096             # 1 MiB de «pesos» de mentira, siempre iguales
puntero = ("version https://git-lfs.github.com/spec/v1\n"
           f"oid sha256:{hashlib.sha256(pesos).hexdigest()}\n"
           f"size {len(pesos)}\n")
print(puntero, end="")
print(f"el archivo: {len(pesos):,} bytes · el puntero: {len(puntero)} bytes")
Salida
version https://git-lfs.github.com/spec/v1
oid sha256:fbbab289f7f94b25736c58be46a994c441fd02552cc6022352e3d86d2fab7c83
size 1048576
el archivo: 1,048,576 bytes · el puntero: 132 bytes

En un proyecto se activa con tres comandos. Son una ilustración: Git LFS se instala aparte y el contenedor de prueba no lo trae. git lfs track escribe la regla en un archivo .gitattributes, que sí se versiona:

Terminal
git lfs install
git lfs track "*.pt"
git add .gitattributes
Pesos dentro de Git, o con Git LFSCalculadora

Git guarda cada versión completa de un archivo, y cada clone baja toda la historia. La calculadora aplica V=v×a y H=V×s, las letras de la lección. Con Git LFS, el historial guarda un puntero de ≈ 130 bytes por versión (125 más los dígitos del tamaño en bytes: 133 con 98 MB) y cada clone baja solo la versión que pide; el servidor de LFS, en cambio, sí guarda todas las versiones. Arranca con los pesos de Alba: 98 MB, un fine-tune al mes, dos años.

Versiones guardadas, VV=v×a24
Historial dentro de Git, HH=V×s: los pesos casi no se comprimen2.35 GB
Historial con Git LFS (solo los punteros)V × (125 bytes + los dígitos del tamaño en bytes)3.19 KB
Lo que guarda el servidor de LFSV×s: todas las versiones; en GitHub Free caben 10 GiB (noviembre de 2026)2.35 GB
Lo que baja cada clone sin LFSH: toda la historia2.35 GB
Lo que baja cada clone con LFSs: solo la versión que pides98.0 MB
Tráfico de clones al día, sin LFSH×c23.5 GB
El archivo contra el límite de GitHub sin LFS (100 MiB)s ÷ 100 MiB, con 1 MiB = 1,048,576 bytes; más de 100 %: GitHub rechaza el push93.5 %
El archivo contra el límite de Git LFS en GitHub Free (2 GB)s ÷ 2 GB; más de 100 %: ni con LFS entra en un solo archivo4.9 %

Con 98 MB, el archivo queda en ≈ 93.5 % del límite: entra, con aviso. Con 16,000 MB (un LLM de 8 mil millones de parámetros en BF16), no entra sin LFS, y en un solo archivo tampoco entra con LFS en GitHub Free (2 GB por archivo; límites de GitHub en noviembre de 2026): lo normal es partirlo en varios archivos o dejarlo en object storage.

Prueba con un LLM chico: 16,000 MB (unos 8 mil millones de parámetros en BF16) y una versión al mes. ¿Qué pasa con el límite de GitHub?

LFS resuelve el tamaño, pero en un sistema de ML los datos y los pesos suelen ir mejor en otro lado: en object storage (como S3), en rutas que nunca se reescriben, y en Git solo una referencia con su hash. Dicho corto: Git versiona tu código; nada versiona tus datos a menos que lo diseñes. DVC, por ejemplo, guarda en Git un archivo chico con el hash y deja los datos en S3; lakeFS da ramas y commits sobre el object storage mismo. Cómo se versionan los datos, el versionado de datos, y cómo se sigue de dónde salió cada cosa, el linaje, lo ves en la lección «Versionado y linaje».

07

Tags, revert y la trazabilidad de Alba

Esencial

Tags, revert and Alba's traceability

Tags: un nombre que no se mueve

Una rama se mueve con cada commit. A veces quieres lo contrario: un nombre que se quede para siempre en un commit, como «el gateway que salió el lunes». Eso es un tag (etiqueta). Con -a se crea un tag anotado: un objeto con autor, fecha y mensaje, como un commit chiquito. Sin -a, es solo el nombre.

Los tags de versión suelen seguir la versión semántica de la lección de Python: en v1.4.0, 1 es la versión mayor (cambios que rompen a quien te usa), 4 la menor (algo nuevo que no rompe) y 0 el parche (un arreglo). Ojo: git push no sube los tags. Se suben aparte, con git push origin v1.4.0.

Volver a ayer: revert contra reset

En este bloque, alguien escribe 0.015 en vez de 0.15: el gateway le da a Triton 15 ms en lugar de 150, casi todas las requests se rinden antes de tiempo y la app recibe errores. Hay que volver a lo de ayer.

Terminal
git init -q gateway && cd gateway
echo 'INFER_TIMEOUT_S = 0.15' > config.py && git add . && git commit -q -m "Agrega el timeout"
git tag -a v1.4.0 -m "El gateway que salió el lunes"
echo 'INFER_TIMEOUT_S = 0.015' > config.py && git commit -q -am "Ajusta el timeout"
git log --oneline --decorate
git rev-parse --short=7 v1.4.0^{commit}    # a qué commit apunta el tag
echo "--- revert: un commit nuevo que deshace el malo"
git revert --no-edit HEAD > /dev/null
git log --oneline
cat config.py
echo "--- reset: la rama vuelve atrás y lo de después ya no está en ella"
git reset -q --hard v1.4.0
git log --oneline
Salida
6dcfb7f (HEAD -> main) Ajusta el timeout
1e53ceb (tag: v1.4.0) Agrega el timeout
1e53ceb
--- revert: un commit nuevo que deshace el malo
d895046 Revert "Ajusta el timeout"
6dcfb7f Ajusta el timeout
1e53ceb Agrega el timeout
INFER_TIMEOUT_S = 0.15
--- reset: la rama vuelve atrás y lo de después ya no está en ella
1e53ceb Agrega el timeout

--decorate muestra qué nombres apuntan a cada commit, y > /dev/null tira lo que imprime revert. Las dos maneras de volver son muy distintas:

git revertgit reset --hard
Qué haceCrea un commit nuevo que hace lo contrario de otroMueve la rama hacia atrás y deja el área de trabajo igual que ese commit
La historiaCrece: queda escrito que hubo un error y que se deshizoSe acorta: los commits de después ya no están en la rama
Lo que no habías guardadoNo lo toca: Git se niega a revertir si tienes cambios a medias en esos archivosSe pierde
En una rama compartidaSeguro: es un commit más, que se sube con push normalPeligroso: subirlo pide --force y reescribe la historia de todos

La regla: revert para lo que ya se compartió; reset solo para tu trabajo local. Volver a ayer en main es un revert.

Para ir más hondo¿Se perdió para siempre lo del reset?

Casi nunca de inmediato. Git anota en el reflog (reference log) cada lugar al que apuntó HEAD, y los commits que quedaron sin rama siguen en .git hasta que una limpieza los borra: por omisión, el reflog los recuerda 30 días, y pasado ese plazo la siguiente limpieza (git gc, que Git corre solo de vez en cuando) ya puede borrarlos. git reflog los lista, y git branch rescate 6dcfb7f los recupera con una rama nueva. Lo que sí se pierde para siempre con reset --hard son los cambios que nunca entraron a un commit.

La trazabilidad de Alba

Ahora puedes contestar la primera pregunta de la lección: ¿qué código exacto corre en producción?

En Alba, cada vez que un cambio entra a main, CI construye la imagen del gateway (la imagen de un contenedor, el paquete con el programa y todo lo que necesita para correr) y la nombra con el commit: TAG=$(git rev-parse --short=7 HEAD) da 3f9c2ab, y la imagen se llama classifier-gateway:3f9c2ab. Nunca :latest, que cambia de contenido cada vez que alguien sube otra imagen. Con ese nombre, git show 3f9c2ab enseña el código exacto, y git log 3f9c2ab..8d41e07 (con 8d41e07 como ejemplo de la versión nueva) lista todo lo que cambió entre dos versiones. La imagen tiene además su propia huella, su digest, que ves en la lección «Empaquetado con Docker».

Con el modelo pasa lo mismo, con más ingredientes. En Alba, cada modelo registrado guarda tres punteros: el snapshot de datos, el commit de código y el digest del contenedor de entrenamiento. El snapshot es la foto fija de los datos con que se entrenó (por ejemplo, ds-2026-09-01); el commit, el código de entrenamiento; el digest, el entorno exacto donde corrió. El lugar donde se guardan los modelos con esos punteros es el registro de modelos, de la lección «Gate de evaluación y registry». Con los tres, cualquiera puede contestar de dónde salió resnet50-2026-10-01, y volver a entrenarlo.

La trazabilidad de Alba: del modelo en producción a su origen · Del modelo que responde en producción hacia atrás, hasta el código, los datos y el entorno que lo produjeron. Usa «Recorrer» para seguir la pregunta «¿de dónde salió?» y la vuelta a la versión de ayer.
  • Commit de código · c3f2fc2 · entrenamiento
    El commit exacto del código de entrenamiento. Solo dice la verdad si el árbol estaba limpio: si el script tenía cambios sin commit, apunta a otro código.
  • Snapshot de datos · ds-2026-09-01
    El snapshot: la lista fija de datos con que se entrenó, en object storage, en un prefijo que no se reescribe. Git no versiona datos: el snapshot sí.
  • Imagen de entrenamiento · fijada por su digest
    El entorno exacto donde corrió el entrenamiento: la imagen de contenedor, identificada por su digest, la huella SHA-256 de su contenido. Lo ves en la lección «Empaquetado con Docker».
  • Modelo registrado · resnet50-2026-10-01
    En el registro de modelos, cada versión guarda tres punteros: commit, snapshot y digest. No copia nada: apunta. Con los tres, el modelo se puede explicar y volver a entrenar.
  • Repo de despliegue · qué imagen y qué modelo
    Con GitOps, este repositorio dice qué corre en el clúster. Su historia es la historia de producción, y volver a ayer es un git revert.
  • Gateway · classifier-gateway:3f9c2ab
    La imagen del gateway lleva como tag el hash corto del commit de su código: git show 3f9c2ab enseña exactamente qué corre. Es otro commit, del código del gateway, no del entrenamiento.
  • Triton · sirve resnet50-2026-10-01
    Triton responde con el modelo resnet50-2026-10-01, y esa versión viaja en cada respuesta y en cada línea de log. Es la punta del hilo.

Hay una trampa. Herramientas como MLflow, que anotan cada entrenamiento, guardan solas el commit de donde corrió el script. Pero si cambiaste el script y no hiciste commit, anotan el commit de antes: es una falsa tranquilidad, porque el código que produjo ese modelo no existe en Git. La defensa es entrenar solo con el árbol limpio. git status --porcelain imprime lo mismo que --short, en un formato pensado para programas; si no imprime nada, no hay cambios sin commit:

Terminal
git init -q entrenamiento && cd entrenamiento
echo 'lr = 0.001' > train.py && git add . && git commit -q -m "Entrenamiento base"
git status --porcelain; echo "porcelain vacío: árbol limpio, se puede entrenar"
echo 'lr = 0.0005' > train.py              # alguien cambia el script y no hace commit
git status --porcelain
git rev-parse --short HEAD                 # el commit sigue siendo el mismo
test -z "$(git status --porcelain)" || echo "árbol sucio: el pipeline se niega a entrenar"
Salida
porcelain vacío: árbol limpio, se puede entrenar
 M train.py
1b1defb
árbol sucio: el pipeline se niega a entrenar

test -z es verdad si el texto está vacío. El pipeline de Alba hace esa revisión antes de entrenar a un candidato (un modelo nuevo que aspira a producción): si hay cambios sin commit, falla.

08

Cómo trabaja un equipo: trunk-based, monorepo y GitOps

Extra

How a team works: trunk-based, monorepo and GitOps

Git da las piezas. Cómo se usan en un equipo es una decisión, y de estas tres vas a oír en cualquier entrevista.

Trunk-based contra gitflow

En el desarrollo trunk-based (trunk-based development, «sobre el tronco»), todos integran a main, el tronco, seguido: las ramas viven horas o uno o dos días, y cada PR es chico. main siempre está lista para publicarse. Lo que aún no se termina entra apagado detrás de una feature flag, un interruptor de la configuración que lo deja oculto hasta que se prende.

Gitflow, el modelo que Vincent Driessen publicó en 2010, usa ramas largas: main con lo publicado, develop con lo que viene, y ramas feature/, release/ y hotfix/ que salen de ellas y vuelven. Sirve para software que se publica por versiones numeradas, como una app que pasa por la tienda o una librería. El mismo Driessen agregó en 2020 una nota a su artículo: para una app web que se entrega todo el tiempo, recomienda algo más simple. Para un servicio que se despliega varias veces al día, como el gateway de Alba, es pesado: las ramas largas se separan, y cada merge grande trae conflictos grandes.

Alba trabaja trunk-based: ramas cortas, PR con revisión y CI, y main siempre desplegable.

Monorepo contra varios repositorios

Un monorepo es un solo repositorio con varios proyectos: en Alba serían el gateway, el código de entrenamiento, el preprocesamiento compartido y la infraestructura. La alternativa es un repositorio por proyecto (a veces se le dice polyrepo).

MonorepoUn repo por proyecto
Un cambio que toca dos proyectosUn solo PR y un solo commitUn PR en cada repo, en el orden correcto
Qué versión va con cuálUn commit describe todo el sistemaHay que anotar qué versión de cada uno va junta
Lo que cuestaEl repo crece, y CI tiene que correr solo lo que cambióCada equipo decide solo, pero coordinar es más trabajo
PermisosMás gruesos: todos ven todoCada repo con los suyos

En ML el monorepo tiene un premio concreto. Alba usa un solo paquete de preprocesamiento, preprocess.py, en el entrenamiento y en el gateway. En un monorepo, un cambio al preprocesamiento entra a los dos en el mismo commit, y el training-serving skew no tiene por dónde colarse. Google guarda casi todo su código en un solo repositorio gigante, con un sistema propio en lugar de Git.

GitOps: el clúster lee el repositorio

Alba corre en Kubernetes, el sistema de orquestación que decide cuántas copias de cada programa correr y en qué máquinas (lo ves a fondo en la lección «Kubernetes»). Kubernetes se maneja con archivos de texto en YAML llamados manifests, que describen lo que debe correr: qué imagen, cuántas copias, con qué memoria.

En GitOps (el nombre lo puso la empresa Weaveworks en 2017), esos manifests viven en un repositorio, y un programa dentro del clúster, Argo CD o Flux (dos proyectos de la CNCF, la fundación que también cuida Kubernetes), compara sin parar lo que dice el repositorio con lo que corre de verdad y aplica la diferencia. Las consecuencias:

  • Desplegar es un PR que cambia la imagen (el tag y el digest), y la historia queda en Git. La aprobación humana puede estar en la revisión de ese PR o en el pipeline antes de juntarlo (lo ves en «CI/CD y registro de imágenes»).
  • El rollback es un revert, que también pasa por PR.
  • La historia del repositorio es la historia de producción: quién desplegó qué, quién lo pidió y cuándo se aplicó.
  • Un cambio a mano no dura. Si alguien cambia el clúster sin pasar por Git, el clúster ya no coincide con el repositorio (configuration drift, deriva de configuración; no es el drift de los datos, aunque comparta la palabra). Si además de la sincronización automática está prendida la autorreparación (self-heal, apagada por omisión), Argo CD lo regresa solo a lo que dice Git; si no, lo marca como distinto y lo pisa en la siguiente sincronización.

Así se ve, en pequeño, el repositorio de despliegue de Alba (sed -i cambia un texto dentro del archivo; en macOS se escribe sed -i '', y 8d41e07 es un commit de ejemplo):

Terminal
git init -q despliegue && cd despliegue         # el repo que Argo CD vigila
echo 'image: classifier-gateway:3f9c2ab' > gateway.yaml
git add . && git commit -q -m "Gateway 3f9c2ab"
sed -i 's/3f9c2ab/8d41e07/' gateway.yaml         # el PR del martes: la versión nueva
git commit -q -am "Gateway 8d41e07"
git revert --no-edit HEAD > /dev/null           # truena: el rollback es un revert
git log --oneline
cat gateway.yaml
Salida
57ece20 Revert "Gateway 8d41e07"
234cac0 Gateway 8d41e07
df5403a Gateway 3f9c2ab
image: classifier-gateway:3f9c2ab

Después del revert, el archivo vuelve a pedir 3f9c2ab, Argo CD lo nota y el clúster regresa a la imagen de ayer, que ya existía: nadie la reconstruye. Y la historia guarda las tres cosas: la versión vieja, la nueva y la vuelta.

09

Errores comunes

Esencial

Common mistakes

1. Subir un secreto y creer que borrarlo lo arregla

Una llave entra en un commit, alguien la ve en el PR, y la solución parece un commit que la borra. Pero sigue en la historia, en cada clone y en cada copia del remoto.

Cómo evitarlo: .env y todo lo que traiga llaves va en .gitignore desde el primer commit, y las llaves viven fuera del repositorio (la lección de configuración). Si una ya se subió, se cambia por otra de inmediato: se da por filtrada.

2. Meter pesos y datos al repositorio

git add . con la carpeta pesos/ adentro, y el repositorio crece 98 MB con cada versión, para siempre. A los meses, clonar tarda minutos y GitHub rechaza el push del primer archivo de más de 100 MiB.

Cómo evitarlo: pesos, datos y .venv/ van en .gitignore. Los pesos y los datos viven en object storage, con su versión, y Git guarda solo la referencia y su hash; si de verdad deben ir junto al código, con Git LFS. Revisa git status antes de cada commit.

3. Reescribir una rama que otros ya bajaron

Un rebase o un reset en main, seguido de git push --force, borra del remoto los commits de los demás. La próxima vez que bajen, su historia y la del remoto no coinciden.

Cómo evitarlo: rebase y reset solo en tu rama, antes de compartirla. En lo compartido, git revert. Protege main para que nadie pueda forzarla, y si alguna vez fuerzas tu propia rama, usa --force-with-lease.

4. Entrenar con el árbol sucio

El script cambió, nadie hizo commit, y el modelo queda registrado con el commit de antes. Meses después, volver a ese commit no reproduce el modelo, y nadie sabe por qué.

Cómo evitarlo: el pipeline revisa git status --porcelain y se niega a entrenar si no está vacío. Los candidatos a producción se entrenan desde CI, que parte de un commit limpio, nunca desde una laptop.

5. Usar como versión algo que se mueve

«En producción está main» o «la imagen es :latest»: los dos nombres apuntan mañana a otra cosa. Un rollback a «main» no regresa a ningún lado.

Cómo evitarlo: la versión de lo que corre es un id que no cambia: el SHA del commit en el tag de la imagen, o un tag de Git como v1.4.0. Y lo que bajas de otros, como un modelo de un repositorio público, se fija en un commit, no en una rama.

6. Arreglar producción a mano cuando hay GitOps

A medianoche alguien cambia la imagen directo en el clúster para salir del problema. Git ya no describe lo que corre, nadie revisó el cambio, y la siguiente sincronización lo deshace.

Cómo evitarlo: el arreglo también va por Git: un revert en el repositorio de despliegue, con un PR que se aprueba rápido. Si de verdad hubo que tocar el clúster a mano, ese mismo día el cambio se escribe en el repositorio.

10

En la vida real

Extra

In real life

Alba: la noche del timeout

Así contestaría Alba el martes de la introducción. La historia es un ejemplo armado con las piezas de su sistema, no un incidente real.

A las 23:05 suena la alerta: el gateway responde errores 504 (el código de estado de «me cansé de esperar»). La primera pregunta, qué corre, se contesta en el repositorio de despliegue: desde las 22:40 pide classifier-gateway:8d41e07, y ayer pedía 3f9c2ab. La segunda, qué cambió, la contesta git log 3f9c2ab..8d41e07: tres commits, y uno se llama «Ajusta el timeout». La tercera, cómo volver: un revert en el repositorio de despliegue, aprobado en dos minutos. Argo CD lo aplica y el clúster vuelve a la imagen de ayer, que ya existía. Rollback primero, investigar después.

A la mañana siguiente, el arreglo de verdad entra por PR al gateway, con una prueba que falla si el timeout queda por debajo de lo que tarda Triton en el p99 (el tiempo que no pasa el 99 % de las requests). Nada se perdió: el commit malo, su revert y el arreglo están en la historia, con autor, hora y quién los aprobó.

Un LLM propio y los modelos de Hugging Face

Hugging Face, el sitio donde se publican modelos abiertos, guarda cada modelo como un repositorio de Git, con los pesos en archivos grandes fuera del historial normal: primero con Git LFS y, desde 2025, con su propio sistema, Xet, que sigue la misma idea. Su rama main puede cambiar: el dueño sube pesos nuevos y el mismo nombre ya es otro modelo. Por eso, quien sirve su propio LLM fija la revisión exacta: el commit del repositorio en Hugging Face, no main. Las librerías aceptan una revisión, y un servidor que sirve un LLM a varios equipos carga siempre ese commit.

Los datos también apuntan al código

En Alba, la tarjeta de un snapshot de datos dice de qué código salió: "code": {"repo": "ml-catalogo", "commit": "4be1d0a"}. Si el dataset trae un error, se sabe exactamente qué versión del código que lo armó hay que revisar. Y su primer dataset queda amarrado con un tag de Git, dataset-v1: los datos viven en S3, y el tag marca el commit del código que lo armó, cuya tarjeta guarda la huella del manifest.

Uber, 2016: una llave en un repositorio

En 2016, unos atacantes entraron a un repositorio privado que usaban ingenieros de Uber en GitHub y encontraron credenciales de la nube de Amazon. Con ellas bajaron datos de unos 57 millones de usuarios y conductores. El repositorio era privado: no bastó. Lo que está en un repositorio lo puede leer cualquiera que consiga entrar, hoy o en diez años.

Git, Linux y GitHub

Linux, el sistema operativo de casi todos los servidores, se coordinaba con un programa comercial llamado BitKeeper, hasta que en 2005 se acabó el permiso para usarlo gratis. Linus Torvalds escribió Git en unas semanas para reemplazarlo, pensando en miles de personas que trabajan en paralelo, sin un servidor central obligatorio, y con ids que nadie pudiera falsificar. GitHub nació en 2008 sobre Git, y en 2018 Microsoft lo compró por US$7,500 millones.

11

Ejercicios

Esencial

Exercises

Resuélvelos antes de abrir la solución. Los que tienen comandos los puedes comprobar en tu terminal, con un repositorio de prueba.

  1. 1Fácil

    git status --short imprime tres líneas: ?? notas.txt, M app.py y M config.py. ¿En qué lugar está cada cambio? Si haces git commit -m "..." ahora mismo, ¿qué entra a la foto?

    Ver la solución paso a paso
    • ?? notas.txt: Git no lo sigue. Está solo en el área de trabajo.
    • M app.py (la M en la segunda columna): cambió en el área de trabajo, pero no está en el staging.
    • M config.py (la M en la primera columna): el cambio está en el staging.
    • El commit lleva solo config.py, porque git commit guarda lo que hay en el staging. Para meter app.py, primero git add app.py (o git commit -a). notas.txt no entra con ninguno de los dos: un archivo nuevo necesita su git add.
  2. 2Fácil

    Un compañero no quiere crear una rama para probar una idea, «porque el proyecto pesa 300 MB y se me va a llenar el disco». ¿Tiene razón? ¿Cuánto ocupa una rama?

    Ver la solución paso a paso
    • No. Una rama es un archivo en .git/refs/heads/ con el id de un commit: 40 caracteres y un salto de línea, 41 bytes.
    • Crear la rama no copia ningún archivo. Cambiarse a ella solo reescribe en el área de trabajo los archivos que son distintos entre las dos ramas.
    • Lo que sí ocupa espacio son los commits nuevos, y solo por el contenido que cambió.
  3. 3Fácil

    ¿Qué de esta lista va en el .gitignore del gateway, y qué sí se versiona? app.py, .env, .venv/, uv.lock, tests/test_app.py, __pycache__/, pesos/resnet50.pt, Dockerfile.

    Ver la solución paso a paso
    • Se ignora: .env (ajustes y llaves), .venv/ (se reconstruye), __pycache__/ (Python lo genera) y pesos/resnet50.pt (va en object storage o en Git LFS).
    • Se versiona: app.py, tests/test_app.py, Dockerfile y uv.lock. El lock file es justo lo que permite reconstruir .venv/ igualito en otra máquina: si se ignora, cada quien instala versiones distintas.
  4. 4Fácil

    En cada caso, ¿el merge es fast-forward o crea un commit de merge? (a) Sacas la rama fix de main, haces dos commits y nadie tocó main. (b) Igual, pero mientras tanto Luis unió un PR a main. (c) Después de (b), haces rebase de fix sobre main y luego el merge.

    Ver la solución paso a paso
    • (a) Fast-forward: main sigue donde la dejaste, solo se adelanta su etiqueta.
    • (b) Commit de merge: cada rama tiene commits que la otra no; el commit nuevo tiene dos padres.
    • (c) Fast-forward otra vez, con git merge en tu terminal: después del rebase, tus commits quedaron encima del último de main, como si hubieras empezado hoy. Por eso muchos equipos hacen rebase antes de unir. (El botón «Create a merge commit» de GitHub crea un commit de merge siempre, aunque se pudiera adelantar.)
  5. 5Medio

    Un archivo respuesta.py contiene una sola línea, TOP_K = 5, con su salto de línea al final. ¿Qué bytes exactos le pasa Git a SHA-1 para calcular su id? Comprueba el id con Python.

    Ver la solución paso a paso
    • La regla de la sección 2: id=SHA-1(encabezado+contenido), con el encabezado blob, un espacio, el tamaño y un byte en cero.
    • El contenido son 10 bytes: los 9 caracteres de TOP_K = 5 más el salto de línea.
    • Git calcula el SHA-1 de blob 10, un byte en cero y los 10 bytes: b"blob 10\0TOP_K = 5\n".
    • Con la función id_git de la sección 2, id_git("blob", b"TOP_K = 5\n") da 1e0b1ade696068e087656f8ae5e859fe92aef3b8, lo mismo que git hash-object respuesta.py.
    • Fíjate en que el nombre del archivo no entra en la cuenta: otro archivo con el mismo contenido tiene el mismo id, y Git lo guarda una sola vez.
  6. 6Medio

    Al unir dos ramas, config.py queda así: <<<<<<< HEAD, TOP_K = 5, =======, TOP_K = 10, >>>>>>> nueva-ui, cada uno en su línea. El equipo decide que 5 siga siendo el valor por omisión y que quien llama al gateway pueda pedir otro. ¿Qué escribes y qué comandos corres?

    Ver la solución paso a paso
    • HEAD es tu rama (dice 5) y nueva-ui la que unes (dice 10). La decisión no es ninguna de las dos al pie de la letra: el valor por omisión es 5, y quien llama puede pedir otro.
    • Dejas el archivo con TOP_K = 5, sin ningún marcador. Lo de aceptar el top_k de la request es un cambio del código del gateway, en otro commit.
    • git add config.py para marcarlo resuelto y git commit para terminar el merge.
    • Antes de subir, corre las pruebas: un merge resuelto a mano es código nuevo que nadie ha probado.
  7. 7Medio

    Un repositorio tiene 50,000 objetos (commits, árboles y blobs). Con prefijos de 7 caracteres, ¿qué tan probable es que al menos dos empiecen igual? ¿Y con 8?

    Ver la solución paso a paso
    • Las fórmulas de la sección 2: M=16k, P=n×(n−1)/2 y Pr≈1−e−P/M, con n = 50,000.
    • Parejas: P = 50,000 × 49,999 ÷ 2 = 1,249,975,000.
    • 7 caracteres: M = 16⁷ = 268,435,456. P/M = 1,249,975,000 ÷ 268,435,456 ≈ 4.66, y Pr≈1−e−4.66 ≈ 99 %: es casi seguro que hay un choque.
    • 8 caracteres: M = 16⁸ = 4,294,967,296. P/M = 1,249,975,000 ÷ 4,294,967,296 ≈ 0.291, y Pr≈1−e−0.291 ≈ 25 %.
    • Por eso Git alarga solo los ids que chocan, y en repositorios grandes muestra más de 7. Un script que corta siempre a 7 puede dar un id ambiguo; git rev-parse --short=7 da 7 o más, los que hagan falta.
  8. 8Reto

    Son las 23:00. El repositorio de despliegue de Alba (con GitOps) tiene, del más nuevo al más viejo: b41c «Gateway 8d41e07», a7e2 «Sube el mínimo de réplicas a 6» (las copias del gateway que como mínimo corren a la vez) y 9d03 «Gateway 3f9c2ab». Desde b41c, los errores 504 se dispararon. Una persona propone git reset --hard 9d03 y git push --force. ¿Qué haces tú, y por qué?

    Ver la solución paso a paso
    • El problema llegó con b41c, la imagen nueva del gateway. a7e2, las réplicas, es un cambio aparte que funcionaba.
    • reset --hard 9d03 se llevaría también a7e2, y el push con --force reescribiría main del repositorio de despliegue: los demás quedan con una historia que ya no existe, y se pierde el registro de qué pasó.
    • Lo correcto es git revert b41c en un PR, aprobado rápido. Deshace solo la imagen nueva, conserva el mínimo de 6 réplicas, deja escrito el rollback y se sube con un push normal.
    • Argo CD ve el cambio y regresa el clúster a 3f9c2ab, que ya existe en el registro de imágenes, el almacén de imágenes que ves en la lección «CI/CD y registro de imágenes». Al día siguiente: git log 3f9c2ab..8d41e07 en el gateway para encontrar la causa, y un PR con el arreglo y una prueba.
  9. 9Reto

    MLflow dice que el modelo resnet50-2026-10-01 salió del commit c3f2fc2. Lo reentrenas desde ese commit con el mismo snapshot de datos y la misma imagen, y el resultado es distinto: el top-1 en el golden set baja 2 puntos. (a) ¿Cuál es la causa más probable que tiene que ver con Git? (b) ¿Cómo lo confirmas? (c) ¿Qué cambias para que no vuelva a pasar?

    Ver la solución paso a paso
    • (a) Que el modelo original se entrenó con cambios sin commit: el script estaba modificado y MLflow anotó el commit de antes, c3f2fc2. El código que lo produjo no existe en Git.
    • (b) Busca en MLflow si la corrida guardó algo más que el commit (los parámetros, la configuración, una copia del script) y compáralo con git show c3f2fc2:train.py. Si el learning rate o el número de epochs no coinciden, ahí está. Descarta también lo que no es Git: la semilla, y las variaciones normales de la GPU.
    • (c) El pipeline revisa git status --porcelain antes de entrenar y se niega si no está vacío. Los candidatos se entrenan desde CI, que parte de un commit limpio. Y el modelo registrado guarda sus tres punteros: commit, snapshot y digest de la imagen de entrenamiento.
12

Lo que sigue

Esencial

What comes next

La siguiente lección, «Pruebas y CI/CD», es lo que corre en cada PR: las pruebas, la integración continua y el despliegue. Después, «Configuración: YAML, variables de entorno y secretos» explica dónde va lo que no entra al repositorio.

Más adelante, «Versionado y linaje» amarra cada snapshot de datos al commit que lo armó, y «Rollout seguro» despliega con GitOps y vuelve atrás con un revert.

13

Palabras que vas a oír

Esencial

Words you will hear

Estos son los conceptos que presentó esta lección. Cada uno tiene su tarjeta con la definición completa.

GitGitUn programa que guarda la historia de un proyecto: cada versión es una foto completa de sus archivos, con autor, fecha, mensaje y un id que es el hash de todo su contenido. Es distribuido: cada copia trae la historia entera.Más

Lo escribió Linus Torvalds en abril de 2005 para el código de Linux, y hoy es el sistema de versiones más usado. Guarda fotos, no diferencias: si un archivo no cambió, la foto nueva apunta al mismo contenido de antes. Cada versión es un commit, cada línea de trabajo es una rama y la carpeta con su historia es un repositorio. Como cada persona tiene la historia completa, puede ver versiones viejas y guardar nuevas sin internet; el servidor (GitHub, GitLab) es una copia más, la que el equipo usa para juntar su trabajo.

Analogía. Un álbum donde cada foto es el proyecto entero y lleva escrita la foto anterior. Se rompe en que las fotos no se pueden retocar sin que cambie su nombre y el de todas las que vienen después.

Ejemplo. En Alba, la imagen del gateway se llama classifier-gateway:3f9c2ab: con git show 3f9c2ab se ve el código exacto que corre en producción.

Ver en el glosario →

Repositoriorepository · repoLa carpeta de un proyecto que Git vigila, con una carpeta oculta .git donde vive toda su historia. Un cambio pasa por tres lugares: el área de trabajo (lo que editas), el staging (lo que va a entrar en la próxima versión guardada) y el historial (las versiones ya guardadas).Más

El área de trabajo (working tree) son los archivos que ves y editas. El staging (staging area o index) es lo que va a entrar en la próxima foto; se llena con git add. El historial son los commits ya guardados en .git; se agrega uno con git commit. git status --short dice con dos letras dónde está cada archivo: ?? sin seguir, A o M en la primera columna si está en el staging, M en la segunda si cambió y no está en el staging. Si borras .git, los archivos se quedan pero la historia desaparece. Un repositorio puede tener copias en otros lugares: los remotos.

Ejemplo. git init -q gateway crea la carpeta gateway con su .git; después de git add config.py y git commit, git status --short ya no imprime nada: el árbol está limpio.

Ver en el glosario →

CommitcommitUna foto guardada del proyecto: la lista de sus archivos (el árbol), el id del commit anterior (su padre), el autor, la fecha y un mensaje. Su id es el hash (SHA-1, por omisión) de todo eso, así que cambiar cualquier cosa del pasado cambia todos los ids siguientes.Más

Git calcula el id con un hash criptográfico (SHA-1 por omisión, que se escribe con 40 caracteres hexadecimales) del texto del commit. Como ese texto incluye el id del padre, cada commit amarra toda la historia anterior: nadie puede cambiar el código de un commit y conservar su id. Se suele usar el hash corto, los primeros 7 caracteres (más si otro objeto empieza igual). El mismo contenido con el mismo autor, fecha, mensaje y padre da el mismo id en cualquier máquina. No es el COMMIT de una transacción de base de datos ni el commit de un offset en una cola: los tres dicen «esto queda firme», pero son cosas distintas.

Ejemplo. El commit «Sube el timeout a 0.20 s» son 213 bytes de texto; Git calcula el SHA-1 de commit 213, un byte en cero y esos bytes, y le salen los 40 caracteres que empiezan con 139f652. Con un carácter menos en el mensaje, el id es otro: c27a81e.

Ver en el glosario →

RamabranchUn nombre que apunta a un commit y avanza solo con cada commit nuevo que haces en ella. Crearla es escribir un archivo de 41 bytes: no copia ningún archivo del proyecto.Más

Git guarda cada rama en .git/refs/heads/ con el id completo de su commit (40 caracteres y un salto de línea). main es el nombre que casi todos usan para la primera rama (GitHub, desde 2020); Git 2.x todavía la llama master si no configuras init.defaultBranch main. HEAD dice en qué rama estás: es el archivo .git/HEAD, que normalmente contiene ref: refs/heads/main. git switch -c nombre crea una rama y te pasa a ella. Con las ramas, cinco personas trabajan a la vez sin pisarse: cada una en la suya, y al final se unen con un merge o se ponen al día con un rebase.

Analogía. Un separador de libro que se mueve solo a la página que acabas de escribir. Se rompe en que un libro tiene una sola historia, y en Git cada separador puede seguir su propia continuación.

Ejemplo. Cien ramas ocupan 100 × 41 = 4,100 bytes, unos 4 KB, aunque el proyecto pese 300 MB.

Ver en el glosario →

MergemergeUnir el trabajo de una rama a otra. Si la rama de destino no se movió, Git solo adelanta su etiqueta (fast-forward); si las dos avanzaron, crea un commit de merge con dos padres.Más

Para juntar dos versiones, Git busca la base, el último commit que las dos ramas tienen en común, y compara cada una contra ella. Si cambiaron archivos o líneas distintas, toma los dos cambios solo. Si cambiaron las mismas líneas de manera distinta, hay un conflicto y te toca decidir. En GitHub, un merge suele hacerse con el botón de un pull request, que permite un commit de merge, un squash (todo el PR en un solo commit) o un rebase.

Ejemplo. main está en 821910a y la rama logs agregó 26b7ad8 mientras main agregaba 60006fd: el merge crea 9341d8a, cuyos dos padres son 60006fd y 26b7ad8.

Ver en el glosario →

Conflicto de mergemerge conflictLo que pasa cuando dos ramas cambiaron las mismas líneas del mismo archivo (o líneas pegadas) de manera distinta: Git no adivina cuál quieres, marca el pedazo en el archivo y se detiene para que decidas.Más

El pedazo en disputa queda entre marcadores: de <<<<<<< HEAD a ======= está tu versión, y de ahí a >>>>>>> otra-rama, la de la rama que estás uniendo. git status --short muestra el archivo con UU. Se resuelve editando el archivo (tu versión, la otra o una tercera), borrando los marcadores, con git add y con git commit; git merge --abort deshace el intento. Lo difícil suele ser la decisión, no Git. Se evitan con ramas cortas, cambios chicos y trayendo seguido lo nuevo de main.

Ejemplo. Luis sube INFER_TIMEOUT_S a 0.25 en su rama y Ana lo baja a 0.10 en main: al unir, config.py queda con las dos líneas entre marcadores, y lo resuelven dejando 0.15.

Ver en el glosario →

RebaserebaseRehacer tus commits, uno por uno, encima del último commit de otra rama, para que la historia quede en línea recta. Como cambia el padre de cada commit, todos salen con ids nuevos.Más

Rebase no mueve commits: crea copias con los mismos cambios y mensajes, y deja los originales sin rama que los nombre. De ahí la regla de oro: no hagas rebase de commits que otros ya bajaron, porque quedarían dos historias distintas con el mismo trabajo. En tu rama, antes de compartirla, es seguro y deja una historia fácil de leer; git pull --rebase pone tus commits locales encima de lo que bajaste. git rebase -i sirve para juntar o corregir tus commits antes de subirlos. Después de un rebase de una rama que ya estaba en el remoto, subirla pide --force-with-lease.

Ejemplo. La rama logs tenía 0750449 y 707221d encima de 1e53ceb. Después de git rebase main, quedan como 26b7ad8 y a8b1758 encima de 821910a: mismos cambios, ids nuevos.

Ver en el glosario →

Remotoremote · originOtra copia de tu repositorio, en otro lugar, con la que intercambias commits. Por costumbre, la principal se llama origin, y casi siempre vive en GitHub o en GitLab.Más

git clone baja un repositorio con toda su historia y apunta origin a su dirección. git fetch baja lo nuevo sin tocar tus ramas (queda en origin/main); git pull hace un fetch y lo une a tu rama (si tu rama también tiene commits propios, el Git de hoy pide que elijas --rebase o --no-rebase); git push sube tus commits. Push solo mueve la rama del remoto hacia adelante: si alguien subió algo que no tienes, se rechaza, porque si entrara borraría su trabajo. --force sobrescribe de todos modos; --force-with-lease se niega si el remoto cambió desde la última vez que lo viste. Los equipos protegen main para que nadie la fuerce.

Ejemplo. Luis sube primero; el push de Ana se rechaza con «! [rejected] main -> main (fetch first)». Ana corre git pull --rebase origin main, su commit queda encima del de Luis y el segundo push entra.

Ver en el glosario →

Pull requestpull request · PR · merge requestUna petición, en GitHub, para unir tu rama a main, la rama principal: muestra el diff (las líneas que salen y las que entran), los commits, la conversación y el resultado de las pruebas, y se une con un botón cuando se aprueba. En GitLab se llama merge request.Más

En un equipo casi nadie sube directo a main: cada cambio va en su rama, la rama se sube al remoto y se abre un PR. Ahí ocurre la revisión de código y corren las pruebas automáticas de integración continua. Si piden cambios, los commits nuevos en la misma rama actualizan el PR. Una regla de protección puede exigir PR, al menos una aprobación y CI en verde antes de unir. Los PRs chicos se revisan mejor y se revierten más fácil. Con GitOps, desplegar y hacer rollback también son PRs.

Ejemplo. En Alba, un PR que cambia el timeout del gateway corre los 26 tests del gateway y espera la aprobación de otra persona antes de entrar a main.

Ver en el glosario →

Revisión de códigocode reviewQue otra persona lea un cambio antes de unirlo: si hace lo que dice, si se entiende, si tiene pruebas y si mete algo que no debe. Es la última mirada humana antes de que el código llegue a main, la rama principal.Más

Se revisa en el pull request. Lo que se busca: casos que rompen el cambio, claridad para quien lo lea después, pruebas que cubran lo que cambió, y cosas que no deben entrar (una contraseña, un archivo de pesos, una dependencia sin razón). En ML se agrega una pregunta: ¿cambia el preprocesamiento? Si cambia en un lado y no en el otro, aparece el training-serving skew. Lo que puede revisar una máquina (pruebas, estilo, secretos) lo revisa integración continua, y la persona se concentra en el diseño. Un archivo CODEOWNERS dice quién debe aprobar cada carpeta.

Ejemplo. Un PR de 50 líneas se revisa con calma en minutos; uno de 2,000 se aprueba sin leer de verdad.

Ver en el glosario →

.gitignore.gitignoreUn archivo con patrones de lo que Git debe hacer como que no existe: el entorno virtual, los archivos que Python genera, el archivo .env (ajustes, a veces con contraseñas), los pesos y los datos. Ignorar no saca lo que ya entró a un commit.Más

Cada línea es un patrón: .venv/ ignora una carpeta, *.pyc todo lo que termine así, .env un archivo. git check-ignore -v ruta dice qué línea ignora a un archivo. .gitignore solo actúa sobre archivos que Git todavía no sigue: si uno ya entró, hay que sacarlo con git rm --cached (lo quita del repositorio y lo deja en tu carpeta), y aun así sigue en los commits viejos. Por eso un secreto que llegó a un commit se da por filtrado. El lock file sí se versiona, porque con él se reconstruye el entorno.

Ejemplo. Con .venv/, __pycache__/, .env, pesos/ y datos/ en .gitignore, de siete archivos git status solo muestra dos: .gitignore y app.py.

Ver en el glosario →

TagtagUn nombre fijo para un commit, que no se mueve como una rama: v1.4.0 apunta siempre al mismo commit. Se usa para marcar versiones publicadas.Más

Con git tag -a v1.4.0 -m "mensaje" se crea un tag anotado, un objeto con autor, fecha y mensaje; sin -a, es solo el nombre. Los nombres suelen seguir la versión semántica: mayor, menor y parche. git push no sube los tags: se suben con git push origin v1.4.0. No hay que confundirlo con el tag de una imagen de contenedor, como classifier-gateway:3f9c2ab, que es otro nombre en otro sistema; en Alba ese tag de imagen es justo el hash corto del commit.

Ejemplo. git tag -a v1.4.0 sobre 1e53ceb, y después de dos commits más, git rev-parse --short=7 v1.4.0^{commit} sigue dando 1e53ceb.

Ver en el glosario →

Git LFSGit Large File StorageUna extensión de Git para archivos grandes: el repositorio guarda un puntero de texto con el hash SHA-256 y el tamaño del archivo, y el archivo de verdad vive en un servidor aparte.Más

Sin LFS, Git guarda cada versión completa de cada archivo y cada clone baja toda la historia: 24 versiones de unos pesos de 98 MB son ≈ 2.35 GB para siempre. Con LFS, el historial guarda 24 punteros de ≈ 130 bytes y cada clone baja solo la versión que pide; el servidor de LFS sí guarda las 24 versiones, y GitHub las cuenta contra una cuota (10 GiB de almacenamiento y 10 GiB de descargas al mes en el plan gratuito, con archivos de hasta 2 GB, en noviembre de 2026). Se activa con git lfs install y git lfs track "*.pt", que escribe la regla en .gitattributes. GitHub avisa con archivos de más de 50 MiB y rechaza los de más de 100 MiB sin LFS (según su documentación, en noviembre de 2026). En ML, los datos y los pesos suelen ir mejor en object storage, con su versión, y en Git solo la referencia: lo resuelven el versionado de datos y herramientas como DVC.

Ejemplo. El puntero de un archivo de 1 MiB son tres líneas: version, oid sha256:… y size 1048576, en total 132 bytes.

Ver en el glosario →

Desarrollo trunk-basedtrunk-based developmentUna forma de trabajar en equipo donde todos integran seguido a main, la rama principal, con ramas que viven horas o uno o dos días y pull requests (PRs) chicos, para que main siempre esté lista para publicarse.Más

Lo que no está terminado entra apagado detrás de una feature flag. Su alternativa clásica es gitflow (Vincent Driessen, 2010), con ramas largas: main, develop, feature/, release/ y hotfix/. Gitflow sirve para software que se publica por versiones numeradas; para un servicio que se despliega varias veces al día pesa, porque las ramas largas se separan y los merges grandes traen conflictos grandes. Trunk-based va de la mano de integración continua y del pull request con revisión.

Ejemplo. En Alba, un cambio al timeout vive en su rama unas horas, pasa la revisión y los tests en el PR y entra a main el mismo día.

Ver en el glosario →

MonorepomonorepoUn solo repositorio con varios proyectos, como el servidor de un modelo, su entrenamiento, el preprocesamiento compartido y la infraestructura. La alternativa es un repositorio por proyecto.Más

Su ventaja: un cambio que toca dos proyectos entra en un solo PR y un solo commit, y un commit describe todo el sistema. En ML eso evita el training-serving skew: el preprocesamiento de entrenamiento y de serving cambia junto. Su costo: el repositorio crece, CI tiene que correr solo lo que cambió y los permisos son más gruesos. Con varios repositorios, cada equipo decide solo, pero hay que anotar qué versión de cada uno va con cuál. Google guarda casi todo su código en un solo repositorio, con un sistema propio en lugar de Git.

Ejemplo. Si el preprocesamiento vive en el mismo repositorio que el gateway y el entrenamiento, un cambio de normalización entra a los dos con el mismo commit.

Ver en el glosario →

GitOpsGitOpsManejar un clúster (el grupo de máquinas donde corren los programas) con un repositorio de Git: el estado deseado (qué imagen, cuántas copias) vive en Git, y un programa como Argo CD o Flux compara el clúster con el repositorio y aplica la diferencia. Desplegar es juntar un PR y volver atrás es un git revert.Más

Los archivos del repositorio son los manifests de Kubernetes, el sistema de orquestación que presenta la lección «Kubernetes». Como todo pasa por Git, la historia del repositorio es la historia de producción: quién desplegó qué, cuándo y quién lo aprobó. Un cambio hecho a mano en el clúster deja a Git describiendo otra cosa (configuration drift), y con la sincronización automática más la autorreparación (self-heal, apagada por omisión) Argo CD lo revierte solo. El nombre lo puso Weaveworks en 2017; Argo CD y Flux son proyectos de la CNCF. El rollback a la versión de ayer es un revert, y la imagen de ayer ya existe: no se reconstruye.

Ejemplo. El repositorio de despliegue de Alba dice image: classifier-gateway:8d41e07 (con su digest); la versión truena, un git revert lo regresa a 3f9c2ab y Argo CD vuelve el clúster a la imagen de ayer.

Ver en el glosario →

14

Chequeo

Esencial

Check

Intenta responder en tu cabeza antes de abrir cada respuesta.

  1. 1¿Cuáles son los tres lugares de un cambio en un repositorio, y qué comando lo mueve de uno al siguiente?Ver respuesta

    El área de trabajo (lo que editas), el staging (lo que va en la próxima foto) y el historial (las fotos guardadas en .git). git add pasa del área de trabajo al staging, y git commit, del staging al historial.

  2. 2¿Por qué cambiar el mensaje de un commit viejo cambia el id de todos los que vienen después?Ver respuesta

    Porque el id de un commit es el SHA-1 de todo su contenido, y ese contenido incluye el id de su padre. Cambia el viejo, cambia su id; el siguiente guarda ese id nuevo y cambia también, y así hasta el último.

  3. 3¿Qué es una rama, y por qué crearla no ocupa espacio?Ver respuesta

    Un nombre que apunta a un commit y avanza con cada commit nuevo: un archivo de 41 bytes con el id. No copia archivos.

  4. 4¿Cuándo un merge es fast-forward y cuándo crea un commit de merge?Ver respuesta

    Fast-forward cuando la rama de destino no avanzó desde que saliste: solo se adelanta su etiqueta. Si avanzó, Git crea un commit nuevo con dos padres.

  5. 5¿Cuál es la regla de oro del rebase?Ver respuesta

    No reescribir commits que otros ya bajaron: rebase en tu rama antes de compartirla, nunca en main.

  6. 6¿Revert o reset para deshacer un error que ya está en main?Ver respuesta

    Revert: crea un commit nuevo que lo deshace, sin reescribir la historia, y se sube con un push normal. Reset es para tu trabajo local.

  7. 7¿Qué tres punteros guarda cada modelo registrado de Alba?Ver respuesta

    El snapshot de datos, el commit del código y el digest del contenedor de entrenamiento. Con ellos se sabe de dónde salió y se puede volver a entrenar.

Repasar los 16 conceptos de esta lección con tarjetas Sigue · 36Pruebas y CI/CDHerramientas del oficio ← 34 · PyTorch en lo que toca a producción