Proyecto integrador · Canchas Bogotá

Cuatro rutas
para el mismo repositorio.

Trabajes en tu portátil, en un equipo de la sala o directamente en el navegador, aquí está el paso a paso. Todos los comandos se copian con un clic.

Cómo leer los puntos de colores

En los procedimientos, cada paso lleva un punto que indica cómo debería estar el pipeline en ese momento: verde si la arquitectura se respeta, rojo si está violada, azul si todavía no aplica. Si tu punto no coincide con el de la guía, algo se desvió.

Módulo 1

En tu máquina, con VS Code y Git Bash

El recorrido completo: traer el repositorio, romperlo a propósito, ver el pipeline rechazarlo y devolverlo al estado bueno.

Lo que necesitas instalado

VS Code es solo un editor: no trae Git ni Node incluidos. Antes de empezar, comprueba qué tienes. Abre la terminal de VS Code con Ctrl + Ñ y en el desplegable de la derecha elige Git Bash.

Git Bash · comprobar
# ¿Está Git?
git --version

# ¿Está Node? (opcional, ver más abajo)
node --version
Si responde…Qué significaQué hacer
git version 2.xGit está listoNada, sigue
command not foundNo está instaladoDescárgalo de git-scm.com
v20.x o superiorNode está listoPodrás verificar la arquitectura sin subir nada
Node no apareceNo está instaladoOpcional: nodejs.org, versión LTS
El detalle que hace perder tiempo

Después de instalar cualquiera de los dos, cierra VS Code y vuélvelo a abrir. Windows solo actualiza la lista de programas disponibles en las ventanas nuevas: si dejas la terminal abierta, va a seguir diciendo que el comando no existe.

Traer el repositorio a tu computador

Clonar es descargar el repositorio con todo su historial. En GitHub, botón verde Code → pestaña HTTPS → copiar la dirección.

Git Bash · clonar y abrir
# Ubícate donde quieras guardarlo
cd ~/Documents

# Cambia TU-USUARIO por el tuyo
git clone https://github.com/TU-USUARIO/canchas-bogota.git

cd canchas-bogota
code .

El ciclo completo: verde, rojo, verde

Este es el recorrido que demuestra para qué sirve el pipeline. Cinco pasos.

Pipeline en verde
1 · Comprueba el estado sano

Antes de tocar nada, confirma que la arquitectura está bien. Este es exactamente el mismo verificador que corre en GitHub.

Git Bash
node tools/verificar-arquitectura.js

Debe imprimir los tres [OK] y ARQUITECTURA RESPETADA.

Vas a romperlo
2 · Agrega una línea que viola la regla R2

Abre src/pagos/pagos.js en VS Code. Busca esta línea:

Búscala · no la borres
import { publicar } from '../nucleo/eventos.js';

Y justo debajo pega esta otra. Es una sola línea:

Agrégala debajo
import { enviarCorreo } from '../notificaciones/notificaciones.js';

Guarda con Ctrl + S.

Por qué esta línea

Es la solución que cualquiera escribiría si le piden «cuando se apruebe un pago, manda el correo». Funciona. Y es justo lo que la arquitectura no quiere: si el correo se cae, el cobro se cae con él.

Pipeline en rojo
3 · Míralo fallar sin subir nada

Aquí está la ventaja de tener Node: ves el error en dos segundos, sin esperar a GitHub.

Git Bash
node tools/verificar-arquitectura.js
Lo que vas a leer
[X] R2 VIOLADA  (ADR-002)
    Archivo: src/pagos/pagos.js
    "pagos" esta importando a "notificaciones", y no puede.
    Por que existe esta regla: Si el envio de correos falla,
    el cobro NO se puede caer.

Si quieres ver el número que hace fallar el pipeline:

Git Bash · el código de salida
node tools/verificar-arquitectura.js > /dev/null
echo $?

Debe dar 1. Cuando la arquitectura está bien, da 0.

Cuidado con las tuberías

Si escribes node ... | tail, el echo $? te devuelve el resultado de tail, no el de node, y siempre va a decir 0. Por eso se manda a /dev/null.

