De docker-compose.yml a una app en vivo — en el panel y con cdnctl

El proyecto de ejemplo

El servicio web cuenta visitas en Postgres y almacena en caché el último conteo en Redis; el worker es un bucle en segundo plano sin puerto que comparte los mismos add-ons gestionados. Ambas imágenes están precompiladas y subidas a un registro que la plataforma puede usar para hacer pull (compiladas para linux/amd64). La plataforma inyecta los detalles de conexión automáticamente — su código solo lee DATABASE_URL y REDIS_URL.

# docker-compose.yml
services:
  web:
    image: mediatriple/compose-demo-web:1.0.0
    ports:
      - "8080:8080"          # container port 8080 is exposed; the host side is ignored
    environment:
      APP_NAME: "Compose Demo"
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:8080/health"]
    depends_on: [db, cache]

  worker:
    image: mediatriple/compose-demo-worker:1.0.0   # no port -> stays private
    depends_on: [db, cache]

  db:
    image: postgres:16     # -> managed Postgres add-on (DATABASE_URL injected)

  cache:
    image: redis:7         # -> managed Redis add-on (REDIS_URL injected)

Cómo se mapean los servicios. Cada servicio con una imagen precompilada se convierte en una app gestionada. Los servicios cuya imagen es postgres, mysql/mariadb, redis o nats se convierten en complementos gestionados (managed add-ons) y se conectan a cada app que los referencia con depends_on — cada app consumidora obtiene su propia instancia de add-on, con credenciales inyectadas como env (DATABASE_HOST/PORT/NAME/USER, REDIS_URL) y secrets (DATABASE_PASSWORD, DATABASE_URL). Un servicio con build: (sin imagen precompilada) es rechazado — publique una imagen primero. Máximo 20 servicios.

A · Desde el panel

1 · Abra Container Apps

Inicie sesión, abra CDN Accounts, haga clic en el icono de ajustes de su cuenta y elija la pestaña Platforms, luego Container Apps (pulse Activate la primera vez). La vista general muestra los límites de su paquete y una lista de apps vacía.

2 · (Imágenes privadas) agregue una credencial de registro

Si sus imágenes son privadas, abra Create App y, en la fila Private registry credential, agregue un nombre, la URL del registro (https://index.docker.io/v1/ para Docker Hub), su usuario y un token de acceso de solo lectura, y luego guarde. El token se almacena cifrado y nunca se vuelve a mostrar. Las imágenes públicas no necesitan credencial.

3 · Import From Docker Compose

Cambie a Import From Docker Compose, y luego suba o pegue su docker-compose.yml (máximo 256 KB).

4 · Previsualice el plan

Haga clic en Preview. La plataforma analiza el archivo y muestra un plan no destructivo: cada app que va a crear, la imagen/puerto/réplicas, los add-ons conectados y cualquier advertencia — sin tocar nada todavía.

5 · Aplique, y observe el deploy

Marque I have reviewed this plan y haga clic en Apply Import. Apply es todo-o-nada; las apps y los add-ons se crean y los deploys se ponen en cola. En un minuto las apps pasan a running en la lista Your apps.

6 · Exponga la app web

Abra la app web (Manage →) y haga clic en Expose on cdn.com.tr para generar al instante un subdominio <uid>.cdn.com.tr (el HTTPS se gestiona por usted). Deje el worker privado. Eso es todo — su proyecto compose está en vivo. Vea el resultado ↓

B · Desde la terminal (cdnctl)

Cada paso anterior tiene un equivalente en CLI. Instale cdnctl, luego:

1 · Inicie sesión y localice su cuenta

cdnctl login --email you@example.com --password '••••••'
cdnctl accounts list                 # copy your account <uuid>

2 · Previsualice el plan

El mismo plan no destructivo que el panel — devuelve las apps, add-ons y advertencias como JSON. La vista previa solo devuelve claves de env/secret, nunca valores.

cdnctl container compose preview --account <uuid> --file docker-compose.yml

3 · Apply

Vuelve a planificar del lado del servidor (nunca se confía en el plan del cliente), aplica los derechos de su paquete, y luego crea las apps en orden de dependencia.

cdnctl container compose apply --account <uuid> --file docker-compose.yml --yes

Imágenes privadas. Cree una credencial de registro una vez (panel → Private registry credential, o la API), y adjúntela a las apps para que la plataforma pueda hacer pull — las imágenes públicas no necesitan nada.

4 · Observe, exponga, inspeccione

cdnctl container apps list   --account <uuid>
cdnctl container apps wait   --account <uuid> --app <app_uuid> --status running --timeout 300
cdnctl container apps expose --account <uuid> --app <app_uuid>   # -> <uid>.cdn.com.tr
cdnctl container apps logs   --account <uuid> --app <app_uuid> --tail 100
cdnctl container apps status --account <uuid> --app <app_uuid>

El resultado

La app web está en vivo en su subdominio cdn.com.tr — el contador de visitas persiste en el add-on Postgres gestionado, en caché en el add-on Redis gestionado, ambos reportando connected, servida por una réplica gestionada.

Algo que hay que saber sobre el estado compartido. Como cada app obtiene su propio Postgres/Redis gestionado, el worker escribe en una base de datos distinta de la que lee web. Para compartir realmente una base de datos SQL, deje que una app sea su dueña y que las demás la alcancen por nombre de app a través de la red privada (http://<nombre-app>:<puerto>), exactamente igual que un servicio de compose. Los backends sin contraseña (Redis, NATS) pueden compartirse configurando su URL como env en cada consumidor.