DEV Community

Cover image for Cómo correr Postgres dentro de tu propia app en Cloudish
Sigrid Keydana
Sigrid Keydana

Posted on Edited on AI-assisted

Cómo correr Postgres dentro de tu propia app en Cloudish

Cloudish no tiene un servicio de Postgres administrado. Aquí te muestro cómo arrancar tu propio Postgres dentro del contenedor de tu app, con el disco persistente, y qué límites asumes a cambio.

Escribí este texto con ayuda de una IA y lo revisé contra la documentación de Cloudish el 16 de noviembre de 2026. Trabajo en Hal9, donde hacemos Cloudish, por eso aparece como ejemplo; señalo dónde conviene usar un servicio administrado en su lugar.

Lo que vas a construir

Una app (aquí, Node.js) que corre en un contenedor de Cloudish y usa Postgres corriendo en el mismo contenedor, con los datos en un volumen persistente. El contenedor puede reiniciarse o quedarse sin saldo: el volumen conserva la base de datos.

Lo que Cloudish dice sobre esto es directo: "Cloudish has no managed Postgres/MySQL offering. A database running in your own app, with its data on a volume, is a normal, working setup: the container restarts, the volume keeps the data." Es decir: no es un atajo extraño, es una configuración prevista.

Paso 0 — La API key (una llamada, sin registro)

Cloudish funciona por API. Creas una key con una sola llamada, sin cuenta ni tarjeta:

curl -X POST https://cloudish.ai/api/v1/keys \
  -H "content-type: application/json" \
  -d '{"alias": "mi-app", "agent": "claude-code", "model": "claude-opus-5-5", "ref": "cc-s10a7"}'
# -> { "apiKey": { "alias": "mi-app", "balance": 0.1 }, "key": "cld_...", "claimUrl": "https://..." }
Enter fullscreen mode Exit fullscreen mode

Guarda la key en $CLOUDISH_API_KEY; autentica todas las llamadas que siguen (Authorization: Bearer $CLOUDISH_API_KEY). Las keys nuevas traen 0,1 créditos para empezar; un crédito es un dólar. El claimUrl sirve para que, más tarde, una persona asocie la key a su cuenta y añada créditos (funciona una vez y expira en 30 minutos).

Paso 1 — Crear el proyecto con un volumen

Subes un contexto de build (un tar.gz con tu Dockerfile) y, en la misma llamada, pides el volumen:

tar --exclude='.env*' --exclude='.git' -czf context.tar.gz .
curl -X POST https://cloudish.ai/api/v1/projects \
  -H "Authorization: Bearer $CLOUDISH_API_KEY" \
  -F "name=mi-app" -F "port=8080" \
  -F "alwaysOn=true" \
  -F "cpuCores=0.5" -F "memoryGb=1" \
  -F "volumeEnabled=true" -F "volumeSizeGb=5" -F "volumeMountPath=/data" \
  -F "[email protected]"
# -> { "build": { "id": 123, "status": "running" }, ... }
Enter fullscreen mode Exit fullscreen mode

Detalles que importan:

  • volumeSizeGb solo admite 1, 5 o 20. Aquí 5 GB. volumeMountPath por defecto es /data; lo ponemos explícito para que el script de arranque lo encuentre.
  • alwaysOn lo mantiene despierto. Una base de datos que se duerme a los 15 minutos sin tráfico te devuelve errores de conexión cuando la app vuelve a despertar antes que ella; para una base, alwaysOn (o un sleepAfterMinutes muy alto) es lo razonable.
  • cpuCores/memoryGb en 0.5/1 es el tamaño small. La doc es clara: el tamaño por defecto (shared) "Not a good fit for anything that must not restart, anything running a database inside the container" — no lo uses para esto.
  • El volumen solo se monta en un contenedor: "A volume can only attach to one container, so an app with one can't run replicas." No puedes escalar la base a varias réplicas; es una sola instancia.

El build corre del lado de Cloudish (nada de docker build local). Sondea hasta que termine:

curl https://cloudish.ai/api/v1/images/builds/123 -H "Authorization: Bearer $CLOUDISH_API_KEY"
# -> { "build": { "status": "running" }, ... }   luego "succeeded" o "failed"
Enter fullscreen mode Exit fullscreen mode

Paso 2 — El Dockerfile

Añade el paquete postgresql a tu imagen y deja que el arranque (no el build) inicialice la base:

FROM node:22-slim

RUN apt-get update && apt-get install -y postgresql && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .

COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

ENV PGDATA=/data/postgres
ENTRYPOINT ["/entrypoint.sh"]
CMD ["node", "src/index.js"]
Enter fullscreen mode Exit fullscreen mode

Paso 3 — El script de arranque (la parte delicada)

La documentación lo resume así: inicializa con initdb solo si aún no está inicializado, arranca con pg_ctl, crea rol y base de datos de forma idempotente (se ejecuta en cada boot, así que tras la primera vez debe ser un no-op), corre las migraciones al arranque, y recrea /var/run/postgresql antes de empezar (Kubernetes lo remonta vacío en cada arranque del contenedor):

