Import

From + Service → Import, drop a Compose file, render.yaml, or fly.toml onto the canvas. Application containers become services. Databases and caches become managed databases on the same board, with backups and private networking.

The mapping is usually mechanical. The Compose example below is the common case; Render and Fly imports follow the same canvas result.

Example `docker-compose.yml`

version: "3.9"

services:
  web:
    build: .
    ports: ["3000:3000"]
    environment:
      - DATABASE_URL=postgres://postgres:secret@postgres:5432/app
      - REDIS_URL=redis://redis:6379
    depends_on: [postgres, redis]

  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: app
    volumes:
      - pgdata:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    volumes:
      - redisdata:/data

volumes:
  pgdata:
  redisdata:

What you end up with

Kind	Name	On the canvas
service	`web`	Built from your Dockerfile, port 3000
database	`postgres`	Managed PostgreSQL
database	`redis`	Managed Redis-compatible cache
volume	`/data`	Volume on the web service

Import stages the tiles. Deploy applies them. You can also describe the same stack in config as code.

Compose → StackBlaze

Compose key	StackBlaze equivalent
`build: .`	Service (from Dockerfile)
`image: postgres:16`	Managed PostgreSQL
`image: redis:7-alpine`	Managed Redis-compatible database
`volumes:`	Volume
`environment:`	Variables

Under the hood

The mapping is consistent:

build / image: source builds and your own images become services, same port and start command.
known datastores: stock images such as postgres, redis, mysql, or mongo become managed databases.
volumes: named volumes on a service become volumes at the same path. Database storage is managed for you.
environment: values become variables. Database URLs are injected, so drop hardcoded DATABASE_URL from Compose.
networking: Compose’s default network becomes the environment’s private network. Names still resolve.

Step by step

Keep your docker-compose.yml as the reference

Your Compose file is the checklist. Import it, then deploy the staged canvas.
App containers become services

Anything you build or ship as your own image becomes a service from that Dockerfile or image, same port and command.
Datastore containers become managed databases

Do not run your own postgres or redis container. Import maps those images to managed databases with backups and optional HA.
Wire them together

Connection strings land as variables. Other services are reachable by name on the private network, so depends_on is handled for you.