Rojo en GitHub
4 · Súbelo y míralo fallar de verdad
Git Bash
git add .
git commit -m "agrego envio de correo al aprobar el pago"
git push

Ve a tu repositorio en GitHub, pestaña Actions. En menos de un minuto aparece una X roja en el trabajo 1. Verificar la arquitectura, y el trabajo 2. Desplegar queda en gris: nunca llegó a correr.

De vuelta en verde
5 · Devuélvelo al estado bueno

Tienes tres formas, según dónde estés. Si ya hiciste push, usa la primera.

Ya subiste el cambio → revierte

Git Bash · lo recomendado
git revert --no-edit HEAD
git push

Crea un commit nuevo que deshace el anterior. El historial conserva ambos, que es justo lo que se quiere en un equipo: queda constancia de que se intentó y se revirtió.

Ojo

git revert no acepta la opción -q. Si la pones, falla con un mensaje de uso.

Hiciste commit pero no push → borra la línea y vuelve a commitear

Git Bash
# después de borrar la línea en VS Code
git add .
git commit -m "reverso: pagos avisa por evento segun ADR-002"
git push

Ni siquiera hiciste commit → descarta

Git Bash
git checkout -- src/pagos/pagos.js

Con cualquiera de las tres, node tools/verificar-arquitectura.js vuelve a dar 0 y el pipeline despliega.

Lo que acabas de comprobar

El correo nunca dejó de enviarse. La línea publicar('pago.aprobado', ...) siempre estuvo ahí: pagos anuncia que hubo un pago y notificaciones, que está suscrito, manda el correo.

La diferencia es quién depende de quién. Si pagos llama a notificaciones, un correo caído tumba el cobro. Si pagos anuncia, el cobro ya ocurrió y solo se pierde el aviso. Eso es el patrón Observer, y esta es la razón por la que existe.

Por qué conviene tener Node (y por qué no es obligatorio)

El verificador de arquitectura está escrito en JavaScript y se ejecuta con Node. Pero quien lo corre de verdad es GitHub, no tu computador: el pipeline trae este paso, que instala Node en la máquina virtual de GitHub cada vez que corre.

.github/workflows/pipeline.yml
- name: Preparar Node
  uses: actions/setup-node@v4
Sin Node en tu equipo

Funciona todo igual. Editas, subes, y esperas alrededor de un minuto a que GitHub te diga si pasó.

Con Node en tu equipo

Lo mismo, pero además puedes verificar en dos segundos antes de subir. Es comodidad, no un requisito.

Módulo 2

Los comandos de Git

Referencia para consultar. No hay que memorizarlos: hay que saber cuál buscar.

Crear un repositorio, o traer uno ajeno

Convertir una carpeta tuya en repositorio

Git Bash · desde cero
cd mi-proyecto
git init                       # crea el repositorio local
git add .                      # prepara todos los archivos
git commit -m "version inicial"

# conectarlo con uno vacío que creaste en GitHub
git remote add origin https://github.com/TU-USUARIO/mi-proyecto.git
git branch -M main
git push -u origin main
Qué hace cada pieza

remote add origin le dice a tu repositorio local dónde vive su copia en internet. «origin» es solo un apodo, el nombre por convención. -u deja esa conexión guardada, para que después baste con escribir git push.

Traer el repositorio de otra persona

Git Bash · clonar
git clone https://github.com/USUARIO/REPOSITORIO.git
cd REPOSITORIO

Clonar trae todo el historial, no solo los archivos actuales. Puedes ver cualquier versión anterior sin conexión.

Clonar no es lo mismo que hacer fork

Fork hace una copia en tu cuenta de GitHub: pasa a ser tuya y puedes subirle cambios. Clone baja una copia a tu computador. Si clonas el repositorio de otra persona sin hacer fork, no vas a poder hacer push: no tienes permiso. El orden correcto es fork primero, clone después.

El ciclo diario

Git tiene tres lugares, y cada comando mueve tu trabajo de uno al siguiente.

