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://..." }
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 "context=@context.tar.gz"
# -> { "build": { "id": 123, "status": "running" }, ... }
Detalles que importan:
-
volumeSizeGbsolo admite 1, 5 o 20. Aquí 5 GB.volumeMountPathpor defecto es/data; lo ponemos explícito para que el script de arranque lo encuentre. -
alwaysOnlo 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 unsleepAfterMinutesmuy alto) es lo razonable. -
cpuCores/memoryGben 0.5/1 es el tamañosmall. 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"
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"]
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 "$@"
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"}'
Dentro del contenedor, la app lee DB_PASSWORD y DATABASE_URL=postgres://app:...@127.0.0.1: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
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
smallo más; el tamañosharedno 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)