Desarrollo local — docker compose

El stack completo corre en docker compose desde la raíz digital-jungle/. Una sola red, volúmenes persistentes y healthchecks orquestando el orden de arranque.

Lo que se levanta

Capa	Servicios
Infraestructura	Postgres 16, NATS JetStream, LocalStack (S3/KMS/Rekognition/SES/SNS), Mailpit, Adminer
Migradores	db-platform, db-bmonkey, db-bhawk, db-bseal (corren una vez y salen)
Backend Go	platform-api, platform-worker, bmonkey-api, bmonkey-worker, bhawk-api, bhawk-worker, bseal-api, bseal-worker
Frontend	digital-jungle-site (Astro, con HMR)

Arrancar en 4 pasos

1. Clonar y entrar al monorepo:

   cd digital-jungle
   cp .env.example .env

2. Editar .env si tienes credenciales de Mercado Pago sandbox o Resend. Si lo dejas vacío todo arranca igual — los forms loguean a stdout y los pagos quedan deshabilitados hasta que pongas un MP_ACCESS_TOKEN válido.

3. Levantar todo:

   make up
   # equivale a: docker compose --profile all up -d

4. Ver URLs disponibles:

   make urls

URLs del stack local

Servicio	URL
Sitio Astro	http://localhost:4321
Platform API	http://localhost:8080
Bmonkey API	http://localhost:8081
Bhawk API	http://localhost:8082
Bseal API	http://localhost:8083
Adminer (DB UI)	http://localhost:8000
Mailpit (emails dev)	http://localhost:8025
NATS monitor	http://localhost:8222
LocalStack health	http://localhost:4566/_localstack/health

Profiles — levanta solo lo que necesitas

Solo infra

make infra
# Postgres + NATS + LocalStack + Mailpit + Adminer
# Útil cuando corres los binarios Go fuera de docker (con go run).

Infra + backend

make backend
# Todo lo anterior + 8 servicios Go + 4 migradores.

Solo el sitio

make site
# Solo el sitio Astro. Se conecta al PLATFORM_API_URL que tengas en .env
# (por defecto apunta al staging).

Comandos comunes

make ps                     # estado de todos los contenedores
make logs                   # tail global
make logs-bmonkey-api       # tail de un servicio específico
make psql-platform          # psql contra bjungle_platform
make migrate-up             # re-correr todas las migraciones (idempotente)
make build-bmonkey-api      # rebuild de un servicio
make down                   # parar todo (conserva volúmenes)
make nuke                   # parar y borrar volúmenes (destructivo)

Inspeccionar lo que pasa

• Postgres — abre Adminer en http://localhost:8000 (servidor: postgres, usuario: postgres, pass: postgres). Las 4 DBs lógicas (bjungle_platform, bjungle_bmonkey, bjungle_bhawk, bjungle_bseal) aparecen en el dropdown.

• NATS — el monitor en http://localhost:8222 muestra streams, consumers, mensajes pendientes. Para inspeccionar payloads concretos, exec dentro del contenedor: docker compose exec nats nats stream ls.

• Emails — los emails enviados por las apps (verificación, OTP, leads) caen en Mailpit en http://localhost:8025. Nada sale a internet desde el stack local.

• LocalStack — los buckets S3, llaves KMS y face collections se ven con awslocal desde tu host (si lo tienes instalado) o exec dentro: docker compose exec localstack awslocal s3 ls.

Cuidado

Mercado Pago no se mockea. El SDK habla con la sandbox real de MP (api.mercadopago.com). Necesitas un MP_ACCESS_TOKEN de sandbox para que los flujos de /checkout lleguen a aprobar pagos. Sin token, la activación de tenants pagos no completa.

Resetear la base de datos

make nuke       # borra contenedores y volúmenes (incluye datos de Postgres)
make backend    # vuelve a levantar; los migradores corren y dejan las DBs limpias

Estructura del compose

El compose vive en digital-jungle/docker-compose.yml. Usa profiles (infra, backend, site, all) y anchors YAML (x-go-app-env, x-platform-db, etc.) para que las env vars no se dupliquen entre los 8 servicios Go.

Los Dockerfiles son tres:

Archivo	Para qué
Dockerfile.api	Cualquier *-api (8080, 8081, 8082, 8083). Parametrizable con MODULE_PATH.
Dockerfile.worker	Cualquier *-worker. Mismo patrón.
<app>/backend/db-<app>/Dockerfile	Migrador específico por DB lógica.

Próximos pasos cuando exista el código real

Hoy los binarios Go son stubs (responden /healthz y poco más). A medida que se implementen los handlers reales, no hace falta cambiar el compose — los servicios ya están enchufados a Postgres, NATS y LocalStack. Solo se rebuildea con make build-<servicio>.