LugarQué contieneComando para avanzar
Tu carpetaLos archivos que estás editandogit add
Área de preparaciónLo que va a entrar en la próxima fotogit commit
Repositorio localEl historial, en tu máquinagit push
GitHubEl historial compartido—
Git Bash · el ciclo de siempre
git status                     # qué cambió
git add .                      # preparo TODO lo cambiado
git add src/pagos/pagos.js     # o solo un archivo
git commit -m "mensaje que explica el porqué"
git push                       # lo subo a GitHub
git pull                       # bajo lo que subieron otros
El error de principiante número uno

Creer que commit ya subió el código. No. Hasta que no hagas push, tu trabajo vive solo en tu computador y nadie más lo ve.

Cómo se escribe un buen mensaje de commit

No sirve

cambios
arreglos
update
asdf

Sí sirve

separo catalogo de pagos segun ADR-001
agrego regla R4 para reservas

El mensaje responde por qué, no qué. El «qué» ya se ve en el código; el «por qué» se pierde para siempre si nadie lo escribe.

Mirar sin cambiar nada

Estos tres comandos no modifican nada. Puedes usarlos sin miedo, siempre.

Git Bash · observar
git status                     # qué cambió y qué está preparado
git log --oneline              # historial, una línea por commit
git log --oneline --graph      # igual, dibujando las ramas
git diff                       # qué cambió, línea por línea
git diff --stat                # resumen: qué archivos y cuántas líneas
git show HEAD                  # qué trajo el último commit
Qué es HEAD

Es dónde estás parado ahora en el historial: casi siempre, el último commit de tu rama. HEAD~1 es el commit anterior, HEAD~2 el de más atrás, y así.

Por qué git log parece no mostrarlo todo

Es la queja más común, y casi siempre son dos causas distintas que se confunden entre sí.

Causa 1 · --oneline solo muestra la primera línea

Un mensaje de commit puede tener título y cuerpo. --oneline muestra el código y únicamente el título; todo el cuerpo queda oculto. No se perdió: no se está pidiendo.

git log --oneline

1ccf1bd tercer commit con titulo

Solo el título. El cuerpo no aparece.

git log

Muestra autor, fecha, título y todo el cuerpo del mensaje.

git log · lo que sí muestra el cuerpo
commit 1ccf1bd16f101c6fd3538c92613aa409be6216b8
Author: Elkin <correo@utadeo.edu.co>
Date:   Sun Aug 30 18:54:27 2026

    tercer commit con titulo

    Y aqui va una descripcion mas larga
    que ocupa varias lineas del cuerpo.

Causa 2 · el visor se traga la pantalla

git log no imprime y termina: abre un visor que muestra una pantalla a la vez. Si el historial es largo, ves solo el principio y parece que ahí se acabó.

TeclaQué hace
Barra espaciadoraAvanza una pantalla
Flechas ↑ ↓Avanza o retrocede una línea
qSalir. Si quedaste atrapado, esta es la tecla
/palabraBuscar dentro del historial
Si prefieres que no abra el visor

Con --no-pager imprime todo de corrido en la terminal, como cualquier otro comando.

Git Bash · sin visor
git --no-pager log
git --no-pager log --oneline

Las formas de ver el historial, según lo que necesites

Git Bash · variantes útiles
git log                        # completo: autor, fecha y mensaje entero
git log --oneline              # compacto: código + título
git log -5                     # solo los últimos 5
git log --stat                 # + qué archivos cambió cada uno
git log -p                     # + el cambio línea por línea
git log --graph --oneline --all # dibuja las ramas

git show 1ccf1bd               # TODO el detalle de UN commit
Para ver un commit viejo completo

Saca el código con git log --oneline y pásaselo a git show. Te da el mensaje entero, el autor, la fecha y todo lo que cambió ese commit.

La tercera posibilidad: el mensaje sí es corto

Revisa esto antes de seguir buscando

Si hiciste el commit con git commit -m "cambios", ese es todo el mensaje: no hay cuerpo escondido. Para escribir título y cuerpo:

Git Bash · título y cuerpo
# dos veces -m: el primero es el título, el segundo el cuerpo
git commit -m "agrego regla R4 para reservas" -m "Protege el aviso de reserva segun ADR-004. Descartamos la llamada directa porque acopla la reserva al correo."

