Skip to Content
We are live but in Staging 🎉
Overview

Ignite Service Overview

Last validated: 2026-05-20

Ignite is Dodil’s serverless execution platform for tenant-scoped apps and managed model inference.

At a high level, Ignite provides:

  • App lifecycle management (create, draft, compile, test, publish, rollback)
  • Streaming and asynchronous invocation for deployed apps
  • Remote build pipeline for container image artifacts
  • Managed model inference endpoints (chat, embeddings, infer, transcribe, rerank)
  • Tenant secret storage for secure credential reuse
  • Internal admin controls for cluster health, warm pool management, and public app rollout

Supported Runtimes

Ignite supports both compile-source and image-based app delivery.

Compile-source runtimes (from ignite_common.proto runtime model):

  • Python (PythonRuntime)
  • Rust (RustRuntime) with native and wasm targets
  • Go (GoRuntime)
  • Deno (DenoRuntime)

In compile-source mode, you provide source, Ignite compiles/builds runtime artifacts, and published versions run behind the same gateway and scaling path as other apps.

Deployment Modes and BYOI

Ignite supports two practical deployment branches through draft/code APIs:

  1. Compilation mode: platform-managed build from source (code.compile)
  2. Image mode: customer/container image path (code.image)

Image mode includes three core patterns:

  • BYOI prebuilt image (image.prebuilt.image_ref)
  • Build image from archive (image.from_code)
  • Build image from git source (image.from_git)

What you can do with BYOI:

  • Run existing containerized services without rewriting to a platform SDK
  • Keep custom runtime stacks, native dependencies, and framework-specific startup logic
  • Expose one or more app ports (ports) and configure health checks (health_path)
  • Pull private images via registry_secret_ref (SecretService-backed credentials)

Across both compile and image modes, Ignite keeps a consistent control and invocation model: versioning, publish/invoke APIs, gateway auth, scale behavior, and execution visibility.

Core Concepts

App

Tenant-owned serverless unit (organization_name/app_name) with runtime, resource, scaling, and schema metadata.

Draft

Mutable code slot used for iteration before immutable version creation.

Version

Immutable release record with status tracking (DRAFT, ACTIVE, SUPERSEDED, FAILED, etc.).

Execution

Invocation instance with status, output, logs, and optional watch stream.

Build

Remote Kaniko-based image build job tracked by build ID and status lifecycle.

Model

Public model entry served through unified inference APIs.

Secret

Org-scoped named secret (Vault KV v2 backed) referenced by other workflows.

Service Inventory (Proto)

  1. ComputeService
  2. BuildService
  3. ModelService
  4. SecretService

Runtime Boundaries

Public user-facing surfaces:

  • ComputeService app lifecycle and invocation
  • BuildService build and build log APIs
  • ModelService inference APIs
  • SecretService CRUD APIs

For detailed coverage and gaps, see:

  • docs/07-feature-status.md
Auth and Access