Deployments overview
The Deployments section of DIAL Admin lets you self-host your own workloads next to DIAL and manage them from the Admin Panel. Bring your own MCP servers, models, adapters, applications and interceptors: DIAL Admin builds or pulls their images, runs them as containers in your Kubernetes cluster, and registers the running endpoints in DIAL, so DIAL users can use them like any other entity. You don't need deep Kubernetes expertise to do it.
What you can do
- Bring your own MCP servers. Deploy an MCP server from the MCP Registry, a Docker image or a Git repository, and expose its tools to DIAL users as a toolset.
- Self-host models. Run a Hugging Face model in your cluster as a model serving container, and register it as a DIAL model.
- Run your own adapters, applications and interceptors. Deploy them from an image or from source code, and register them in DIAL as an adapter, an application or an interceptor.
- Build from source. Build images from a Git repository (a branch and a commit), including private repositories, or use a ready-made Docker image from an external registry.
- Operate your workloads. Start and stop containers, scale them (including scale to zero), set CPU, memory and GPU resources, pin them to node pools, manage environment variables and startup probes.
- Troubleshoot. Read build and execution logs, Kubernetes events and resource metrics, and review the audit log of changes.
- Control network access. Allow a container or an image build to reach only the domains you list, with a global list plus per-image and per-container rules.
How it works
Source DIAL Admin Your Kubernetes cluster
────── ────────── ───────────────────────
Docker image ┐
Git repository ├─► Image ──► Container ──► running endpoint ──► DIAL entity
MCP Registry ┘ (build) (run, scale) (toolset, model, adapter,
Hugging Face model ────────────► Model serving ─► application, interceptor)
- An image describes what to run: a Docker image, source code to build, or an MCP server from the MCP Registry. Images of source code are built in your cluster.
- A container runs an image (or an external Docker image directly) as a serverless workload that scales on demand and gets an HTTPS endpoint. A model serving container runs a Hugging Face model.
- From a running container you create the matching DIAL entity. DIAL then calls the container's endpoint, for example when a user uses the toolset or the model.
Behind the screens, the Deployment Manager Backend does the work in Kubernetes: it builds images with BuildKit jobs, runs workloads as Knative services (and Hugging Face models with KServe), streams status, logs and events to Admin, and keeps its state in a database (H2 for development; PostgreSQL or SQL Server for production).
The Deployments menu appears in DIAL Admin when deployments are enabled and the Deployments API URL is configured; model servings also need Hugging Face support enabled. See DIAL Admin deployment settings. To deploy and configure the backend and its stdio MCP proxy images, see DIAL Deployment Manager.
Components and repositories
| Component | Repository | Role |
|---|---|---|
| DIAL Admin | ai-dial-admin-frontend | The Images, Containers and Model Servings screens. |
| DIAL Deployment Manager Backend | ai-dial-admin-deployment-manager-backend | Builds images, deploys and manages containers in Kubernetes, and reports their status, logs, events and metrics. |
| MCP proxy images | ai-dial-deployment-manager-mcp-proxy | Supply the executable added to stdio MCP server images to expose Streamable HTTP. |
| DIAL Core | ai-dial-core | Serves the entities you create from your containers to DIAL users. |
| DIAL SDK | ai-dial-sdk | Write your own adapters and applications to deploy here. |
Concepts
| Concept | Description |
|---|---|
| Image | The build source of a workload: an MCP server, adapter, application or interceptor. Its source is a Docker image, a source code repository (URL, branch and commit SHA) or the MCP Registry. Images are versioned. See Images. |
| Container | A running instance of an image, or of an external Docker image. Types are MCP, adapter, application and interceptor. It has resources, scaling, environment variables, a startup probe and firewall rules. See Containers. |
| Model serving | A container that runs a Hugging Face model in your cluster. See Model servings. |
| DIAL entity | What DIAL users see: a toolset, model, adapter, application or interceptor created from a running container. |
| Firewall | The list of domains a container or an image build may connect to. A global list applies to all image builds. |
| Node pool | A group of cluster nodes, for example GPU nodes. You pin a container to a pool in its Compute settings. |
Typical workflow
- Add an image from a Docker image, a Git repository or the MCP Registry, and wait until it is installed. See Images. You can skip this step for an external Docker image.
- Create a container from the image (or from an external Docker image reference). See Containers.
- Configure and run it: set the endpoint, resources, scaling, environment variables, startup probe and firewall, then run it. Check the status, the execution log and the metrics.
- Create the DIAL entity from the running container: a toolset, model, adapter, application or interceptor.
- Maintain it: update the configuration, publish a new image version, stop containers that are not needed, and review the audit log.
Common scenarios
| Goal | Approach |
|---|---|
| Make an MCP server available to users | Add an image of type MCP from the MCP Registry, deploy it as an MCP container, and create a toolset from it. See MCP containers. |
| Self-host an open model | Create a model serving container from a Hugging Face model, then create a model from it. Use a GPU node pool for large models. See Model servings. |
| Deploy your own application or adapter | Build an image from your repository, deploy it as an application or adapter container, and create the entity. |
| Add an interceptor | Deploy an interceptor image as a container, and create an interceptor from it. |
| Build from a private repository | Add the image from source code, and allow the repository's domain in the image firewall. |
| Save cost on rarely used workloads | Keep automatic scale to zero on, so a container uses no replicas when idle. |
| Lock down a workload | Restrict its outgoing traffic with firewall rules. Sensitive environment variables are stored as Kubernetes Secrets. |