Ramas y cómo se unen

Una rama es una línea de trabajo paralela. Te llevas una copia, trabajas tranquilo, y cuando está lista la juntas con la principal.

Git Bash · trabajar con ramas
git branch                       # ¿qué ramas hay? la actual va con *
git branch regla-r4              # crear una
git switch regla-r4              # cambiarme a ella
git switch -c regla-r4           # crear Y cambiarme, en un paso

git switch main                  # volver a la principal
git push -u origin regla-r4      # subir la rama la primera vez
switch o checkout

Antes todo se hacía con git checkout, que servía para demasiadas cosas distintas y confundía. Git lo partió en dos: git switch para cambiar de rama y git restore para descartar cambios. checkout sigue funcionando, pero los nuevos son más claros.

Unir dos ramas

Regla de oro: te paras en la rama que va a recibir, y desde ahí traes la otra.

Git Bash · fusionar
git switch main                # me paro en la que recibe
git merge regla-r4             # traigo el trabajo de la otra
git push

git branch -d regla-r4         # borro la rama ya fusionada

Si aparece un conflicto

Un conflicto ocurre cuando dos personas cambiaron la misma línea. Git no adivina cuál vale: se detiene y te pregunta. No es que se haya dañado nada.

Así se ve dentro del archivo
<<<<<<< HEAD
const precio = 90000;          // lo que había en tu rama
=======
const precio = 95000;          // lo que trae la otra rama
>>>>>>> regla-r4

Para resolverlo: abre el archivo, borra las tres líneas de marcas (<<<, ===, >>>), deja el código como debe quedar, y después:

Git Bash · cerrar el conflicto
git add .
git commit                     # Git propone el mensaje solo

# ¿te arrepentiste a mitad? cancela toda la fusión:
git merge --abort
VS Code te ayuda aquí

Cuando hay conflicto, VS Code muestra botones sobre el bloque: Accept Current, Accept Incoming y Accept Both. Un clic y limpia las marcas por ti.

Volver atrás en el tiempo: las cinco formas

Esta es la parte que más miedo da y donde más gente se enreda. La pregunta que decide todo es una: ¿ya hiciste push?

Quiero…Comando¿Reescribe el historial?
Descartar cambios sin commitgit restore ARCHIVONo
Sacar algo del área de preparacióngit restore --staged ARCHIVONo
Deshacer un commit ya subidogit revert HASHNo · el recomendado
Deshacer commits no subidosgit reset HASHSí
Solo mirar cómo estaba antesgit checkout HASHNo

1 · Descartar lo que aún no has confirmado

Git Bash
git restore src/pagos/pagos.js     # un archivo
git restore .                       # todo lo modificado
git checkout -- src/pagos/pagos.js  # la forma antigua, igual de válida
Esto no se puede deshacer

Los cambios descartados no están en ningún historial, porque nunca hubo commit. Se pierden de verdad.

2 · Sacar un archivo de la preparación

Hiciste git add de algo que no querías incluir. El archivo conserva tus cambios: solo sale de la lista del próximo commit.

Git Bash
git restore --staged src/pagos/pagos.js

3 · Revertir un commit · el recomendado

Es la forma segura, y la única correcta si ya hiciste push. No borra nada: crea un commit nuevo que deshace lo que hizo el anterior.

Git Bash
git revert --no-edit HEAD          # deshace el último
git revert --no-edit a1b2c3d       # deshace uno específico
git push
Por qué es el recomendado

El historial conserva los dos commits: el que introdujo el problema y el que lo revirtió. En un equipo eso es exactamente lo que se quiere — queda constancia de que se intentó algo y se deshizo, y nadie más tiene que arreglar su copia.

4 · Reset · potente y peligroso

reset reescribe el historial: mueve tu rama hacia atrás como si los commits nunca hubieran existido. Tiene tres modos que solo se diferencian en qué pasa con tu trabajo.

ModoLos commitsTus cambios
--softDesaparecenQuedan preparados, listos para commitear
--mixed (por defecto)DesaparecenQuedan en los archivos, sin preparar
--hardDesaparecenSe borran. No hay vuelta atrás

