Skip to Content
We are live but in Staging 🎉
ComputeRecipesOverview

Recipes

Self-contained, runnable Compute scenarios grounded in the real managed-runtime contract, the image delivery paths, and the dodil CLI. Each one takes you from nothing to a published, invokable app. For the model behind these paths — compile vs image, and the builders involved — see Code & Runtimes.

Managed runtime

Hand the platform source code; it compiles (or, for Python, packs) it and runs the HTTP server for you. No Dockerfile, no registry.

RecipeWhat you’ll doWhen you need it
Deploy a Python appWrite a handler, add a dependency, publish, invoke, and reason about cold start + scalingThe everyday managed-runtime flow — your default path for Python on Ignite
Compile for fast cold startsCompile a Rust handler to a tiny static binary — --code ./src --runtime rust --rust-target native → draft compile → publishLatency-sensitive, scale-to-zero apps where cold start matters

Build an image

You need system packages, a specific base image, or full control of the container — but you’d rather the platform build it than run a registry. You own the HTTP server in all of these.

RecipeWhat you’ll doWhen you need it
Build an image from your codeShip a Dockerfile + local context — --code ./app --dockerfile-path Dockerfile (Kaniko)You have a Dockerfile and a local build context
Deploy from a git repoPoint at a repo — --git-url ... --git-ref main (Buildpacks auto-detect, or add a Dockerfile for Kaniko); private repos via a git SecretYour code already lives in git and you want the platform to clone and build it

Bring your own image

RecipeWhat you’ll doWhen you need it
Run a prebuilt image (BYOI)Run an image you already pushed — --image-ref (public) or + --registry-secret-ref (private registry)You build images in your own CI, or want total control of the container

Integrations

RecipeWhat you’ll doWhen you need it
Expose an app as an MCP toolCreate an app with --mcp-enabled + a description + an input schema, publish, and call it as `ignite_{org}_{name}`Make an app callable by agents/LLMs over MCP

Conventions used in these recipes

  • CLI-first. Commands use the dodil CLI; the id form is org:name (we use acme-corp:...). For raw HTTP, the base is https://api.dev.dodil.io/v1/ignite/... with Authorization: Bearer $DODIL_TOKEN.
  • One source per draft. A draft’s source flags are mutually exclusive: --code (compile, or + --dockerfile-path to build an image), --git-url (build from git), or --image-ref (BYOI). Picking one sets the app’s delivery path — see Code & Runtimes.
  • Managed vs image servers. Managed-runtime code is a handler the platform wraps in an HTTP server. Image-mode apps (build-from-code, build-from-git, BYOI) own their own server — listen on $PORT and answer POST /. Both receive the same x-ignite-* request headers.
  • Direct FQDN. After the first publish an app is reachable at `<app>-<org>.ignite.dodil.cloud` (port 80), still Bearer-authed.

Other useful pages

Catalog FunctionsDeploy a Python app