2444 lines
81 KiB
TypeScript
2444 lines
81 KiB
TypeScript
export default {
|
|
$schema: "https://json-schema.org/draft/2020-12/schema",
|
|
$id: "compose_spec.json",
|
|
type: "object",
|
|
title: "Compose Specification",
|
|
description:
|
|
"The Compose file is a YAML file defining a multi-containers based application.",
|
|
properties: {
|
|
managedBy: {
|
|
const: "kuber",
|
|
},
|
|
version: {
|
|
type: "string",
|
|
deprecated: true,
|
|
description:
|
|
"declared for backward compatibility, ignored. Please remove it.",
|
|
},
|
|
name: {
|
|
type: "string",
|
|
description:
|
|
"define the Compose project name, until user defines one explicitly.",
|
|
},
|
|
include: {
|
|
type: "array",
|
|
items: {
|
|
$ref: "#/$defs/include",
|
|
},
|
|
description: "compose sub-projects to be included.",
|
|
},
|
|
services: {
|
|
type: "object",
|
|
patternProperties: {
|
|
"^[a-zA-Z0-9._-]+$": {
|
|
$ref: "#/$defs/service",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
description: "The services that will be used by your application.",
|
|
},
|
|
models: {
|
|
type: "object",
|
|
patternProperties: {
|
|
"^[a-zA-Z0-9._-]+$": {
|
|
$ref: "#/$defs/model",
|
|
},
|
|
},
|
|
description: "Language models that will be used by your application.",
|
|
},
|
|
networks: {
|
|
type: "object",
|
|
patternProperties: {
|
|
"^[a-zA-Z0-9._-]+$": {
|
|
$ref: "#/$defs/network",
|
|
},
|
|
},
|
|
description: "Networks that are shared among multiple services.",
|
|
},
|
|
volumes: {
|
|
type: "object",
|
|
patternProperties: {
|
|
"^[a-zA-Z0-9._-]+$": {
|
|
$ref: "#/$defs/volume",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
description: "Named volumes that are shared among multiple services.",
|
|
},
|
|
secrets: {
|
|
type: "object",
|
|
patternProperties: {
|
|
"^[a-zA-Z0-9._-]+$": {
|
|
$ref: "#/$defs/secret",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
description: "Secrets that are shared among multiple services.",
|
|
},
|
|
configs: {
|
|
type: "object",
|
|
patternProperties: {
|
|
"^[a-zA-Z0-9._-]+$": {
|
|
$ref: "#/$defs/config",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
description: "Configurations that are shared among multiple services.",
|
|
},
|
|
},
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
additionalProperties: false,
|
|
$defs: {
|
|
service: {
|
|
type: "object",
|
|
description: "Configuration for a service.",
|
|
properties: {
|
|
develop: {
|
|
$ref: "#/$defs/development",
|
|
},
|
|
deploy: {
|
|
$ref: "#/$defs/deployment",
|
|
},
|
|
annotations: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
},
|
|
attach: {
|
|
type: ["boolean", "string"],
|
|
},
|
|
build: {
|
|
description:
|
|
"Configuration options for building the service's image.",
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
description:
|
|
"Path to the build context. Can be a relative path or a URL.",
|
|
},
|
|
{
|
|
type: "object",
|
|
properties: {
|
|
context: {
|
|
type: "string",
|
|
description:
|
|
"Path to the build context. Can be a relative path or a URL.",
|
|
},
|
|
dockerfile: {
|
|
type: "string",
|
|
description:
|
|
"Name of the Dockerfile to use for building the image.",
|
|
},
|
|
dockerfile_inline: {
|
|
type: "string",
|
|
description:
|
|
"Inline Dockerfile content to use instead of a Dockerfile from the build context.",
|
|
},
|
|
entitlements: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
description:
|
|
"List of extra privileged entitlements to grant to the build process.",
|
|
},
|
|
args: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description:
|
|
"Build-time variables, specified as a map or a list of KEY=VAL pairs.",
|
|
},
|
|
ssh: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description:
|
|
"SSH agent socket or keys to expose to the build. Format is either a string or a list of 'default|<id>[=<socket>|<key>[,<key>]]'.",
|
|
},
|
|
labels: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description: "Labels to apply to the built image.",
|
|
},
|
|
cache_from: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
description:
|
|
"List of sources the image builder should use for cache resolution",
|
|
},
|
|
cache_to: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
description: "Cache destinations for the build cache.",
|
|
},
|
|
no_cache: {
|
|
type: ["boolean", "string"],
|
|
description: "Do not use cache when building the image.",
|
|
},
|
|
no_cache_filter: {
|
|
$ref: "#/$defs/string_or_list",
|
|
description:
|
|
"Do not use build cache for the specified stages.",
|
|
},
|
|
additional_contexts: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description:
|
|
"Additional build contexts to use, specified as a map of name to context path or URL.",
|
|
},
|
|
network: {
|
|
type: "string",
|
|
description:
|
|
"Network mode to use for the build. Options include 'default', 'none', 'host', or a network name.",
|
|
},
|
|
provenance: {
|
|
type: ["string", "boolean"],
|
|
description: "Add a provenance attestation",
|
|
},
|
|
sbom: {
|
|
type: ["string", "boolean"],
|
|
description: "Add a SBOM attestation",
|
|
},
|
|
pull: {
|
|
type: ["boolean", "string"],
|
|
description:
|
|
"Always attempt to pull a newer version of the image.",
|
|
},
|
|
target: {
|
|
type: "string",
|
|
description:
|
|
"Build stage to target in a multi-stage Dockerfile.",
|
|
},
|
|
shm_size: {
|
|
type: ["integer", "string"],
|
|
description:
|
|
"Size of /dev/shm for the build container. A string value can use suffix like '2g' for 2 gigabytes.",
|
|
},
|
|
extra_hosts: {
|
|
$ref: "#/$defs/extra_hosts",
|
|
description: "Add hostname mappings for the build container.",
|
|
},
|
|
isolation: {
|
|
type: "string",
|
|
description:
|
|
"Container isolation technology to use for the build process.",
|
|
},
|
|
privileged: {
|
|
type: ["boolean", "string"],
|
|
description:
|
|
"Give extended privileges to the build container.",
|
|
},
|
|
secrets: {
|
|
$ref: "#/$defs/service_config_or_secret",
|
|
description:
|
|
"Secrets to expose to the build. These are accessible at build-time.",
|
|
},
|
|
tags: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
description: "Additional tags to apply to the built image.",
|
|
},
|
|
ulimits: {
|
|
$ref: "#/$defs/ulimits",
|
|
description:
|
|
"Override the default ulimits for the build container.",
|
|
},
|
|
platforms: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
description:
|
|
"Platforms to build for, e.g., 'linux/amd64', 'linux/arm64', or 'windows/amd64'.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
blkio_config: {
|
|
type: "object",
|
|
description: "Block IO configuration for the service.",
|
|
properties: {
|
|
device_read_bps: {
|
|
type: "array",
|
|
description: "Limit read rate (bytes per second) from a device.",
|
|
items: {
|
|
$ref: "#/$defs/blkio_limit",
|
|
},
|
|
},
|
|
device_read_iops: {
|
|
type: "array",
|
|
description: "Limit read rate (IO per second) from a device.",
|
|
items: {
|
|
$ref: "#/$defs/blkio_limit",
|
|
},
|
|
},
|
|
device_write_bps: {
|
|
type: "array",
|
|
description: "Limit write rate (bytes per second) to a device.",
|
|
items: {
|
|
$ref: "#/$defs/blkio_limit",
|
|
},
|
|
},
|
|
device_write_iops: {
|
|
type: "array",
|
|
description: "Limit write rate (IO per second) to a device.",
|
|
items: {
|
|
$ref: "#/$defs/blkio_limit",
|
|
},
|
|
},
|
|
weight: {
|
|
type: ["integer", "string"],
|
|
description:
|
|
"Block IO weight (relative weight) for the service, between 10 and 1000.",
|
|
},
|
|
weight_device: {
|
|
type: "array",
|
|
description:
|
|
"Block IO weight (relative weight) for specific devices.",
|
|
items: {
|
|
$ref: "#/$defs/blkio_weight",
|
|
},
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
cap_add: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
uniqueItems: true,
|
|
description:
|
|
"Add Linux capabilities. For example, 'CAP_SYS_ADMIN', 'SYS_ADMIN', or 'NET_ADMIN'.",
|
|
},
|
|
cap_drop: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
uniqueItems: true,
|
|
description:
|
|
"Drop Linux capabilities. For example, 'CAP_SYS_ADMIN', 'SYS_ADMIN', or 'NET_ADMIN'.",
|
|
},
|
|
cgroup: {
|
|
type: "string",
|
|
enum: ["host", "private"],
|
|
description:
|
|
"Specify the cgroup namespace to join. Use 'host' to use the host's cgroup namespace, or 'private' to use a private cgroup namespace.",
|
|
},
|
|
cgroup_parent: {
|
|
type: "string",
|
|
description: "Specify an optional parent cgroup for the container.",
|
|
},
|
|
command: {
|
|
$ref: "#/$defs/command",
|
|
description:
|
|
"Override the default command declared by the container image, for example 'CMD' in Dockerfile.",
|
|
},
|
|
configs: {
|
|
$ref: "#/$defs/service_config_or_secret",
|
|
description: "Grant access to Configs on a per-service basis.",
|
|
},
|
|
container_name: {
|
|
type: "string",
|
|
description:
|
|
"Specify a custom container name, rather than a generated default name.",
|
|
pattern: "[a-zA-Z0-9][a-zA-Z0-9_.-]+",
|
|
},
|
|
cpu_count: {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
},
|
|
{
|
|
type: "integer",
|
|
minimum: 0,
|
|
},
|
|
],
|
|
description: "Number of usable CPUs.",
|
|
},
|
|
cpu_percent: {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
},
|
|
{
|
|
type: "integer",
|
|
minimum: 0,
|
|
maximum: 100,
|
|
},
|
|
],
|
|
description: "Percentage of CPU resources to use.",
|
|
},
|
|
cpu_shares: {
|
|
type: ["number", "string"],
|
|
description: "CPU shares (relative weight) for the container.",
|
|
},
|
|
cpu_quota: {
|
|
type: ["number", "string"],
|
|
description: "Limit the CPU CFS (Completely Fair Scheduler) quota.",
|
|
},
|
|
cpu_period: {
|
|
type: ["number", "string"],
|
|
description: "Limit the CPU CFS (Completely Fair Scheduler) period.",
|
|
},
|
|
cpu_rt_period: {
|
|
type: ["number", "string"],
|
|
description:
|
|
"Limit the CPU real-time period in microseconds or a duration.",
|
|
},
|
|
cpu_rt_runtime: {
|
|
type: ["number", "string"],
|
|
description:
|
|
"Limit the CPU real-time runtime in microseconds or a duration.",
|
|
},
|
|
cpus: {
|
|
type: ["number", "string"],
|
|
description:
|
|
"Number of CPUs to use. A floating-point value is supported to request partial CPUs.",
|
|
},
|
|
cpuset: {
|
|
type: "string",
|
|
description: "CPUs in which to allow execution (0-3, 0,1).",
|
|
},
|
|
credential_spec: {
|
|
type: "object",
|
|
description:
|
|
"Configure the credential spec for managed service account.",
|
|
properties: {
|
|
config: {
|
|
type: "string",
|
|
description: "The name of the credential spec Config to use.",
|
|
},
|
|
file: {
|
|
type: "string",
|
|
description: "Path to a credential spec file.",
|
|
},
|
|
registry: {
|
|
type: "string",
|
|
description: "Path to a credential spec in the Windows registry.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
depends_on: {
|
|
oneOf: [
|
|
{
|
|
$ref: "#/$defs/list_of_strings",
|
|
},
|
|
{
|
|
type: "object",
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^[a-zA-Z0-9._-]+$": {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
properties: {
|
|
restart: {
|
|
type: ["boolean", "string"],
|
|
description:
|
|
"Whether to restart dependent services when this service is restarted.",
|
|
},
|
|
required: {
|
|
type: "boolean",
|
|
default: true,
|
|
description:
|
|
"Whether the dependency is required for the dependent service to start.",
|
|
},
|
|
condition: {
|
|
type: "string",
|
|
enum: [
|
|
"service_started",
|
|
"service_healthy",
|
|
"service_completed_successfully",
|
|
],
|
|
description:
|
|
"Condition to wait for. 'service_started' waits until the service has started, 'service_healthy' waits until the service is healthy (as defined by its healthcheck), 'service_completed_successfully' waits until the service has completed successfully.",
|
|
},
|
|
},
|
|
required: ["condition"],
|
|
},
|
|
},
|
|
},
|
|
],
|
|
description:
|
|
"Express dependency between services. Service dependencies cause services to be started in dependency order. The dependent service will wait for the dependency to be ready before starting.",
|
|
},
|
|
device_cgroup_rules: {
|
|
$ref: "#/$defs/list_of_strings",
|
|
description: "Add rules to the cgroup allowed devices list.",
|
|
},
|
|
devices: {
|
|
type: "array",
|
|
description: "List of device mappings for the container.",
|
|
items: {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
},
|
|
{
|
|
type: "object",
|
|
required: ["source"],
|
|
properties: {
|
|
source: {
|
|
type: "string",
|
|
description: "Path on the host to the device.",
|
|
},
|
|
target: {
|
|
type: "string",
|
|
description:
|
|
"Path in the container where the device will be mapped.",
|
|
},
|
|
permissions: {
|
|
type: "string",
|
|
description: "Cgroup permissions for the device (rwm).",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
dns: {
|
|
$ref: "#/$defs/string_or_list",
|
|
description: "Custom DNS servers to set for the service container.",
|
|
},
|
|
dns_opt: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
uniqueItems: true,
|
|
description:
|
|
"Custom DNS options to be passed to the container's DNS resolver.",
|
|
},
|
|
dns_search: {
|
|
$ref: "#/$defs/string_or_list",
|
|
description:
|
|
"Custom DNS search domains to set on the service container.",
|
|
},
|
|
domainname: {
|
|
type: "string",
|
|
description: "Custom domain name to use for the service container.",
|
|
},
|
|
entrypoint: {
|
|
$ref: "#/$defs/command",
|
|
description:
|
|
"Override the default entrypoint declared by the container image, for example 'ENTRYPOINT' in Dockerfile.",
|
|
},
|
|
env_file: {
|
|
$ref: "#/$defs/env_file",
|
|
description:
|
|
"Add environment variables from a file or multiple files. Can be a single file path or a list of file paths.",
|
|
},
|
|
label_file: {
|
|
$ref: "#/$defs/label_file",
|
|
description:
|
|
"Add metadata to containers using files containing Docker labels.",
|
|
},
|
|
environment: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description:
|
|
"Add environment variables. You can use either an array or a list of KEY=VAL pairs.",
|
|
},
|
|
expose: {
|
|
type: "array",
|
|
items: {
|
|
type: ["string", "number"],
|
|
},
|
|
uniqueItems: true,
|
|
description:
|
|
"Expose ports without publishing them to the host machine - they'll only be accessible to linked services.",
|
|
},
|
|
extends: {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
},
|
|
{
|
|
type: "object",
|
|
properties: {
|
|
service: {
|
|
type: "string",
|
|
description: "The name of the service to extend.",
|
|
},
|
|
file: {
|
|
type: "string",
|
|
description:
|
|
"The file path where the service to extend is defined.",
|
|
},
|
|
},
|
|
required: ["service"],
|
|
additionalProperties: false,
|
|
},
|
|
],
|
|
description:
|
|
"Extend another service, in the current file or another file.",
|
|
},
|
|
provider: {
|
|
type: "object",
|
|
description:
|
|
"Specify a service which will not be manage by Compose directly, and delegate its management to an external provider.",
|
|
required: ["type"],
|
|
properties: {
|
|
type: {
|
|
type: "string",
|
|
description:
|
|
"External component used by Compose to manage setup and teardown lifecycle of the service.",
|
|
},
|
|
options: {
|
|
type: "object",
|
|
description: "Provider-specific options.",
|
|
patternProperties: {
|
|
"^.+$": {
|
|
oneOf: [
|
|
{
|
|
type: ["string", "number", "boolean"],
|
|
},
|
|
{
|
|
type: "array",
|
|
items: {
|
|
type: ["string", "number", "boolean"],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
external_links: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
uniqueItems: true,
|
|
description:
|
|
"Link to services started outside this Compose application. Specify services as <service_name>:<alias>.",
|
|
},
|
|
extra_hosts: {
|
|
$ref: "#/$defs/extra_hosts",
|
|
description:
|
|
"Add hostname mappings to the container network interface configuration.",
|
|
},
|
|
gpus: {
|
|
$ref: "#/$defs/gpus",
|
|
description:
|
|
"Define GPU devices to use. Can be set to 'all' to use all GPUs, or a list of specific GPU devices.",
|
|
},
|
|
group_add: {
|
|
type: "array",
|
|
items: {
|
|
type: ["string", "number"],
|
|
},
|
|
uniqueItems: true,
|
|
description:
|
|
"Add additional groups which user inside the container should be member of.",
|
|
},
|
|
healthcheck: {
|
|
$ref: "#/$defs/healthcheck",
|
|
description:
|
|
"Configure a health check for the container to monitor its health status.",
|
|
},
|
|
hostname: {
|
|
type: "string",
|
|
description: "Define a custom hostname for the service container.",
|
|
},
|
|
image: {
|
|
type: "string",
|
|
description:
|
|
"Specify the image to start the container from. Can be a repository/tag, a digest, or a local image ID.",
|
|
},
|
|
init: {
|
|
type: ["boolean", "string"],
|
|
description:
|
|
"Run as an init process inside the container that forwards signals and reaps processes.",
|
|
},
|
|
ipc: {
|
|
type: "string",
|
|
description:
|
|
"IPC sharing mode for the service container. Use 'host' to share the host's IPC namespace, 'service:[service_name]' to share with another service, or 'shareable' to allow other services to share this service's IPC namespace.",
|
|
},
|
|
isolation: {
|
|
type: "string",
|
|
description:
|
|
"Container isolation technology to use. Supported values are platform-specific.",
|
|
},
|
|
labels: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description:
|
|
"Add metadata to containers using Docker labels. You can use either an array or a list.",
|
|
},
|
|
links: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
uniqueItems: true,
|
|
description:
|
|
"Link to containers in another service. Either specify both the service name and a link alias (SERVICE:ALIAS), or just the service name.",
|
|
},
|
|
logging: {
|
|
type: "object",
|
|
description: "Logging configuration for the service.",
|
|
properties: {
|
|
driver: {
|
|
type: "string",
|
|
description:
|
|
"Logging driver to use, such as 'json-file', 'syslog', 'journald', etc.",
|
|
},
|
|
options: {
|
|
type: "object",
|
|
description: "Options for the logging driver.",
|
|
patternProperties: {
|
|
"^.+$": {
|
|
type: ["string", "number", "null"],
|
|
},
|
|
},
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
mac_address: {
|
|
type: "string",
|
|
description: "Container MAC address to set.",
|
|
},
|
|
mem_limit: {
|
|
type: ["number", "string"],
|
|
description:
|
|
"Memory limit for the container. A string value can use suffix like '2g' for 2 gigabytes.",
|
|
},
|
|
mem_reservation: {
|
|
type: ["string", "integer"],
|
|
description: "Memory reservation for the container.",
|
|
},
|
|
mem_swappiness: {
|
|
type: ["integer", "string"],
|
|
description: "Container memory swappiness as percentage (0 to 100).",
|
|
},
|
|
memswap_limit: {
|
|
type: ["number", "string"],
|
|
description:
|
|
"Amount of memory the container is allowed to swap to disk. Set to -1 to enable unlimited swap.",
|
|
},
|
|
network_mode: {
|
|
type: "string",
|
|
description:
|
|
"Network mode. Values can be 'bridge', 'host', 'none', 'service:[service name]', or 'container:[container name]'.",
|
|
},
|
|
models: {
|
|
oneOf: [
|
|
{
|
|
$ref: "#/$defs/list_of_strings",
|
|
},
|
|
{
|
|
type: "object",
|
|
patternProperties: {
|
|
"^[a-zA-Z0-9._-]+$": {
|
|
oneOf: [
|
|
{
|
|
type: "object",
|
|
properties: {
|
|
endpoint_var: {
|
|
type: "string",
|
|
description:
|
|
"Environment variable set to AI model endpoint.",
|
|
},
|
|
model_var: {
|
|
type: "string",
|
|
description:
|
|
"Environment variable set to AI model name.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
{
|
|
type: "null",
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
],
|
|
description:
|
|
"AI Models to use, referencing entries under the top-level models key.",
|
|
},
|
|
networks: {
|
|
oneOf: [
|
|
{
|
|
$ref: "#/$defs/list_of_strings",
|
|
},
|
|
{
|
|
type: "object",
|
|
patternProperties: {
|
|
"^[a-zA-Z0-9._-]+$": {
|
|
oneOf: [
|
|
{
|
|
type: "object",
|
|
properties: {
|
|
aliases: {
|
|
$ref: "#/$defs/list_of_strings",
|
|
description:
|
|
"Alternative hostnames for this service on the network.",
|
|
},
|
|
interface_name: {
|
|
type: "string",
|
|
description:
|
|
"Interface network name used to connect to network",
|
|
},
|
|
ipv4_address: {
|
|
type: "string",
|
|
description:
|
|
"Specify a static IPv4 address for this service on this network.",
|
|
},
|
|
ipv6_address: {
|
|
type: "string",
|
|
description:
|
|
"Specify a static IPv6 address for this service on this network.",
|
|
},
|
|
link_local_ips: {
|
|
$ref: "#/$defs/list_of_strings",
|
|
description: "List of link-local IPs.",
|
|
},
|
|
mac_address: {
|
|
type: "string",
|
|
description:
|
|
"Specify a MAC address for this service on this network.",
|
|
},
|
|
driver_opts: {
|
|
type: "object",
|
|
description: "Driver options for this network.",
|
|
patternProperties: {
|
|
"^.+$": {
|
|
type: ["string", "number"],
|
|
},
|
|
},
|
|
},
|
|
priority: {
|
|
type: "number",
|
|
description:
|
|
"Specify the priority for the network connection.",
|
|
},
|
|
gw_priority: {
|
|
type: "number",
|
|
description:
|
|
"Specify the gateway priority for the network connection.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
{
|
|
type: "null",
|
|
},
|
|
],
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
],
|
|
description:
|
|
"Networks to join, referencing entries under the top-level networks key. Can be a list of network names or a mapping of network name to network configuration.",
|
|
},
|
|
oom_kill_disable: {
|
|
type: ["boolean", "string"],
|
|
description: "Disable OOM Killer for the container.",
|
|
},
|
|
oom_score_adj: {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
},
|
|
{
|
|
type: "integer",
|
|
minimum: -1000,
|
|
maximum: 1000,
|
|
},
|
|
],
|
|
description:
|
|
"Tune host's OOM preferences for the container (accepts -1000 to 1000).",
|
|
},
|
|
pid: {
|
|
type: ["string", "null"],
|
|
description: "PID mode for container.",
|
|
},
|
|
pids_limit: {
|
|
type: ["number", "string"],
|
|
description:
|
|
"Tune a container's PIDs limit. Set to -1 for unlimited PIDs.",
|
|
},
|
|
platform: {
|
|
type: "string",
|
|
description:
|
|
"Target platform to run on, e.g., 'linux/amd64', 'linux/arm64', or 'windows/amd64'.",
|
|
},
|
|
ports: {
|
|
type: "array",
|
|
description:
|
|
"Expose container ports. Short format ([HOST:]CONTAINER[/PROTOCOL]).",
|
|
items: {
|
|
oneOf: [
|
|
{
|
|
type: "number",
|
|
},
|
|
{
|
|
type: "string",
|
|
},
|
|
{
|
|
type: "object",
|
|
properties: {
|
|
name: {
|
|
type: "string",
|
|
description: "A human-readable name for this port mapping.",
|
|
},
|
|
mode: {
|
|
type: "string",
|
|
description:
|
|
"The port binding mode, either 'host' for publishing a host port or 'ingress' for load balancing.",
|
|
},
|
|
host_ip: {
|
|
type: "string",
|
|
description: "The host IP to bind to.",
|
|
},
|
|
target: {
|
|
type: ["integer", "string"],
|
|
description: "The port inside the container.",
|
|
},
|
|
published: {
|
|
type: ["string", "integer"],
|
|
description: "The publicly exposed port.",
|
|
},
|
|
protocol: {
|
|
type: "string",
|
|
description: "The port protocol (tcp or udp).",
|
|
},
|
|
app_protocol: {
|
|
type: "string",
|
|
description:
|
|
"Application protocol to use with the port (e.g., http, https, mysql).",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
uniqueItems: true,
|
|
},
|
|
pre_start: {
|
|
type: "array",
|
|
items: {
|
|
$ref: "#/$defs/pre_start_hook",
|
|
},
|
|
description:
|
|
"Init containers to run to completion before the service container is started. Each step runs in its own ephemeral container, in declared order; a non-zero exit fails the bring-up of the service and its dependents.",
|
|
},
|
|
post_start: {
|
|
type: "array",
|
|
items: {
|
|
$ref: "#/$defs/service_hook",
|
|
},
|
|
description:
|
|
"Commands to run after the container starts. If any command fails, the container stops.",
|
|
},
|
|
pre_stop: {
|
|
type: "array",
|
|
items: {
|
|
$ref: "#/$defs/service_hook",
|
|
},
|
|
description:
|
|
"Commands to run before the container stops. If any command fails, the container stop is aborted.",
|
|
},
|
|
privileged: {
|
|
type: ["boolean", "string"],
|
|
description: "Give extended privileges to the service container.",
|
|
},
|
|
profiles: {
|
|
$ref: "#/$defs/list_of_strings",
|
|
description:
|
|
"List of profiles for this service. When profiles are specified, services are only started when the profile is activated.",
|
|
},
|
|
pull_policy: {
|
|
type: "string",
|
|
pattern:
|
|
"always|never|build|if_not_present|missing|refresh|daily|weekly|every_([0-9]+[wdhms])+",
|
|
description:
|
|
"Policy for pulling images. Options include: 'always', 'never', 'if_not_present', 'missing', 'build', or time-based refresh policies.",
|
|
},
|
|
pull_refresh_after: {
|
|
type: "string",
|
|
description:
|
|
"Time after which to refresh the image. Used with pull_policy=refresh.",
|
|
},
|
|
read_only: {
|
|
type: ["boolean", "string"],
|
|
description: "Mount the container's filesystem as read only.",
|
|
},
|
|
restart: {
|
|
type: "string",
|
|
description:
|
|
"Restart policy for the service container. Options include: 'no', 'always', 'on-failure', and 'unless-stopped'.",
|
|
},
|
|
runtime: {
|
|
type: "string",
|
|
description: "Runtime to use for this container, e.g., 'runc'.",
|
|
},
|
|
scale: {
|
|
type: ["integer", "string"],
|
|
description: "Number of containers to deploy for this service.",
|
|
},
|
|
security_opt: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
uniqueItems: true,
|
|
description:
|
|
"Override the default labeling scheme for each container.",
|
|
},
|
|
shm_size: {
|
|
type: ["number", "string"],
|
|
description:
|
|
"Size of /dev/shm. A string value can use suffix like '2g' for 2 gigabytes.",
|
|
},
|
|
secrets: {
|
|
$ref: "#/$defs/service_config_or_secret",
|
|
description: "Grant access to Secrets on a per-service basis.",
|
|
},
|
|
sysctls: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description:
|
|
"Kernel parameters to set in the container. You can use either an array or a list.",
|
|
},
|
|
stdin_open: {
|
|
type: ["boolean", "string"],
|
|
description: "Keep STDIN open even if not attached.",
|
|
},
|
|
stop_grace_period: {
|
|
type: "string",
|
|
description:
|
|
"Time to wait for the container to stop gracefully before sending SIGKILL (e.g., '1s', '1m30s').",
|
|
},
|
|
stop_signal: {
|
|
type: "string",
|
|
description:
|
|
"Signal to stop the container (e.g., 'SIGTERM', 'SIGINT').",
|
|
},
|
|
storage_opt: {
|
|
type: "object",
|
|
description: "Storage driver options for the container.",
|
|
},
|
|
tmpfs: {
|
|
$ref: "#/$defs/string_or_list",
|
|
description:
|
|
"Mount a temporary filesystem (tmpfs) into the container. Can be a single value or a list.",
|
|
},
|
|
tty: {
|
|
type: ["boolean", "string"],
|
|
description: "Allocate a pseudo-TTY to service container.",
|
|
},
|
|
ulimits: {
|
|
$ref: "#/$defs/ulimits",
|
|
description: "Override the default ulimits for a container.",
|
|
},
|
|
use_api_socket: {
|
|
type: "boolean",
|
|
description: "Bind mount Docker API socket and required auth.",
|
|
},
|
|
user: {
|
|
type: "string",
|
|
description: "Username or UID to run the container process as.",
|
|
},
|
|
uts: {
|
|
type: "string",
|
|
description:
|
|
"UTS namespace to use. 'host' shares the host's UTS namespace.",
|
|
},
|
|
userns_mode: {
|
|
type: "string",
|
|
description:
|
|
"User namespace to use. 'host' shares the host's user namespace.",
|
|
},
|
|
volumes: {
|
|
type: "array",
|
|
description:
|
|
"Mount host paths or named volumes accessible to the container. Short syntax (VOLUME:CONTAINER_PATH[:MODE])",
|
|
items: {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
},
|
|
{
|
|
type: "object",
|
|
required: ["type"],
|
|
properties: {
|
|
type: {
|
|
type: "string",
|
|
enum: [
|
|
"bind",
|
|
"volume",
|
|
"tmpfs",
|
|
"cluster",
|
|
"npipe",
|
|
"image",
|
|
],
|
|
description:
|
|
"The mount type: bind for mounting host directories, volume for named volumes, tmpfs for temporary filesystems, cluster for cluster volumes, npipe for named pipes, or image for mounting from an image.",
|
|
},
|
|
source: {
|
|
type: "string",
|
|
description:
|
|
"The source of the mount, a path on the host for a bind mount, a docker image reference for an image mount, or the name of a volume defined in the top-level volumes key. Not applicable for a tmpfs mount.",
|
|
},
|
|
target: {
|
|
type: "string",
|
|
description:
|
|
"The path in the container where the volume is mounted.",
|
|
},
|
|
read_only: {
|
|
type: ["boolean", "string"],
|
|
description: "Flag to set the volume as read-only.",
|
|
},
|
|
consistency: {
|
|
type: "string",
|
|
description:
|
|
"The consistency requirements for the mount. Available values are platform specific.",
|
|
},
|
|
bind: {
|
|
type: "object",
|
|
description: "Configuration specific to bind mounts.",
|
|
properties: {
|
|
propagation: {
|
|
type: "string",
|
|
description:
|
|
"The propagation mode for the bind mount: 'shared', 'slave', 'private', 'rshared', 'rslave', or 'rprivate'.",
|
|
},
|
|
create_host_path: {
|
|
type: ["boolean", "string"],
|
|
description:
|
|
"Create the host path if it doesn't exist.",
|
|
},
|
|
recursive: {
|
|
type: "string",
|
|
enum: ["enabled", "disabled", "writable", "readonly"],
|
|
description: "Recursively mount the source directory.",
|
|
},
|
|
selinux: {
|
|
type: "string",
|
|
enum: ["z", "Z"],
|
|
description:
|
|
"SELinux relabeling options: 'z' for shared content, 'Z' for private unshared content.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
volume: {
|
|
type: "object",
|
|
description: "Configuration specific to volume mounts.",
|
|
properties: {
|
|
labels: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description: "Labels to apply to the volume.",
|
|
},
|
|
nocopy: {
|
|
type: ["boolean", "string"],
|
|
description:
|
|
"Flag to disable copying of data from a container when a volume is created.",
|
|
},
|
|
subpath: {
|
|
type: "string",
|
|
description:
|
|
"Path within the volume to mount instead of the volume root.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
tmpfs: {
|
|
type: "object",
|
|
description: "Configuration specific to tmpfs mounts.",
|
|
properties: {
|
|
size: {
|
|
oneOf: [
|
|
{
|
|
type: "integer",
|
|
minimum: 0,
|
|
},
|
|
{
|
|
type: "string",
|
|
},
|
|
],
|
|
description: "Size of the tmpfs mount in bytes.",
|
|
},
|
|
mode: {
|
|
type: ["number", "string"],
|
|
description: "File mode of the tmpfs in octal.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
image: {
|
|
type: "object",
|
|
description: "Configuration specific to image mounts.",
|
|
properties: {
|
|
subpath: {
|
|
type: "string",
|
|
description:
|
|
"Path within the image to mount instead of the image root.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
uniqueItems: true,
|
|
},
|
|
volumes_from: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
uniqueItems: true,
|
|
description:
|
|
"Mount volumes from another service or container. Optionally specify read-only access (ro) or read-write (rw).",
|
|
},
|
|
working_dir: {
|
|
type: "string",
|
|
description:
|
|
"The working directory in which the entrypoint or command will be run",
|
|
},
|
|
},
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
healthcheck: {
|
|
type: "object",
|
|
description:
|
|
"Configuration options to determine whether the container is healthy.",
|
|
properties: {
|
|
disable: {
|
|
type: ["boolean", "string"],
|
|
description:
|
|
"Disable any container-specified healthcheck. Set to true to disable.",
|
|
},
|
|
interval: {
|
|
type: "string",
|
|
description:
|
|
"Time between running the check (e.g., '1s', '1m30s'). Default: 30s.",
|
|
},
|
|
retries: {
|
|
type: ["number", "string"],
|
|
description:
|
|
"Number of consecutive failures needed to consider the container as unhealthy. Default: 3.",
|
|
},
|
|
test: {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
},
|
|
{
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
},
|
|
],
|
|
description:
|
|
"The test to perform to check container health. Can be a string or a list. The first item is either NONE, CMD, or CMD-SHELL. If it's CMD, the rest of the command is exec'd. If it's CMD-SHELL, the rest is run in the shell.",
|
|
},
|
|
timeout: {
|
|
type: "string",
|
|
description:
|
|
"Maximum time to allow one check to run (e.g., '1s', '1m30s'). Default: 30s.",
|
|
},
|
|
start_period: {
|
|
type: "string",
|
|
description:
|
|
"Start period for the container to initialize before starting health-retries countdown (e.g., '1s', '1m30s'). Default: 0s.",
|
|
},
|
|
start_interval: {
|
|
type: "string",
|
|
description:
|
|
"Time between running the check during the start period (e.g., '1s', '1m30s'). Default: interval value.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
development: {
|
|
type: ["object", "null"],
|
|
description:
|
|
"Development configuration for the service, used for development workflows.",
|
|
properties: {
|
|
watch: {
|
|
type: "array",
|
|
description:
|
|
"Configure watch mode for the service, which monitors file changes and performs actions in response.",
|
|
items: {
|
|
type: "object",
|
|
required: ["path", "action"],
|
|
properties: {
|
|
ignore: {
|
|
$ref: "#/$defs/string_or_list",
|
|
description: "Patterns to exclude from watching.",
|
|
},
|
|
include: {
|
|
$ref: "#/$defs/string_or_list",
|
|
description: "Patterns to include in watching.",
|
|
},
|
|
path: {
|
|
type: "string",
|
|
description: "Path to watch for changes.",
|
|
},
|
|
action: {
|
|
type: "string",
|
|
enum: [
|
|
"rebuild",
|
|
"sync",
|
|
"restart",
|
|
"sync+restart",
|
|
"sync+exec",
|
|
],
|
|
description:
|
|
"Action to take when a change is detected: rebuild the container, sync files, restart the container, sync and restart, or sync and execute a command.",
|
|
},
|
|
target: {
|
|
type: "string",
|
|
description:
|
|
"Target path in the container for sync operations.",
|
|
},
|
|
exec: {
|
|
$ref: "#/$defs/service_hook",
|
|
description:
|
|
"Command to execute when a change is detected and action is sync+exec.",
|
|
},
|
|
initial_sync: {
|
|
type: "boolean",
|
|
description:
|
|
"Ensure that an initial synchronization is done before starting watch mode for sync+x triggers",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
deployment: {
|
|
type: ["object", "null"],
|
|
description: "Deployment configuration for the service.",
|
|
properties: {
|
|
mode: {
|
|
type: "string",
|
|
description:
|
|
"Deployment mode for the service: 'replicated' (default) or 'global'.",
|
|
},
|
|
endpoint_mode: {
|
|
type: "string",
|
|
description:
|
|
"Endpoint mode for the service: 'vip' (default) or 'dnsrr'.",
|
|
},
|
|
replicas: {
|
|
type: ["integer", "string"],
|
|
description: "Number of replicas of the service container to run.",
|
|
},
|
|
labels: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description: "Labels to apply to the service.",
|
|
},
|
|
rollback_config: {
|
|
type: "object",
|
|
description: "Configuration for rolling back a service update.",
|
|
properties: {
|
|
parallelism: {
|
|
type: ["integer", "string"],
|
|
description:
|
|
"The number of containers to rollback at a time. If set to 0, all containers rollback simultaneously.",
|
|
},
|
|
delay: {
|
|
type: "string",
|
|
description:
|
|
"The time to wait between each container group's rollback (e.g., '1s', '1m30s').",
|
|
},
|
|
failure_action: {
|
|
type: "string",
|
|
description:
|
|
"Action to take if a rollback fails: 'continue', 'pause'.",
|
|
},
|
|
monitor: {
|
|
type: "string",
|
|
description:
|
|
"Duration to monitor each task for failures after it is created (e.g., '1s', '1m30s').",
|
|
},
|
|
max_failure_ratio: {
|
|
type: ["number", "string"],
|
|
description: "Failure rate to tolerate during a rollback.",
|
|
},
|
|
order: {
|
|
type: "string",
|
|
enum: ["start-first", "stop-first"],
|
|
description:
|
|
"Order of operations during rollbacks: 'stop-first' (default) or 'start-first'.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
update_config: {
|
|
type: "object",
|
|
description: "Configuration for updating a service.",
|
|
properties: {
|
|
parallelism: {
|
|
type: ["integer", "string"],
|
|
description: "The number of containers to update at a time.",
|
|
},
|
|
delay: {
|
|
type: "string",
|
|
description:
|
|
"The time to wait between updating a group of containers (e.g., '1s', '1m30s').",
|
|
},
|
|
failure_action: {
|
|
type: "string",
|
|
description:
|
|
"Action to take if an update fails: 'continue', 'pause', 'rollback'.",
|
|
},
|
|
monitor: {
|
|
type: "string",
|
|
description:
|
|
"Duration to monitor each updated task for failures after it is created (e.g., '1s', '1m30s').",
|
|
},
|
|
max_failure_ratio: {
|
|
type: ["number", "string"],
|
|
description:
|
|
"Failure rate to tolerate during an update (0 to 1).",
|
|
},
|
|
order: {
|
|
type: "string",
|
|
enum: ["start-first", "stop-first"],
|
|
description:
|
|
"Order of operations during updates: 'stop-first' (default) or 'start-first'.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
resources: {
|
|
type: "object",
|
|
description: "Resource constraints and reservations for the service.",
|
|
properties: {
|
|
limits: {
|
|
type: "object",
|
|
description: "Resource limits for the service containers.",
|
|
properties: {
|
|
cpus: {
|
|
type: ["number", "string"],
|
|
description:
|
|
"Limit for how much of the available CPU resources, as number of cores, a container can use.",
|
|
},
|
|
memory: {
|
|
type: "string",
|
|
description:
|
|
"Limit on the amount of memory a container can allocate (e.g., '1g', '1024m').",
|
|
},
|
|
pids: {
|
|
type: ["integer", "string"],
|
|
description:
|
|
"Maximum number of PIDs available to the container.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
reservations: {
|
|
type: "object",
|
|
description: "Resource reservations for the service containers.",
|
|
properties: {
|
|
cpus: {
|
|
type: ["number", "string"],
|
|
description:
|
|
"Reservation for how much of the available CPU resources, as number of cores, a container can use.",
|
|
},
|
|
memory: {
|
|
type: "string",
|
|
description:
|
|
"Reservation on the amount of memory a container can allocate (e.g., '1g', '1024m').",
|
|
},
|
|
generic_resources: {
|
|
$ref: "#/$defs/generic_resources",
|
|
description: "User-defined resources to reserve.",
|
|
},
|
|
devices: {
|
|
$ref: "#/$defs/devices",
|
|
description: "Device reservations for the container.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
restart_policy: {
|
|
type: "object",
|
|
description: "Restart policy for the service containers.",
|
|
properties: {
|
|
condition: {
|
|
type: "string",
|
|
description:
|
|
"Condition for restarting the container: 'none', 'on-failure', 'any'.",
|
|
},
|
|
delay: {
|
|
type: "string",
|
|
description:
|
|
"Delay between restart attempts (e.g., '1s', '1m30s').",
|
|
},
|
|
max_attempts: {
|
|
type: ["integer", "string"],
|
|
description:
|
|
"Maximum number of restart attempts before giving up.",
|
|
},
|
|
window: {
|
|
type: "string",
|
|
description:
|
|
"Time window used to evaluate the restart policy (e.g., '1s', '1m30s').",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
placement: {
|
|
type: "object",
|
|
description:
|
|
"Constraints and preferences for the platform to select a physical node to run service containers",
|
|
properties: {
|
|
constraints: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
description:
|
|
"Placement constraints for the service (e.g., 'node.role==manager').",
|
|
},
|
|
preferences: {
|
|
type: "array",
|
|
description: "Placement preferences for the service.",
|
|
items: {
|
|
type: "object",
|
|
properties: {
|
|
spread: {
|
|
type: "string",
|
|
description:
|
|
"Spread tasks evenly across values of the specified node label.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
},
|
|
max_replicas_per_node: {
|
|
type: ["integer", "string"],
|
|
description: "Maximum number of replicas of the service.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
generic_resources: {
|
|
type: "array",
|
|
description:
|
|
"User-defined resources for services, allowing services to reserve specialized hardware resources.",
|
|
items: {
|
|
type: "object",
|
|
properties: {
|
|
discrete_resource_spec: {
|
|
type: "object",
|
|
description: "Specification for discrete (countable) resources.",
|
|
properties: {
|
|
kind: {
|
|
type: "string",
|
|
description: "Type of resource (e.g., 'GPU', 'FPGA', 'SSD').",
|
|
},
|
|
value: {
|
|
type: ["number", "string"],
|
|
description: "Number of resources of this kind to reserve.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
},
|
|
devices: {
|
|
type: "array",
|
|
description:
|
|
"Device reservations for containers, allowing services to access specific hardware devices.",
|
|
items: {
|
|
type: "object",
|
|
properties: {
|
|
capabilities: {
|
|
$ref: "#/$defs/list_of_strings",
|
|
description:
|
|
"List of capabilities the device needs to have (e.g., 'gpu', 'compute', 'utility').",
|
|
},
|
|
count: {
|
|
type: ["string", "integer"],
|
|
description: "Number of devices of this type to reserve.",
|
|
},
|
|
device_ids: {
|
|
$ref: "#/$defs/list_of_strings",
|
|
description: "List of specific device IDs to reserve.",
|
|
},
|
|
driver: {
|
|
type: "string",
|
|
description: "Device driver to use (e.g., 'nvidia').",
|
|
},
|
|
options: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description: "Driver-specific options for the device.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
required: ["capabilities"],
|
|
},
|
|
},
|
|
gpus: {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
enum: ["all"],
|
|
description: "Use all available GPUs.",
|
|
},
|
|
{
|
|
type: "array",
|
|
description: "List of specific GPU devices to use.",
|
|
items: {
|
|
type: "object",
|
|
properties: {
|
|
capabilities: {
|
|
$ref: "#/$defs/list_of_strings",
|
|
description:
|
|
"List of capabilities the GPU needs to have (e.g., 'compute', 'utility').",
|
|
},
|
|
count: {
|
|
type: ["string", "integer"],
|
|
description: "Number of GPUs to use.",
|
|
},
|
|
device_ids: {
|
|
$ref: "#/$defs/list_of_strings",
|
|
description: "List of specific GPU device IDs to use.",
|
|
},
|
|
driver: {
|
|
type: "string",
|
|
description: "GPU driver to use (e.g., 'nvidia').",
|
|
},
|
|
options: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description: "Driver-specific options for the GPU.",
|
|
},
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
include: {
|
|
description: "Compose application or sub-projects to be included.",
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
},
|
|
{
|
|
type: "object",
|
|
properties: {
|
|
path: {
|
|
$ref: "#/$defs/string_or_list",
|
|
description:
|
|
"Path to the Compose application or sub-project files to include.",
|
|
},
|
|
env_file: {
|
|
$ref: "#/$defs/string_or_list",
|
|
description:
|
|
"Path to the environment files to use to define default values when interpolating variables in the Compose files being parsed.",
|
|
},
|
|
project_directory: {
|
|
type: "string",
|
|
description:
|
|
"Path to resolve relative paths set in the Compose file",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
],
|
|
},
|
|
network: {
|
|
type: ["object", "null"],
|
|
description: "Network configuration for the Compose application.",
|
|
properties: {
|
|
name: {
|
|
type: "string",
|
|
description: "Custom name for this network.",
|
|
},
|
|
driver: {
|
|
type: "string",
|
|
description:
|
|
"Specify which driver should be used for this network. Default is 'bridge'.",
|
|
},
|
|
driver_opts: {
|
|
type: "object",
|
|
description:
|
|
"Specify driver-specific options defined as key/value pairs.",
|
|
patternProperties: {
|
|
"^.+$": {
|
|
type: ["string", "number"],
|
|
},
|
|
},
|
|
},
|
|
ipam: {
|
|
type: "object",
|
|
description:
|
|
"Custom IP Address Management configuration for this network.",
|
|
properties: {
|
|
driver: {
|
|
type: "string",
|
|
description: "Custom IPAM driver, instead of the default.",
|
|
},
|
|
config: {
|
|
type: "array",
|
|
description: "List of IPAM configuration blocks.",
|
|
items: {
|
|
type: "object",
|
|
properties: {
|
|
subnet: {
|
|
type: "string",
|
|
description:
|
|
"Subnet in CIDR format that represents a network segment.",
|
|
},
|
|
ip_range: {
|
|
type: "string",
|
|
description:
|
|
"Range of IPs from which to allocate container IPs.",
|
|
},
|
|
gateway: {
|
|
type: "string",
|
|
description: "IPv4 or IPv6 gateway for the subnet.",
|
|
},
|
|
aux_addresses: {
|
|
type: "object",
|
|
description:
|
|
"Auxiliary IPv4 or IPv6 addresses used by Network driver.",
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^.+$": {
|
|
type: "string",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
},
|
|
options: {
|
|
type: "object",
|
|
description: "Driver-specific options for the IPAM driver.",
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^.+$": {
|
|
type: "string",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
external: {
|
|
type: ["boolean", "string", "object"],
|
|
description:
|
|
"Specifies that this network already exists and was created outside of Compose.",
|
|
properties: {
|
|
name: {
|
|
deprecated: true,
|
|
type: "string",
|
|
description:
|
|
"Specifies the name of the external network. Deprecated: use the 'name' property instead.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
internal: {
|
|
type: ["boolean", "string"],
|
|
description: "Create an externally isolated network.",
|
|
},
|
|
enable_ipv4: {
|
|
type: ["boolean", "string"],
|
|
description: "Enable IPv4 networking.",
|
|
},
|
|
enable_ipv6: {
|
|
type: ["boolean", "string"],
|
|
description: "Enable IPv6 networking.",
|
|
},
|
|
attachable: {
|
|
type: ["boolean", "string"],
|
|
description:
|
|
"If true, standalone containers can attach to this network.",
|
|
},
|
|
labels: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description: "Add metadata to the network using labels.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
volume: {
|
|
type: ["object", "null"],
|
|
description: "Volume configuration for the Compose application.",
|
|
properties: {
|
|
name: {
|
|
type: "string",
|
|
description: "Custom name for this volume.",
|
|
},
|
|
driver: {
|
|
type: "string",
|
|
description:
|
|
"Specify which volume driver should be used for this volume.",
|
|
},
|
|
driver_opts: {
|
|
type: "object",
|
|
description: "Specify driver-specific options.",
|
|
patternProperties: {
|
|
"^.+$": {
|
|
type: ["string", "number"],
|
|
},
|
|
},
|
|
},
|
|
external: {
|
|
type: ["boolean", "string", "object"],
|
|
description:
|
|
"Specifies that this volume already exists and was created outside of Compose.",
|
|
properties: {
|
|
name: {
|
|
deprecated: true,
|
|
type: "string",
|
|
description:
|
|
"Specifies the name of the external volume. Deprecated: use the 'name' property instead.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
labels: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description: "Add metadata to the volume using labels.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
secret: {
|
|
type: "object",
|
|
description: "Secret configuration for the Compose application.",
|
|
properties: {
|
|
name: {
|
|
type: "string",
|
|
description: "Custom name for this secret.",
|
|
},
|
|
environment: {
|
|
type: "string",
|
|
description:
|
|
"Name of an environment variable from which to get the secret value.",
|
|
},
|
|
file: {
|
|
type: "string",
|
|
description: "Path to a file containing the secret value.",
|
|
},
|
|
external: {
|
|
type: ["boolean", "string", "object"],
|
|
description:
|
|
"Specifies that this secret already exists and was created outside of Compose.",
|
|
properties: {
|
|
name: {
|
|
type: "string",
|
|
description: "Specifies the name of the external secret.",
|
|
},
|
|
},
|
|
},
|
|
labels: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description: "Add metadata to the secret using labels.",
|
|
},
|
|
driver: {
|
|
type: "string",
|
|
description:
|
|
"Specify which secret driver should be used for this secret.",
|
|
},
|
|
driver_opts: {
|
|
type: "object",
|
|
description: "Specify driver-specific options.",
|
|
patternProperties: {
|
|
"^.+$": {
|
|
type: ["string", "number"],
|
|
},
|
|
},
|
|
},
|
|
template_driver: {
|
|
type: "string",
|
|
description: "Driver to use for templating the secret's value.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
config: {
|
|
type: "object",
|
|
description: "Config configuration for the Compose application.",
|
|
properties: {
|
|
name: {
|
|
type: "string",
|
|
description: "Custom name for this config.",
|
|
},
|
|
content: {
|
|
type: "string",
|
|
description: "Inline content of the config.",
|
|
},
|
|
environment: {
|
|
type: "string",
|
|
description:
|
|
"Name of an environment variable from which to get the config value.",
|
|
},
|
|
file: {
|
|
type: "string",
|
|
description: "Path to a file containing the config value.",
|
|
},
|
|
external: {
|
|
type: ["boolean", "string", "object"],
|
|
description:
|
|
"Specifies that this config already exists and was created outside of Compose.",
|
|
properties: {
|
|
name: {
|
|
deprecated: true,
|
|
type: "string",
|
|
description:
|
|
"Specifies the name of the external config. Deprecated: use the 'name' property instead.",
|
|
},
|
|
},
|
|
},
|
|
labels: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description: "Add metadata to the config using labels.",
|
|
},
|
|
template_driver: {
|
|
type: "string",
|
|
description: "Driver to use for templating the config's value.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
model: {
|
|
type: "object",
|
|
description: "Language Model for the Compose application.",
|
|
properties: {
|
|
name: {
|
|
type: "string",
|
|
description: "Custom name for this model.",
|
|
},
|
|
model: {
|
|
type: "string",
|
|
description: "Language Model to run.",
|
|
},
|
|
context_size: {
|
|
type: "integer",
|
|
},
|
|
runtime_flags: {
|
|
type: "array",
|
|
items: {
|
|
type: "string",
|
|
},
|
|
description: "Raw runtime flags to pass to the inference engine.",
|
|
},
|
|
},
|
|
required: ["model"],
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
command: {
|
|
oneOf: [
|
|
{
|
|
type: "null",
|
|
description:
|
|
"No command specified, use the container's default command.",
|
|
},
|
|
{
|
|
type: "string",
|
|
description:
|
|
"Command as a string, which will be executed in a shell (e.g., '/bin/sh -c').",
|
|
},
|
|
{
|
|
type: "array",
|
|
description:
|
|
"Command as an array of strings, which will be executed directly without a shell.",
|
|
items: {
|
|
type: "string",
|
|
description: "Part of the command (executable or argument).",
|
|
},
|
|
},
|
|
],
|
|
description:
|
|
"Command to run in the container, which can be specified as a string (shell form) or array (exec form).",
|
|
},
|
|
service_hook: {
|
|
type: "object",
|
|
description:
|
|
"Configuration for service lifecycle hooks, which are commands executed at specific points in a container's lifecycle.",
|
|
properties: {
|
|
command: {
|
|
$ref: "#/$defs/command",
|
|
description: "Command to execute as part of the hook.",
|
|
},
|
|
user: {
|
|
type: "string",
|
|
description: "User to run the command as.",
|
|
},
|
|
privileged: {
|
|
type: ["boolean", "string"],
|
|
description: "Whether to run the command with extended privileges.",
|
|
},
|
|
working_dir: {
|
|
type: "string",
|
|
description: "Working directory for the command.",
|
|
},
|
|
environment: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description: "Environment variables for the command.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
required: ["command"],
|
|
},
|
|
pre_start_hook: {
|
|
type: "object",
|
|
description:
|
|
"Configuration for a pre_start init container, run to completion before the service container starts.",
|
|
properties: {
|
|
command: {
|
|
$ref: "#/$defs/command",
|
|
description:
|
|
"Command to execute. Optional when the chosen image's entrypoint already runs the intended command.",
|
|
},
|
|
image: {
|
|
type: "string",
|
|
description:
|
|
"Image used for the ephemeral container. If omitted, the parent service's image is used.",
|
|
},
|
|
user: {
|
|
type: "string",
|
|
description:
|
|
"User to run the command as. Defaults to the user declared in image (or to the service's user when image is omitted).",
|
|
},
|
|
privileged: {
|
|
type: ["boolean", "string"],
|
|
description: "Whether to run the command with extended privileges.",
|
|
},
|
|
working_dir: {
|
|
type: "string",
|
|
description:
|
|
"Working directory for the command. Defaults to the service's working directory.",
|
|
},
|
|
environment: {
|
|
$ref: "#/$defs/list_or_dict",
|
|
description:
|
|
"Environment variables for the command. Appended to or overriding the service environment.",
|
|
},
|
|
per_replica: {
|
|
type: ["boolean", "string"],
|
|
description:
|
|
"Whether the hook runs once per service replica (true), or once for the service as a whole before any replica starts (false, the default).",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
env_file: {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
description: "Path to a file containing environment variables.",
|
|
},
|
|
{
|
|
type: "array",
|
|
description:
|
|
"List of paths to files containing environment variables.",
|
|
items: {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
description: "Path to a file containing environment variables.",
|
|
},
|
|
{
|
|
type: "object",
|
|
description: "Detailed configuration for an environment file.",
|
|
additionalProperties: false,
|
|
properties: {
|
|
path: {
|
|
type: "string",
|
|
description: "Path to the environment file.",
|
|
},
|
|
format: {
|
|
type: "string",
|
|
description:
|
|
"Format attribute lets you to use an alternative file formats for env_file. When not set, env_file is parsed according to Compose rules.",
|
|
},
|
|
required: {
|
|
type: ["boolean", "string"],
|
|
default: true,
|
|
description:
|
|
"Whether the file is required. If true and the file doesn't exist, an error will be raised.",
|
|
},
|
|
},
|
|
required: ["path"],
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
label_file: {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
description: "Path to a file containing Docker labels.",
|
|
},
|
|
{
|
|
type: "array",
|
|
description: "List of paths to files containing Docker labels.",
|
|
items: {
|
|
type: "string",
|
|
description: "Path to a file containing Docker labels.",
|
|
},
|
|
},
|
|
],
|
|
},
|
|
string_or_list: {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
description: "A single string value.",
|
|
},
|
|
{
|
|
$ref: "#/$defs/list_of_strings",
|
|
description: "A list of string values.",
|
|
},
|
|
],
|
|
description: "Either a single string or a list of strings.",
|
|
},
|
|
list_of_strings: {
|
|
type: "array",
|
|
description: "A list of unique string values.",
|
|
items: {
|
|
type: "string",
|
|
description: "A string value in the list.",
|
|
},
|
|
uniqueItems: true,
|
|
},
|
|
list_or_dict: {
|
|
oneOf: [
|
|
{
|
|
type: "object",
|
|
description: "A dictionary mapping keys to values.",
|
|
patternProperties: {
|
|
".+": {
|
|
type: ["string", "number", "boolean", "null"],
|
|
description:
|
|
"Value for the key, which can be a string, number, boolean, or null.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
{
|
|
type: "array",
|
|
description: "A list of unique string values.",
|
|
items: {
|
|
type: "string",
|
|
description: "A string value in the list.",
|
|
},
|
|
uniqueItems: true,
|
|
},
|
|
],
|
|
description:
|
|
"Either a dictionary mapping keys to values, or a list of strings.",
|
|
},
|
|
extra_hosts: {
|
|
oneOf: [
|
|
{
|
|
type: "object",
|
|
description: "list mapping hostnames to IP addresses.",
|
|
patternProperties: {
|
|
".+": {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
description: "IP address for the hostname.",
|
|
},
|
|
{
|
|
type: "array",
|
|
description: "List of IP addresses for the hostname.",
|
|
items: {
|
|
type: "string",
|
|
description: "IP address for the hostname.",
|
|
},
|
|
uniqueItems: false,
|
|
},
|
|
],
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
{
|
|
type: "array",
|
|
description: "List of host:IP mappings in the format 'hostname:IP'.",
|
|
items: {
|
|
type: "string",
|
|
description: "Host:IP mapping in the format 'hostname:IP'.",
|
|
},
|
|
uniqueItems: true,
|
|
},
|
|
],
|
|
description:
|
|
"Additional hostnames to be defined in the container's /etc/hosts file.",
|
|
},
|
|
blkio_limit: {
|
|
type: "object",
|
|
description: "Block IO limit for a specific device.",
|
|
properties: {
|
|
path: {
|
|
type: "string",
|
|
description: "Path to the device (e.g., '/dev/sda').",
|
|
},
|
|
rate: {
|
|
type: ["integer", "string"],
|
|
description:
|
|
"Rate limit in bytes per second or IO operations per second.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
blkio_weight: {
|
|
type: "object",
|
|
description: "Block IO weight for a specific device.",
|
|
properties: {
|
|
path: {
|
|
type: "string",
|
|
description: "Path to the device (e.g., '/dev/sda').",
|
|
},
|
|
weight: {
|
|
type: ["integer", "string"],
|
|
description: "Relative weight for the device, between 10 and 1000.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
service_config_or_secret: {
|
|
type: "array",
|
|
description:
|
|
"Configuration for service configs or secrets, defining how they are mounted in the container.",
|
|
items: {
|
|
oneOf: [
|
|
{
|
|
type: "string",
|
|
description: "Name of the config or secret to grant access to.",
|
|
},
|
|
{
|
|
type: "object",
|
|
description: "Detailed configuration for a config or secret.",
|
|
properties: {
|
|
source: {
|
|
type: "string",
|
|
description:
|
|
"Name of the config or secret as defined in the top-level configs or secrets section.",
|
|
},
|
|
target: {
|
|
type: "string",
|
|
description:
|
|
"Path in the container where the config or secret will be mounted. Defaults to /<source> for configs and /run/secrets/<source> for secrets.",
|
|
},
|
|
uid: {
|
|
type: "string",
|
|
description:
|
|
"UID of the file in the container. Default is 0 (root).",
|
|
},
|
|
gid: {
|
|
type: "string",
|
|
description:
|
|
"GID of the file in the container. Default is 0 (root).",
|
|
},
|
|
mode: {
|
|
type: ["number", "string"],
|
|
description:
|
|
"File permission mode inside the container, in octal. Default is 0444 for configs and 0400 for secrets.",
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
ulimits: {
|
|
type: "object",
|
|
description:
|
|
"Container ulimit options, controlling resource limits for processes inside the container.",
|
|
patternProperties: {
|
|
"^[a-z]+$": {
|
|
oneOf: [
|
|
{
|
|
type: ["integer", "string"],
|
|
description: "Single value for both soft and hard limits.",
|
|
},
|
|
{
|
|
type: "object",
|
|
description: "Separate soft and hard limits.",
|
|
properties: {
|
|
hard: {
|
|
type: ["integer", "string"],
|
|
description:
|
|
"Hard limit for the ulimit type. This is the maximum allowed value.",
|
|
},
|
|
soft: {
|
|
type: ["integer", "string"],
|
|
description:
|
|
"Soft limit for the ulimit type. This is the value that's actually enforced.",
|
|
},
|
|
},
|
|
required: ["soft", "hard"],
|
|
additionalProperties: false,
|
|
patternProperties: {
|
|
"^x-": {},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
},
|
|
} as const;
|