Y hay dos formas de decirle hasta dónde retroceder. Se confunden mucho y significan cosas distintas.

Git Bash · contando hacia atrás
git reset --soft HEAD~1        # deshago el ÚLTIMO commit, conservo el trabajo
git reset HEAD~1               # igual, pero sin preparar
git reset --hard HEAD~1        # deshago el último Y borro el trabajo
Git Bash · apuntando a un commit del log
git log --oneline              # copio el código, por ejemplo c0b400d

git reset --soft c0b400d       # vuelvo a ESE commit, trabajo preparado
git reset --hard c0b400d       # vuelvo a ESE commit y borro lo demás
La diferencia que hay que tener clara

Con HEAD~1 dices «retrocede uno»: el último commit desaparece.

Con un código del log dices «párate ahí»: ese commit se conserva y desaparece todo lo que vino después. Si apuntas al último commit del log, no pasa nada — ya estás ahí.

Qué se siente en cada modo

Partiendo de un historial con tres commits y haciendo reset al segundo:

Antes · git log --oneline
1ccf1bd tercer commit
c0b400d segundo commit      <-- voy a apuntar aquí
3ea6e19 primer commit
git reset --soft c0b400d
c0b400d segundo commit
3ea6e19 primer commit

$ git status
A  c.txt          # el archivo sigue ahí y YA PREPARADO
git reset --hard c0b400d
c0b400d segundo commit
3ea6e19 primer commit

$ ls
a.txt  b.txt      # c.txt desapareció del disco
Cuándo sirve cada uno

--soft — «el commit estaba mal armado, pero el trabajo sirve». Típico: hiciste tres commits pequeños y quieres unirlos en uno solo, o pusiste un mensaje malo. Retrocedes, y vuelves a commitear bien.

--hard — «esto no sirve, bórralo». Es el único de los tres que destruye trabajo. Úsalo solo cuando estés seguro.

Nunca hagas reset de algo que ya subiste

Si ya hiciste push y luego haces reset, tu historial y el de GitHub quedan en desacuerdo. Para arreglarlo tocaría forzar el push, y eso le rompe la copia a todos tus compañeros. Si ya subiste, usa revert.

5 · Mirar una versión anterior sin cambiar nada

Git Bash · viajar y volver
git log --oneline              # copio el código del commit
git checkout a1b2c3d           # me paro ahí a mirar

git switch -                   # vuelvo a donde estaba
Vas a ver un mensaje raro

Git avisa «You are in 'detached HEAD' state». No es un error: significa que estás parado en un commit suelto, fuera de cualquier rama. Mira lo que necesites y vuelve con git switch -. Si haces commits estando ahí, se pierden al salir.

El salvavidas: reflog

Si hiciste un reset y crees que perdiste trabajo, hay una última carta. Git guarda un registro de todos los lugares donde estuviste, incluso los que ya no aparecen en el historial.

Git Bash · el último recurso
git reflog                     # todo por donde pasó HEAD
git reset --hard 1ccf1bd       # vuelvo a ese punto
Así se ve el reflog · el commit «perdido» sigue ahí
c0b400d HEAD@{0}: reset: moving to c0b400d
1ccf1bd HEAD@{1}: commit: tercer commit   # <-- este creía perdido
c0b400d HEAD@{2}: commit: segundo commit
Probado

Después de un --hard que borró un archivo del disco, este rescate lo devuelve completo. Git conserva el reflog unos 30 días, así que hay margen — pero no es eterno.

Tabla de referencia

ComandoQué hace
git clone URLBaja un repositorio con todo su historial
git statusQué cambió y qué está preparado
git add .Prepara todo lo modificado
git commit -m "…"Guarda una foto con su explicación
git pushSube tus commits a GitHub
git pullBaja lo que subieron otros
git log --onelineEl historial resumido
git diffQué cambió, línea por línea
git switch -c NOMBRECrea una rama y se cambia a ella
git merge NOMBRETrae esa rama a la actual
git restore ARCHIVODescarta cambios sin confirmar
git revert HASHDeshace un commit dejando constancia
git show HASHTodo el detalle de un commit concreto
git --no-pager logEl historial sin abrir el visor
git reflogTodo por donde pasaste, para recuperar
Módulo 3