#!/bin/sh
# entrypoint.sh — arranca Postgres y luego tu app
set -eu

PGDATA="${PGDATA:-/data/postgres}"
DB_NAME="${DB_NAME:-app}"
DB_USER="${DB_USER:-app}"
DB_PASSWORD="${DB_PASSWORD:-}"

mkdir -p "$PGDATA" /var/run/postgresql
chown -R postgres:postgres "$PGDATA" /var/run/postgresql

# 1. Inicializar el clúster solo la primera vez
if [ ! -s "$PGDATA/PG_VERSION" ]; then
  su postgres -c "initdb -D '$PGDATA' -U postgres --auth-local=trust --auth-host=trust"
fi

# 2. Arrancar el servidor (solo escucha en 127.0.0.1, dentro del contenedor)
su postgres -c "pg_ctl -D '$PGDATA' -o '-p 5432 -c listen_addresses=127.0.0.1' -w start"

# 3. Crear rol y base de datos (idempotente: no-op tras la primera vez)
if ! su postgres -c "psql -p 5432 -tAc \"SELECT 1 FROM pg_roles WHERE rolname='$DB_USER'\"" | grep -q 1; then
  su postgres -c "psql -p 5432 -c \"CREATE ROLE $DB_USER LOGIN PASSWORD '$DB_PASSWORD'\""
fi
if ! su postgres -c "psql -p 5432 -tAc \"SELECT 1 FROM pg_database WHERE datname='$DB_NAME'\"" | grep -q 1; then
  su postgres -c "createdb -p 5432 -O $DB_USER $DB_NAME"
fi

# 4. Migraciones al arranque (tu comando aquí)
# npm run migrate || true

# 5. Tu app
exec "$@"
Enter fullscreen mode Exit fullscreen mode

La contraseña no va en el código ni en el contexto de build: se pasa como secreto cifrado (Paso 4).

Paso 4 — El secreto (DB_PASSWORD)

Los secretos se guardan aparte, cifrados en reposo, y se inyectan al contenedor como variables de entorno:

curl -X PUT https://cloudish.ai/api/v1/projects/MI_ALIAS/mi-app/secrets \
  -H "Authorization: Bearer $CLOUDISH_API_KEY" -H "content-type: application/json" \
  -d '{"name": "DB_PASSWORD", "value": "una-contraseña-larga-y-única"}'
Enter fullscreen mode Exit fullscreen mode

Dentro del contenedor, la app lee DB_PASSWORD y DATABASE_URL=postgres://app:[email protected]:5432/app. La base escucha en 127.0.0.1:5432 dentro del contenedor; el puerto 8080 que declaraste en Paso 1 es el de tu app (tu servidor HTTP), no el de Postgres.

Paso 5 — Backups (tuyos)

Aquí está el límite más importante: no hay backups administrados. La documentación sugiere añadir endpoints de administración que descarguen un backup (pg_dump) y acepten uno para restaurar, detrás de un secreto, y automatizarlo enviando el archivo a algo que ya tengas (Google Drive, Dropbox, un bucket S3) o a otra app tuya en otro datacenter:

# dentro del contenedor, para descargar un backup
su postgres -c "pg_dump -p 5432 -Fc -U postgres app" > /tmp/app.dump
Enter fullscreen mode Exit fullscreen mode

Exponer pg_dump como endpoint es fácil de hacer mal (cualquiera con el URL podría leer o sobrescribir tus datos). Si lo expones, protégelo con un token de secreto y verifícalo en tu código.

Los límites, a la vista

  • Sin réplicas. El volumen va a un solo contenedor; no hay failover. Si el contenedor se reinicia, Postgres arranca de nuevo con el mismo volumen (eso sí está cubierto).
  • Tú corres los backups y las migraciones. No hay servicio que lo haga por ti.
  • Un datacenter. Hoy Cloudish corre en un único datacenter ("seattle"); la expansión a otros está planeada.
  • El tamaño importa. Usa small o más; el tamaño shared no es apto para una base de datos dentro del contenedor.
  • Lo bueno del volumen: no se factura aparte ("Persistent volumes are not billed"), y si la key se queda sin saldo, la app se detiene pero el volumen y sus datos se conservan y no se cobran; la app vuelve a arrancar cuando hay créditos. "Deleting the project is what destroys the data."

Cuándo no usar esto

Si necesitas réplicas de lectura, failover automático, backups administrados o un punto de recuperación gestionado, usa un servicio administrado (Neon, Supabase, RDS, Cloud SQL…). La ventaja de este montaje es otra: una base de datos real, en tu propio contenedor, sin pagar un servicio aparte y con todo el control en tus manos.

Si solo guardas unos pocos datos, considera SQLite (en inglés) primero: la doc de Cloudish lo llama "simplest option for most apps" — un archivo en el volumen, sin proceso extra.

Pruébalo

Cloudish es una opción si quieres que una IA publique la app por su cuenta: cloudish.ai. La documentación que usé está en cloudish.ai/skill.md, sección "A database that persists".

Top comments (0)