Parcial de práctica — Arquitectura de Software
Temas: partes 1 y 2 del curso (semanas 1 a 7) · Duración sugerida: 2 horas
Este es un examen de práctica con el formato del parcial. Sirve para medir
cuánto tiempo les toma cada tipo de pregunta: resuélvanlo en papel, con el
reloj corriendo, antes de mirar ninguna solución. Las soluciones las da el
docente en clase. El formato general y cómo estudiar están en
exams/README.md.
Cómo aprovecharlo
- Lean el caso completo antes de empezar. Todas las preguntas son sobre él, y una respuesta que serviría para cualquier sistema no responde la pregunta.
- En toda respuesta que pide una decisión se espera lo mismo que en el proyecto: el escenario que la motiva, al menos una alternativa y qué se sacrifica.
- Muestren las cuentas. Los percentiles se calculan por rango más cercano, como en el curso: con mediciones ordenadas, el percentil es la que ocupa la posición . Para la disponibilidad, un mes tiene 30 días (43 200 minutos).
- En TypeScript y en las reglas de dependency-cruiser importa la idea: no hace falta recordar cada opción.
| Pregunta | Tema | Semanas | Tiempo sugerido |
|---|---|---|---|
| Leer el caso | 5 min | ||
| 1 | Requisitos, restricciones y decisiones | 1 | 12 min |
| 2 | Escenarios, percentiles, disponibilidad y utility tree | 2 | 28 min |
| 3 | Módulos, ciclos y reglas de dependencia | 3 | 20 min |
| 4 | Dos estilos para Yaku | 4 y 5 | 16 min |
| 5 | Tácticas y sus trade-offs | 6 | 17 min |
| 6 | Un ADR y un recorrido del diseño | 7 | 22 min |
| Total | 120 min |
El caso: Yaku
Yaku quiere decir agua en quechua. Aquí es el sistema comercial de la empresa de agua potable de una ciudad de la sierra, con 180 000 suministros (un suministro es una conexión con su medidor). No existe: lo inventamos para este examen.
Hoy Yaku es un monolito en TypeScript sobre Node.js, con una base de datos PostgreSQL, desplegado como un solo proceso. Lo que hace:
- Lecturas. Una vez al mes, un lecturista registra la lectura de cada medidor desde una aplicación en su celular.
- Facturación. La ciudad está dividida en cuatro ciclos de 45 000 suministros, y cada semana se factura uno. La corrida de facturación calcula el consumo de cada suministro, le aplica la tarifa, le suma la deuda anterior y emite el recibo. Hoy la lanza una persona a las 9 a. m., corre dentro del mismo proceso que atiende la API y tarda unas cinco horas.
- Cobranza. Los recibos se pagan en bancos y agentes a través de una
red de recaudación, una empresa externa: la red consulta la deuda del
suministro (
GET /debts/:supplyCode) y después notifica el pago (POST /payments). También se paga en las ventanillas de la empresa, donde un cajero usa Yaku desde el navegador. - Comprobantes. Por cada pago se emite un comprobante electrónico con un proveedor externo. Hoy la emisión ocurre dentro del mismo pedido que registra el pago: si el proveedor no responde, el pago falla.
- Cortes. Cuando un suministro acumula dos recibos vencidos, se genera una orden de corte. Cuando paga, se genera la orden de reconexión y se le avisa al titular por mensaje de texto, con un proveedor de SMS.
- Portal. El titular de un suministro ve y descarga sus recibos desde una página web.
De las reuniones con la empresa salió esta lista, tal como la dijeron:
- El lecturista registra la lectura de cada medidor, con una foto, desde su celular.
- El recibo muestra en un gráfico el consumo de los últimos doce meses.
- El día en que vence un ciclo, a las 6 p. m., la red de recaudación concilia sus cobros: durante 10 minutos llegan unas 120 consultas de deuda por segundo. En un día normal son 8 por segundo.
- La estructura tarifaria (rangos de consumo, categorías, subsidios) la aprueba el regulador y cambia unas dos veces al año. Hoy cada cambio toma tres semanas y toca once archivos.
- El sistema debe ser moderno y confiable.
- La red de recaudación es la que la empresa ya contrató, y su protocolo no se cambia: espera 2 segundos cada respuesta y, si no llega, repite el pedido.
- Un pago notificado por la red no se puede perder ni aplicarse dos veces.
- Cuando un suministro acumula dos recibos vencidos, el sistema genera la orden de corte.
- El equipo son cuatro personas que conocen TypeScript y PostgreSQL; una de ellas, además, opera el sistema. La nube es la del contrato que la municipalidad ya firmó.
- Mientras corre la facturación de un ciclo, las ventanillas y la red de recaudación se quejan de que Yaku está lento.
Pregunta 1 — Requisitos, restricciones y decisiones
Semana 1 · 12 minutos
a) Clasifiquen cada enunciado de la lista como requisito funcional, requisito significativo para la arquitectura (ASR) o restricción, y justifiquen cada uno en una línea. Si alguno todavía no es un requisito, o esconde otro, díganlo.
b) Escriban las dos preguntas que le harían a la empresa antes de diseñar nada, y digan qué decisión de arquitectura depende de cada respuesta.
c) De estas cuatro decisiones que ya tiene Yaku, ¿cuáles son de arquitectura y cuáles no? Digan con qué criterio lo deciden y, para las que sí lo son, en qué tipo de estructura (de módulos, de componentes y conectores, de asignación) se ven.
- (i) La corrida de facturación se ejecuta dentro del mismo proceso que atiende la API.
- (ii) El recibo en PDF usa la tipografía que eligió el área de imagen de la empresa.
- (iii) El código de cortes lee con su propio SQL la tabla de recibos, que escribe el código de facturación.
- (iv) El comprobante electrónico se emite dentro del pedido que registra el pago.
Pregunta 2 — Escenarios, percentiles, disponibilidad y utility tree
Semana 2 · 28 minutos
La empresa aclaró dos cosas. Para la conciliación del enunciado 3 quiere que el p95 de la consulta de deuda sea menor que 400 ms, con menos de 0,5 % de errores, también cuando coincide con la corrida de facturación. Y quiere que pagar un recibo en un agente esté disponible al menos el 99,7 % del mes.
a) Escriban el escenario de la conciliación con sus seis partes; llámenlo E1. Después digan todo lo que está mal en este intento de un compañero para el enunciado 4, y reescríbanlo como E3:
Fuente: el regulador. Estímulo: cambia la tarifa. Artefacto: Yaku. Respuesta: el sistema se adapta rápidamente. Medida: lo antes posible.
b) Una prueba de carga con el tráfico de la conciliación, hecha mientras corría la facturación, midió 4 000 consultas de deuda:
| Consultas | Tiempo de respuesta |
|---|---|
| 3 400 | 45 ms |
| 360 | 180 ms |
| 200 | 750 ms |
| 40 | 4 000 ms |
Calculen el promedio, el p50, el p95 y el p99. ¿Se cumple E1? ¿Qué número le mostrarían a quien decide, y qué esconde cada uno de los que no le mostrarían?
c) La prueba corrió sobre dos instancias de la API. api-1 atendió 2 000
consultas: 1 900 de 45 ms y 100 de 180 ms. api-2 atendió las otras 2 000:
1 500 de 45 ms, 260 de 180 ms, 200 de 750 ms y 40 de 4 000 ms. El tablero de
monitoreo muestra “p95 del servicio” como el promedio de los p95 de las dos
instancias. ¿Qué número muestra, qué conclusión sacaría quien lo lea y por
qué está mal?
d) Con el diseño actual, pagar un recibo en un agente necesita que respondan la red de recaudación (99,9 % de disponibilidad), la API de Yaku (99,95 %), PostgreSQL (99,95 %) y el proveedor de comprobantes (99,0 %).
- Calculen la disponibilidad de pagar, y cuántos minutos al mes no se puede. ¿Se cumple lo que pidió la empresa?
- Calculen lo mismo para dos alternativas: (i) el comprobante se emite después de registrar el pago, fuera del pedido; (ii) el comprobante sigue dentro del pedido, pero se contrata un segundo proveedor, también de 99,0 %, y basta con que responda uno de los dos.
- ¿Cuál elegirían? Digan qué supone cada cuenta y qué se paga con cada alternativa.
e) Además de E1 y E3, el equipo escribió dos escenarios más:
- E2. La corrida de facturación de un ciclo de 45 000 suministros termina en 3 horas o menos.
- E4. El proveedor de comprobantes no responde durante 30 minutos en un día de vencimiento: los pagos se siguen registrando, se pierden 0 pagos y todos los comprobantes pendientes quedan emitidos 60 minutos después de que el proveedor vuelve, o antes.
La gerencia agregó: el contrato con la red de recaudación tiene una penalidad si la red no puede cobrar en un día de vencimiento; la fecha en que entra en vigor cada tarifa la fija el regulador, con multa si los recibos salen con la tarifa anterior; y que la corrida tarde cinco horas en vez de tres no lo nota nadie fuera de la empresa. Armen el utility tree con los cuatro escenarios (atributo, refinamiento, escenario y sus dos notas), justifiquen cada nota en una frase y digan qué escenario define la arquitectura.
Pregunta 3 — Módulos, ciclos y reglas de dependencia
Semana 3 · 20 minutos
El monolito tiene siete módulos, uno por carpeta de src/. Estas son sus
dependencias («a -> b» quiere decir que algún archivo de a importa algo de
b):
readings -> customers payments -> billing
billing -> readings payments -> cutoffs
billing -> tariffs cutoffs -> billing
billing -> customers cutoffs -> customers
billing -> payments cutoffs -> notifications
notifications -> customers
Por qué existen las flechas menos obvias: billing importa a payments para
poner en el recibo la deuda anterior del suministro; payments importa a
billing porque un pago se aplica a un recibo, y a cutoffs para pedir la
reconexión cuando el suministro se pone al día; cutoffs importa a billing
para contar los recibos vencidos.
a) Encuentren todos los ciclos. ¿Qué módulos quedan enredados, es decir, no se pueden probar ni separar unos sin otros?
b) ¿Alcanza con quitar una sola flecha para que no quede ningún ciclo? Si alcanza, digan cuál o cuáles sirven; si no, cuántas hacen falta.
c) Rompan los ciclos con una inversión de dependencias. Escriban la interfaz en TypeScript, y digan qué módulo la declara, cuál la implementa y quién los conecta. ¿Qué cambió de dirección y qué no? Nombren otra manera de romper el ciclo y digan por qué no la eligieron.
d) Escriban la regla de dependency-cruiser que impide que el ciclo vuelva
(basta con name, from y to). ¿Qué harían para confiar en que la regla
comprueba algo?
e) Este es un archivo de cutoffs:
// src/cutoffs/select.ts
import { pool } from '../shared/db.ts';
import { overdueSince } from '../billing/due-dates.ts';
export async function suppliesToCut(): Promise<number[]> {
const { rows } = await pool.query(
'SELECT supply_id FROM bills WHERE status = 2 AND due_date < $1 GROUP BY supply_id HAVING count(*) >= 2',
[overdueSince(new Date(), 0, true)],
);
return rows.map((row) => row.supply_id);
}
Encuentren tres formas de acoplamiento con el módulo billing y nómbrenlas.
Para cada una digan qué cambio en billing rompería este archivo, si una
regla de dependency-cruiser puede detectarla, y cómo la reducirían.
Pregunta 4 — Dos estilos para Yaku
Semanas 4 y 5 · 16 minutos
El equipo va a rediseñar Yaku. Hay dos propuestas sobre la mesa:
- A. Modular monolith con un worker. Un solo repositorio y una sola base de datos, con los siete módulos con interfaz pública y reglas de dependencia. Se despliega como dos procesos: la API y un worker que ejecuta la corrida de facturación como un pipeline.
- B. Microservicios. Un servicio por módulo, siete en total, cada uno con su base de datos, que se comunican por HTTP.
a) Comparen las dos propuestas contra E1, E2 y E3 (los de la pregunta 2). Para cada escenario y cada propuesta escriban una frase concreta: cómo lo cumple, o por qué no. Agreguen el costo de operar cada una con el equipo del enunciado 9.
b) Elijan una y digan qué se sacrifica. Su comparación tiene que incluir la alternativa de no cambiar nada.
c) En la propuesta A, la corrida es un pipeline. Nombren sus filtros en orden, digan cuál es el acoplamiento más fuerte entre ellos y den un cambio que tocaría un solo filtro y otro que los tocaría a todos.
d) Clasifiquen como comando o evento, y digan quién conoce a quién en cada
caso: ReconnectSupply, PaymentRegistered, IssueReceipt, BillIssued.
Si payments dejara de llamar a cutoffs y publicara PaymentRegistered,
¿qué flecha del grafo de la pregunta 3 cambiaría, y qué se paga por eso?
Pregunta 5 — Tácticas y sus trade-offs
Semana 6 · 17 minutos
Se midió por partes una de las 40 consultas de deuda de 4 000 ms de la prueba de la pregunta 2. De sus 4 000 ms, 3 550 ms los pasó esperando una conexión del pool, 400 ms ejecutando su consulta en PostgreSQL y 50 ms en todo lo demás. Sin la corrida, la misma consulta tarda 20 ms en PostgreSQL.
Datos del despliegue: la API corre en 3 instancias, cada una con un pool de
10 conexiones; la corrida de facturación usa 30 conexiones; PostgreSQL acepta
100 conexiones (max_connections = 100).
a) ¿A dónde se va el tiempo de esa consulta, y qué grupo de tácticas de rendimiento corresponde a cada parte? Alguien propone agregar tres instancias más de la API: ¿qué pasaría?
b) Estimen el peor caso: la conciliación entera coincide con el momento más pesado de la corrida. Llegan 120 consultas por segundo durante 10 minutos, y cada una ocupa una conexión 400 ms, como la consulta medida. Supongan llegadas a ritmo constante y que la cola empieza vacía. ¿Cuántas consultas por segundo pueden atender las 30 conexiones de la API? ¿Cuántas consultas quedan en cola al final de los 10 minutos, y cuánto espera la última? ¿Cuántas conexiones harían falta para que la cola no crezca?
c) Otra persona propone subir el pool de cada instancia de la API a 40 conexiones. Hagan la cuenta de conexiones y digan qué pasaría. Aunque cupieran, ¿por qué más conexiones no resolverían el problema?
d) Propongan tres tácticas para cumplir E1. Para cada una digan a qué grupo pertenece, qué parte del tiempo ataca y qué otro atributo o escenario empeora. ¿En qué orden las aplicarían, y cómo sabrían cuándo detenerse?
e) La red de recaudación reintenta la notificación de un pago cuando no recibe respuesta en 2 segundos (enunciado 6 de la lista). Expliquen cómo ese retry puede producir un pago aplicado dos veces. Den una táctica de detección, una de recuperación y una de prevención de fallas para el registro de pagos, y el costo de cada una.
Pregunta 6 — Un ADR y un recorrido del diseño
Semana 7 · 22 minutos
a) Escriban el ADR de la decisión que tomaron en la pregunta 4, con el template del curso: contexto con su escenario, alternativas consideradas (cada una con lo que gana, lo que cuesta y por qué no), decisión, estado y consecuencias. Usen las cuentas que ya hicieron.
b) Con la propuesta A ya construida, el equipo recorre E1 sobre el diseño y anota estas seis observaciones. Clasifiquen cada una como riesgo, no riesgo, punto de sensibilidad o punto de trade-off, y justifiquen en una frase. Corrijan la que esté mal escrita como hallazgo.
- El worker de facturación y la API usan la misma instancia de PostgreSQL.
- El número de conexiones que usa el worker de facturación.
- La consulta de deuda es una sola sentencia que entra por un índice y no llama a ningún sistema externo.
- Nadie decidió qué responde la API cuando su pool está lleno: hoy las consultas esperan sin límite.
- Para aliviar a PostgreSQL, la deuda de cada suministro se guarda 60 segundos en una cache: el tiempo de vida de esa entrada.
- El sistema podría ponerse lento en los días de vencimiento.
c) ¿Qué puede concluir el equipo después de ese recorrido, y qué no?