Equipos compartidos de la universidad

Cómo trabajar con tu propia cuenta en una máquina donde ya hay otra persona registrada. Sin permisos de administrador.

La respuesta corta: sí se puede

Todo lo de este módulo funciona sin permisos de administrador. Ni la identidad de Git ni las credenciales guardadas necesitan instalar nada: viven en el perfil del usuario de Windows, y ahí sí puedes escribir.

Qué pasa en un equipo de la sala

Git y VS Code están instalados, pero alguien los usó antes que tú. Eso deja dos rastros distintos, y conviene no confundirlos porque se arreglan por caminos separados.

RastroQué esDónde viveSíntoma
IdentidadEl nombre y correo que firman cada commitArchivo .gitconfigTus commits salen a nombre de otra persona
CredencialesEl permiso guardado para subir a GitHubAdministrador de credenciales de WindowsAl hacer push te rechaza, o sube a la cuenta ajena

Primero: averigua quién está registrado

Git Bash · diagnóstico
git config --global user.name
git config --global user.email

# ver toda la configuración y de qué archivo sale
git config --list --show-origin

Si aparece el nombre de otra persona, es lo esperado en una máquina compartida. No hay que borrar nada suyo: basta con poner lo tuyo por encima.

Poner tu identidad

Git lee la configuración en capas, y gana la más cercana al proyecto. Eso es justo lo que necesitas en un equipo compartido.

NivelDónde aplicaEn una sala de cómputo
--systemTodo el equipoNecesita administrador. Olvídalo
--globalTu usuario de WindowsFunciona, pero se lo dejas al siguiente
--localSolo ese repositorioLo recomendado. No afecta a nadie más
Git Bash · dentro de la carpeta del proyecto
cd canchas-bogota

git config --local user.name "Tu Nombre"
git config --local user.email "tucorreo@utadeo.edu.co"

# comprobar que quedó
git config --local --list
Por qué local y no global

La configuración local se guarda dentro de la carpeta del proyecto, en .git/config. Cuando termines la clase y borres la carpeta, se va con ella. No dejas rastro y no le cambias nada al que use el equipo mañana.

Usa el correo que GitHub reconoce

Escribe el mismo correo que tienes registrado en tu cuenta de GitHub. Si pones otro, los commits funcionan pero GitHub no los asocia a tu perfil y aparecen sin tu foto ni tu nombre de usuario. Para el proyecto eso importa: es la evidencia de quién hizo qué.

Cambiar la cuenta de GitHub

Esta es la parte que de verdad se atasca. Windows guarda el permiso de acceso a GitHub en un solo lugar, y por defecto solo guarda una cuenta. Si tu compañero de la mañana dejó la suya, tu push va a ir a nombre de él o va a ser rechazado.

Paso 1 · Borra la credencial guardada

Es la vía más confiable y no necesita administrador.

Menú Inicio → «Administrador de credenciales» Pestaña Credenciales de Windows → busca en la lista una entrada llamada git:https://github.com → clic para desplegarla → Quitar.
Si el equipo está en inglés

Busca Credential Manager → pestaña Windows Credentials → entrada git:https://github.com → Remove.

También se puede desde la terminal, aunque el camino visual falla menos:

Git Bash · alternativa
printf "protocol=https\nhost=github.com\n\n" | git credential-manager erase

Paso 2 · Vuelve a entrar con tu cuenta

Con la credencial borrada, el siguiente comando que necesite permiso va a pedir que te identifiques.

Git Bash · dispara la autenticación
git push

Se abre una ventana con la opción Sign in with your browser. Dale, entra con tu usuario de GitHub, autoriza, y listo. Windows guarda tu credencial y el push continúa solo.

Si no se abre la ventana

Puede que el equipo tenga Git muy viejo. En ese caso te va a pedir usuario y contraseña en la terminal — pero GitHub ya no acepta contraseñas para esto. Hay que generar un token: en GitHub, Settings → Developer settings → Personal access tokens → Tokens (classic) → Generate new token, marca los permisos repo y workflow, y usa ese token en lugar de la contraseña.

Limpiar al terminar · hazlo siempre

No dejes tu cuenta abierta en un equipo público

Si te vas sin limpiar, el siguiente estudiante puede subir código a tu nombre, en tus repositorios. Son treinta segundos.

  1. Borra tu credencial: Administrador de credenciales → Credenciales de Windows → git:https://github.com → Quitar.
  2. Borra la carpeta del proyecto. Con ella se va tu configuración local, porque vivía en .git/config.
  3. Cierra la sesión de GitHub en el navegador, si entraste.
Si además usaste --global

Si en algún momento configuraste tu identidad global en vez de local, deshazlo también:

Git Bash · solo si usaste --global
git config --global --unset user.name
git config --global --unset user.email
La ruta que evita todo esto

Si el equipo se resiste o andas con afán, trabaja desde el navegador: el Módulo 4 hace exactamente lo mismo sin instalar ni configurar nada. Se edita con el lápiz de GitHub y el pipeline verifica igual. La única diferencia es que esperas un minuto en vez de dos segundos.

Módulo 4

Desde GitHub, sin instalar nada

Todo el trabajo del proyecto se puede hacer en el navegador. Esta es la ruta del taller de clase.

Paso 1 · Haz el fork

Un fork es una copia completa del repositorio del curso que queda en tu cuenta, con todo el historial. Desde ese momento es tuyo: puedes cambiar lo que quieras sin afectar el original.

Repositorio del curso → botón «Fork» (arriba a la derecha) Deja el nombre como está y presiona Create fork. En unos segundos la copia aparece en tu cuenta.
No necesitas que el profesor te dé permisos

El fork lo haces tú y queda bajo tu nombre. Así funciona todo el software libre del mundo: nadie pide permiso para copiar, solo para que le acepten cambios de vuelta.

Que quede público

El repositorio debe ser público. GitHub Pages y Actions son gratis e ilimitados en repositorios públicos; en privados hay tope y con cuenta gratuita Pages ni siquiera está disponible.

Paso 2 · Enciende el pipeline y Pages

Son dos clics, pero están escondidos. Aquí es donde se atasca casi todo el mundo.

Todavía no corre nada
Habilita los flujos de trabajo

Por seguridad, GitHub desactiva los pipelines en los forks.

Tu repositorio → pestaña «Actions» Aparece un aviso amarillo diciendo que los workflows están deshabilitados. Presiona el botón verde para habilitarlos. Si no lo haces, no corre nada y no vas a entender por qué.
Falta el destino
Enciende GitHub Pages
Settings → Pages → Build and deployment → Source Elige GitHub Actions.
No elijas «Deploy from a branch»

Es la opción antigua y se salta el pipeline: publicaría el sitio, pero sin pasar por la verificación de arquitectura. Se perdería el punto entero del proyecto.

Pipeline en verde
Espera y anota tu dirección

Vuelve a Actions. En un minuto el flujo termina en verde. Tu URL aparece arriba, en Settings → Pages, con esta forma:

Tu sitio, en internet
https://TU-USUARIO.github.io/canchas-bogota/

Anótala: es parte de la entrega. Ábrela en el celular para comprobar que funciona.

Paso 3 · Rompe la arquitectura a propósito

El negocio pide algo razonable: «cuando se apruebe un pago, manda el correo de confirmación». La solución obvia es que pagos llame a notificaciones. Vamos a hacerlo y ver qué pasa.

Tu repositorio → src → pagos → pagos.js → icono del lápiz Busca la línea import { publicar } … y justo debajo pega la línea de abajo.
Agrega esta línea · una sola
import { enviarCorreo } from '../notificaciones/notificaciones.js';

Abajo, en el mensaje del commit, escribe algo real y presiona Commit changes:

Mensaje del commit
agrego envio de correo al aprobar el pago
Editar desde la web hace commit y push a la vez

Por eso no necesitas instalar Git para el taller. El lápiz de GitHub guarda el cambio y lo sube en un solo paso.

Pipeline en rojo
Ve a Actions y lee el error completo

En menos de un minuto aparece la X roja. Entra al flujo, clic en 1. Verificar la arquitectura, y despliega el paso de la función de aptitud.

Lo que dice el pipeline
[X] R2 VIOLADA  (ADR-002)
    Archivo: src/pagos/pagos.js
    "pagos" esta importando a "notificaciones", y no puede.
    Por que existe esta regla: Si el envio de correos falla,
    el cobro NO se puede caer.

ARQUITECTURA VIOLADA: 1 problema(s). El despliegue se detiene.

Fíjate también en que el trabajo 2. Desplegar quedó en gris: nunca corrió. Tu cambio no llegó a producción.

Lee la tercera línea otra vez

No dice «error». Dice por qué existe esa regla. Una regla que no explica su motivo es una imposición; una que lo explica es una decisión que se puede discutir.

Paso 4 · Arréglalo bien

La tentación que hay que resistir

Lo fácil sería borrar la regla de arquitectura/reglas.json para que el pipeline pase. Eso no resuelve el problema: lo esconde. El reto es resolverlo sin violar la regla.

Vuelve al lápiz en src/pagos/pagos.js y borra la línea que agregaste. El archivo debe quedar exactamente así:

src/pagos/pagos.js · versión correcta
// PAGOS · cobra. NO importa notificaciones (regla R2):
// si el envio de correos falla, el cobro no se puede caer.
// Por eso avisa publicando un evento, no llamando a nadie.
import { publicar } from '../nucleo/eventos.js';

export function cobrar(reserva) {
  const referencia = 'PG-' + Math.random().toString(36).slice(2, 8).toUpperCase();
  publicar('pago.aprobado', Object.assign({}, reserva, { referencia: referencia }));
  return { ok: true, referencia: referencia, valor: reserva.valor };
}
Mensaje del commit
reverso: pagos avisa por evento segun ADR-002
Y aquí está el punto de todo esto

Mira la línea resaltada en verde. Siempre estuvo ahí. El correo sí se envía: pagos anuncia que hubo un pago aprobado, y notificaciones, que está suscrita a ese anuncio, lo manda.

La diferencia es quién depende de quién. Si pagos llama a notificaciones y el servidor de correo se cae, la llamada falla y el cobro se cae con ella: el cliente no pudo pagar porque el correo estaba malo. Si pagos anuncia y sigue, el cobro ya ocurrió y solo se perdió el aviso.

Eso es el patrón Observer. No es elegancia: es que el cobro no dependa del correo.

Compruébalo tú mismo: abre tu URL desplegada, haz una reserva, y mira la sección Notificaciones recibidas. El mensaje aparece — y llegó por el evento.

Cuando algo falla

Lo primero siempre es la misma pregunta: ¿cuál de los dos trabajos falló? La respuesta cambia por completo qué hay que arreglar.

El trabajo que fallaQué significaQué hacer
1 · Verificar la arquitecturaViolaste una reglaLee el log: dice cuál, dónde y por qué existe
2 · Desplegar a PagesLa arquitectura está bien. Es configuraciónCasi siempre: Pages sin encender

Error: Get Pages site failed … Not Found

GitHub Pages no se enciende solo. El pipeline intentó publicar en un sitio que todavía no existe.

Settings → Pages → Source: GitHub Actions Y después: Actions → entra al flujo que falló → Re-run all jobs.

El pipeline no arranca

Los flujos siguen deshabilitados. Pestaña Actions → botón verde del aviso amarillo.

Aviso: Node 20 is being deprecated

Es una advertencia, no un error. GitHub ya ejecuta las acciones en una versión más nueva por su cuenta. Ignóralo.

La URL abre en blanco

Espera un minuto y recarga con Ctrl + F5. La primera publicación tarda un poco en propagarse.

Saber leer un fallo es la habilidad, no un trámite

Distinguir en qué paso se rompió un pipeline es lo primero que hace alguien con experiencia. El mensaje casi siempre dice qué pasó — el problema es que nadie lo lee.