delonix container

Ciclo de vida de containers: run, ps, start, stop, rm, exec, logs, inspect, stats, apply.

Container lifecycle: run, ps, start, stop, rm, exec, logs, inspect, stats, apply.

O grupo container é o dia a dia do runtime — o homólogo do docker container. Cada invocação é um processo efémero (sem daemon): o run faz clone() directo com os namespaces pedidos e o estado fica em JSON no $DELONIX_ROOT. Em rootless, o rootfs do container é uma cópia flat persistente — as escritas sobrevivem a stop/start, como no Docker.

The container group is the runtime's everyday surface — the counterpart to docker container. Each invocation is an ephemeral process (no daemon): run does a direct clone() with the requested namespaces and the state lands as JSON under $DELONIX_ROOT. In rootless mode, a container's rootfs is a persistent flat copy — writes survive stop/start, just like in Docker.

📄 Implementação real em Rust: cmd/container.rs

Usage: dlx container [OPTIONS] <COMMAND>

Commands:
  dash         Dashboard (KPIs + table + problems) of the containers — interactive TUI, or `--once` for a text snapshot
  init         Initialize a project with a Delonixfile + manifest — files ALREADY FILLED IN (images included), ready to use without editing anything
  run          Run a container from an image (pulls it if missing)
  ps           List containers [alias: ls]
  start        (Re)start stopped/crashed containers, reusing the persistent rootfs (writes made inside the container survive, like in docker) and the same network/ports/volumes as the original `run`. Always detached
  stop         Stop one or more containers (SIGTERM, then SIGKILL)
  kill         Send a signal to one or more containers (default SIGKILL) — unlike `stop`, does not wait or force a `Stopped` status: the real outcome (e.g. `Crashed` for a `KILL`) is picked up on the next observation
  wait         Block until one or more containers exit, then print their exit code (one per line, in the order given)
  restart      Stop then start one or more containers (reuses the persistent rootfs and the original run configuration, like `start`)
  rename       Give a container a new name
  port         Published ports of a container (`hostPort/proto -> containerPort`)
  rm           Remove one or more containers
  pause        Suspend a container's processes (cgroup v2 freezer) — the state stays in memory, unlike `stop`. Resume with `unpause`
  unpause      Resume a container suspended with `pause`
  commit       Create an image from a container's CURRENT rootfs state (whatever was written inside becomes a new layer)
  ssh          Interactive shell inside a container (shortcut for `exec -t`): with no command, it tries `bash` and falls back to `sh`, which exists in any image
  healthcheck  Run the image's `HEALTHCHECK` inside the container. Exits with 1 if `unhealthy` — usable in a script/CI
  top          Processes running inside a container (read from `cgroup.procs`)
  diff         Files changed relative to the image: `A` = created/changed, `D` = deleted
  cp           Copy files between the host and a container. Exactly one side is `container:/path` (e.g. `delonix container cp web:/etc/nginx.conf .`)
  exec         Execute a command inside a running container
  inspect      Show the full spec of one or more containers (Store JSON)
  describe     Human-readable detail of one or more containers, `kubectl describe`-style (for humans; use `inspect` for script-consumable JSON)
  update       **Reconfigure a RUNNING container without stopping it** — ports, volumes, networks, and bandwidth cap
  stats        Resource usage (CPU/memory/PIDs) of the running containers — one sample and exits (no stream). With no IDs, shows all running ones
  logs         Show the logs (detached containers)
  attach       Re-attach to a running container's output stream (same log file `logs -f` reads). Unlike `docker attach`, this is OUTPUT-ONLY: a detached container's stdin has nowhere to go (this engine keeps no live conduit to it once started, unlike a persistent per-container shim) — `-i`/`--stdin` is refused with a clear error instead of silently doing nothing
  apply        Apply the `kind: Container` documents of a manifest (idempotent by name — an existing container with that name is neither recreated nor checked for spec drift, see `cmd::manifest`)
  help         Print this message or the help of the given subcommand(s)

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

`container dash`

Dashboard (KPIs + table + problems) of the containers — interactive TUI, or --once for a text snapshot

Usage: dlx container dash [OPTIONS]

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
      --once          
      --json          
  -h, --help          Print help

Exemplos

Dashboard só dos containers

delonix container dash

`container run`

Run a container from an image (pulls it if missing)

Usage: dlx container run [OPTIONS] <IMAGE> [COMMAND]...

Arguments:
  <IMAGE>       Image (e.g. `alpine:3.19`)
  [COMMAND]...  Command + arguments (default: the image's ENTRYPOINT/CMD)

Options:
  -d, --detach
          Run in the background and print the ID
      --l18n <en|pt>
          Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
      --name <NAME>
          Container name (default: `dlx-<id>`)
      --hostname <HOSTNAME>
          Hostname inside the container (UTS namespace + `/etc/hostname`). Default: the container name (docker `--hostname`)
  -u, --user <USER>
          Run the process as this user: `uid[:gid]` or `name[:group]` (docker `--user`). Names are resolved in the image's `/etc/passwd`/`/etc/group`
      --net <NET>
          Network: `host` (shares the host's, default), `none` (isolated netns with no connectivity), or the NAME of a network created with `delonix network create` [default: host]
      --namespace <NAMESPACE>
          Logical ISOLATION namespace (default `default`). Containers in different namespaces cannot reach each other (even on the same network); only a `kind: Dependency` crosses the boundary
      --expose <EXPOSE>
          Auto-register this container's HTTP port in the L7 proxy under its internal FQDN `<name>.<namespace>.delonix.internal` (reachable via the proxy). Needs `--net <network>`. Removed automatically on `container rm`
  -v, --volume <VOLUMES>
          Volume/bind mount, `name:/target[:ro]` or `/host:/target[:ro]`. Repeatable
  -p, --publish <PUBLISH>
          Publish a port, `[hostIp:]hostPort:contPort[/tcp|udp]` or just `port`. Repeatable. SAFE BY DEFAULT: without `hostIp` the port binds to `127.0.0.1` only — reachable from the host itself, NOT from a browser on another machine. Name the address to widen it: `0.0.0.0:8080:80` (every interface), `192.168.1.10:8080:80` (one), or the libvirt gateway to reach it from VMs (see `delonix vm reach`). With `--net host` (the default) the container moves to its own netns with userspace NAT (slirp4netns, like rootless podman); with `--net <network>` it publishes via the ingress (nft DNAT + hostfwd on the single slirp)
      --privileged
          Privileged container (all caps, seccomp off) — trusted workloads
      --entrypoint <ENTRYPOINT>
          Override the image's ENTRYPOINT (COMMAND becomes the arguments to this binary; `--entrypoint ""` clears it and runs just the COMMAND)
  -w, --workdir <WORKDIR>
          Working directory the container's process starts in (default: the image's own configured workdir, or `/`). Persists in the record — an `exec -w` overrides it for that one call only
      --rm
          Remove the container when the process exits (with `-d`, a detached watcher handles removal when the container dies)
      --restart <RESTART>
          Restart policy (only with `-d`): `no` (default), `on-failure[:max]`, `always`, `unless-stopped`. A detached supervisor (one per container, ephemeral — there's no daemon) becomes the container's parent, captures the real exit code, and restarts it according to the policy [default: no]
      --device <DEVICES>
          Attach a host device, `/dev/x[:/dev/y]`. Repeatable. The container's `/dev` is a tmpfs with a curated list (null/zero/tty/...); this adds real host nodes to it, like `docker --device`
  -e, --env <ENV>
          Additional environment variables (`KEY=VAL`), repeatable
      --label <LABELS>
          Label (`KEY=VAL`), repeatable — e.g. `io.x-k8s.kind.role=control-plane` enables the dedicated cgroup2 delegation for Kind nodes (see `setup_node_cgroup_ns`)
  -m, --memory <MEMORY>
          Memory limit (`64M`, `2G`, `max`). Default: `max` (no cap)
  -c, --cpus <CPUS>
          CPU quota (number of cores, e.g. `0.5`, `2`). Default: `1.0`
      --cpu-weight <CPU_WEIGHT>
          Relative CPU weight (`cpu.weight`, 1–10000) under contention
      --cpuset <CPUSET>
          CPUs the container is pinned to (`cpuset.cpus`, e.g. `0-3`, `0,2`)
      --io-weight <IO_WEIGHT>
          Relative I/O weight (`io.weight`, 1–10000)
      --device-read-bps <DEVICE_READ_BPS>
          Absolute read limit from the store's disk (`10mb`, `1g`). Docker's `--device-read-bps`
      --device-write-bps <DEVICE_WRITE_BPS>
          Absolute write limit to the store's disk (`10mb`, `1g`). Docker's `--device-write-bps`
      --device-read-iops <DEVICE_READ_IOPS>
          Absolute read IOPS limit from the store's disk
      --device-write-iops <DEVICE_WRITE_IOPS>
          Absolute write IOPS limit to the store's disk
      --read-only
          Read-only rootfs (writes go to tmpfs/volumes)
      --cap-add <CAP_ADD>
          Add a capability (e.g. `NET_ADMIN`). Repeatable
      --cap-drop <CAP_DROP>
          Drop a capability. Repeatable
      --security-opt <SECURITY_OPT>
          Security options (docker-style), repeatable: `seccomp=unconfined` | `seccomp=<profile.json>` (OCI/runc format) | `apparmor=<profile>` | `no-new-privileges[=true|false]` (default true, stricter than docker/podman)
      --apparmor <APPARMOR>
          AppArmor profile to apply (`unconfined`, `delonix-default`, or an already-loaded name). `delonix-default` is loaded automatically
      --selinux <SELINUX>
          SELinux context/profile to apply
      --userns
          User namespace: enables the subuid mapping (default in rootless)
      --no-userns
          Disable the automatic activation of the user namespace
      --host-pid
          Share the host's PID namespace (`--pid host`)
      --host-ipc
          Share the host's IPC namespace
      --detect
          Detection mode: seccomp in log mode (doesn't block), to discover syscalls
      --secret <SECRET>
          Inject a secret from the vault (`name`), as an environment variable. Repeatable. With `--secret-files`, it goes to `/run/secrets/<name>`
      --secret-files
          The `--secret`s come in as files in `/run/secrets/` (tmpfs), not env
      --env-file <ENV_FILE>
          Load variables from a `.env` file (`KEY=VAL` per line). Repeatable
      --tmpfs <TMPFS>
          Mount a tmpfs (`/path[:options]`). Repeatable
      --ulimit <ULIMIT>
          Ulimit (`nofile=1024:2048`). Repeatable
      --dns <DNS>
          DNS server for the container's `/etc/resolv.conf`. Repeatable. Overrides the resolver the engine would pick (network gateway, slirp, or the host's copy)
      --dns-search <DNS_SEARCH>
          DNS search domain. Repeatable
      --dns-option <DNS_OPTION>
          `resolv.conf` option (`ndots:2`, `timeout:1`). Repeatable
      --group-add <GROUP_ADD>
          Supplementary group id for the process (`--group-add 1234`). Repeatable. Applied even when the container runs as root — a root process still needs a group to reach a mounted share
      --masked-path <MASKED_PATH>
          Make a path unreadable inside the container (`--masked-path /proc/kcore`). Repeatable. A file is covered with `/dev/null`, a directory with an empty read-only tmpfs
      --readonly-path <READONLY_PATH>
          Remount a path read-only inside the container (`--readonly-path /proc/sys`). Repeatable
      --sysctl <SYSCTL>
          Container sysctl (`net.core.somaxconn=1024`). Repeatable
      --gpus <GPUS>
          Expose GPUs: `all` | `nvidia` | `dri` (expands to the `/dev` nodes)
      --ip <IP>
          Fixed IP on the network (`--net <network>`), e.g. `10.89.0.10`
      --network-alias <NETWORK_ALIAS>
          The container's DNS alias on the network. Repeatable
      --add-host <ADD_HOST>
          Extra `/etc/hosts` entry, `name:ip` (as Docker/Podman). Repeatable. PERSISTED: survives `stop`/`start` and `restart`, which rewrite `/etc/hosts` from scratch
      --wait
          With `-d`, block until the image's `HEALTHCHECK` passes (or the timeout elapses). Replaces the `until curl ...; do sleep; done` that every script ends up writing. No `HEALTHCHECK` in the image is a clear error, never a silent instant return
      --wait-timeout <WAIT_TIMEOUT>
          How long `--wait` waits before giving up (seconds) [default: 60]
      --health-cmd <HEALTH_CMD>
          Probe command, run with `/bin/sh -c` inside the container. Without it, the image's own `HEALTHCHECK` is monitored; any other `--health-*` flag turns monitoring on for an image that has one
      --health-interval <HEALTH_INTERVAL>
          Seconds between probes [default: 30]
      --health-timeout <HEALTH_TIMEOUT>
          A probe that runs longer than this counts as a failure. The probe kills ITSELF (the wrapper is `sh`), so nothing is left stuck inside the container [default: 30]
      --health-retries <HEALTH_RETRIES>
          Consecutive failures before the container is `unhealthy` [default: 3]
      --health-start-period <HEALTH_START_PERIOD>
          Grace at startup: failures inside this window do not count, and the container reads `starting` rather than `unhealthy` [default: 0]
      --knows <KNOWS>
          Restrict DNS resolution to these containers (isolation). Repeatable
      --knows-none
          The container resolves NO other container by name
      --pod <POD>
          Join a pod's netns (`--net <network>`), sharing IP/ports
      --net-bps <NET_BPS>
          Egress bandwidth cap (`10mbit`, `512kbit`). Only with `--net <network>`
      --net-burst <NET_BURST>
          Burst for the bandwidth cap. Only with `--net-bps`
      --log-driver <LOG_DRIVER>
          Log driver (`json`, `cri`, ...)
      --log-file <LOG_FILE>
          Log file path (overrides the default)
      --log-cri
          CRI format in the log file (for the kubelet/`crictl logs`)
  -h, --help
          Print help

-p e a rede: com --net host (o default) o container muda para um netns próprio com NAT em userspace (slirp4netns — o modelo do podman rootless); com --net <rede> a porta é publicada pelo ingress (hostfwd no slirp único + DNAT nft), o caminho que permite trocar portas a quente sem parar o container. --net none recusa -p.

Exemplos

Servir nginx na porta 8080 do host (NAT userspace, sem root)

delonix container run -d --name web -p 8080:80 nginx

Correr numa rede criada pelo utilizador, publicando pelo ingress

delonix network create minha-rede
delonix container run -d --net minha-rede -p 8443:443 caddy

Shell descartável (remove-se sozinho à saída)

delonix container run --rm -e TERM=xterm alpine sh -c 'echo olá'

Sobrepor o ENTRYPOINT para depurar uma imagem

delonix container run --rm --entrypoint /bin/sh nginx -c 'nginx -t'

`container ps`

List containers

Usage: dlx container ps [OPTIONS]

Options:
  -a, --all              Include stopped/failed ones
      --l18n <en|pt>     Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -q, --quiet            Print only the IDs (to compose with `stop`/`rm`)
  -o, --output <OUTPUT>  Output format: `table` (default) or `json` (ADR-0005). `json` honors `--all` (same filter as the table) and ignores `--quiet` [default: table] [possible values: table, json]
  -h, --help             Print help

Exemplos

Listar (alias `ls` também funciona)

delonix container ls -a

Compor com stop/rm

delonix container rm -f $(delonix container ps -aq)

`container start`

(Re)start stopped/crashed containers, reusing the persistent rootfs (writes made inside the container survive, like in docker) and the same network/ports/volumes as the original run. Always detached

Usage: dlx container start [OPTIONS] <IDS>...

Arguments:
  <IDS>...  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Reusa a spec guardada (comando, env, volumes, rede, portas) e o rootfs persistente — ao contrário de rm+run, nada do que o container escreveu se perde.

Exemplos

Rearrancar um container parado, preservando o que foi escrito lá dentro

delonix container start web

`container stop`

Stop one or more containers (SIGTERM, then SIGKILL)

Usage: dlx container stop [OPTIONS] <IDS>...

Arguments:
  <IDS>...  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -t, --time <TIME>   Seconds until SIGKILL [default: 10]
  -h, --help          Print help

Exemplos

SIGTERM, e SIGKILL ao fim de 5s

delonix container stop -t 5 web db

`container rm`

Remove one or more containers

Usage: dlx container rm [OPTIONS] <IDS>...

Arguments:
  <IDS>...  

Options:
  -f, --force         Force (kill it if running)
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

Forçar remoção de vários

delonix container rm -f web db cache

`container exec`

Execute a command inside a running container

Usage: dlx container exec [OPTIONS] <ID> <COMMAND>...

Arguments:
  <ID>          
  <COMMAND>...  

Options:
  -i, --interactive        Interactive (attaches stdin)
      --l18n <en|pt>       Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -t, --tty                Allocate a pseudo-terminal
  -e, --env <ENV>          Extra environment variable (`KEY=VAL`) for this call only, on top of the container's own env. Repeatable
  -w, --workdir <WORKDIR>  Working directory for this call only (default: the container's own configured `workdir`, or `/`)
  -u, --user <USER>        Run as this user for this call only: `uid[:gid]` or `name[:group]` (resolved against the container's own `/etc/passwd`/`/etc/group`). Default: the container's own configured user
  -h, --help               Print help

Exemplos

Shell interactiva

delonix container exec -it web sh

`container logs`

Show the logs (detached containers)

Usage: dlx container logs [OPTIONS] <ID>

Arguments:
  <ID>  

Options:
  -f, --follow         Follow the log continuously (exits when the container stops)
      --l18n <en|pt>   Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
      --tail <TAIL>    Show only the last N lines. Requires the container to have been run with `--log-cri` (per-line timestamps needed to find "the last N" — see `--timestamps`'s doc for why)
      --since <SINCE>  Show only lines at or after this Unix timestamp (seconds). Same `--log-cri` requirement as `--tail`
      --timestamps     Prefix each line with its RFC3339 timestamp. Only available for containers run with `--log-cri` (`container run --log-cri`) — the plain log format is raw bytes with no per-line timestamp to show; a container without it gets a clear error naming the flag, not a silently-blank column
  -h, --help           Print help

Exemplos

Seguir em contínuo (sai quando o container parar)

delonix container logs -f web

`container inspect`

Show the full spec of one or more containers (Store JSON)

Usage: dlx container inspect [OPTIONS] <IDS>...

Arguments:
  <IDS>...  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

Spec completa em JSON

delonix container inspect web | jq .[0].ports

`container stats`

Resource usage (CPU/memory/PIDs) of the running containers — one sample and exits (no stream). With no IDs, shows all running ones

Usage: dlx container stats [OPTIONS] [IDS]...

Arguments:
  [IDS]...  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

CPU%/memória/PIDs lidos do cgroup v2 do próprio container (resolvido por /proc/<pid>/cgroup, qualquer que seja a base delegada). Sem delegação de cgroup (rootless sem Delegate=yes), a memória cai para o VmRSS do init do container, marcada com ~.

Exemplos

Uma amostra de todos os que correm

delonix container stats

`container apply`

Apply the kind: Container documents of a manifest (idempotent by name — an existing container with that name is neither recreated nor checked for spec drift, see cmd::manifest)

Usage: dlx container apply [OPTIONS]

Options:
  -f, --file <FILE>   
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

Aplicar só os `kind: Container` de um manifesto

delonix container apply -f delonix-manifest.yaml

`container init`

Initialize a project with a Delonixfile + manifest — files ALREADY FILLED IN (images included), ready to use without editing anything

Usage: dlx container init [OPTIONS] [DIR]

Arguments:
  [DIR]  Project directory (default: the current one) [default: .]

Options:
      --l18n <en|pt>         Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
      --name <NAME>          Project name (default: the directory name)
      --image <IMAGE>        Image to use. Omit = fill in with the default image
      --force                Overwrite existing files
  -t, --template <TEMPLATE>  Generate a complete PROJECT for a stack (e.g. `python`) with best practices, instead of the generic scaffold. `--template list` shows the available ones
      --up                   After generating, build the image, start it, and wait until it's healthy
  -h, --help                 Print help

Exemplos

Scaffold de um projecto completo, pronto a usar

delonix container init myapp && cd myapp

`container kill`

Send a signal to one or more containers (default SIGKILL) — unlike stop, does not wait or force a Stopped status: the real outcome (e.g. Crashed for a KILL) is picked up on the next observation

Usage: dlx container kill [OPTIONS] <IDS>...

Arguments:
  <IDS>...  

Options:
      --l18n <en|pt>     Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -s, --signal <SIGNAL>  Signal name (`KILL`, `SIGKILL`, case-insensitive, `SIG` prefix optional) or number (`9`) [default: KILL]
  -h, --help             Print help

Ao contrário de stop, não espera nem força o estado — o resultado real (ex.: Crashed para um KILL) só se confirma na observação seguinte.

Exemplos

Sinal arbitrário, sem forçar `Stopped`

delonix container kill -s USR1 web

`container wait`

Block until one or more containers exit, then print their exit code (one per line, in the order given)

Usage: dlx container wait [OPTIONS] <IDS>...

Arguments:
  <IDS>...  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

O exit code real só é garantido quando um supervisor --restart é o pai real do processo — um container -d simples sem supervisor mostra Crashed/137, limite arquitectural conhecido (o motor não é o pai real desse processo).

Exemplos

Bloqueia até sair, imprime o exit code

delonix container wait web

`container restart`

Stop then start one or more containers (reuses the persistent rootfs and the original run configuration, like start)

Usage: dlx container restart [OPTIONS] <IDS>...

Arguments:
  <IDS>...  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -t, --time <TIME>   Seconds until SIGKILL, for the `stop` half [default: 10]
  -h, --help          Print help

Exemplos

Pára e arranca de novo, mesma configuração

delonix container restart web

`container rename`

Give a container a new name

Usage: dlx container rename [OPTIONS] <ID> <NEW_NAME>

Arguments:
  <ID>        
  <NEW_NAME>  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

delonix container rename web frontend

`container port`

Published ports of a container (hostPort/proto -> containerPort)

Usage: dlx container port [OPTIONS] <ID>

Arguments:
  <ID>  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

Portas publicadas deste container

delonix container port web

`container pause`

Suspend a container's processes (cgroup v2 freezer) — the state stays in memory, unlike stop. Resume with unpause

Usage: dlx container pause [OPTIONS] <IDS>...

Arguments:
  <IDS>...  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

Suspende os processos (cgroup v2 freezer)

delonix container pause web

`container unpause`

Resume a container suspended with pause

Usage: dlx container unpause [OPTIONS] <IDS>...

Arguments:
  <IDS>...  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

Resume um container suspenso

delonix container unpause web

`container commit`

Create an image from a container's CURRENT rootfs state (whatever was written inside becomes a new layer)

Usage: dlx container commit [OPTIONS] <ID> <TAG>

Arguments:
  <ID>   
  <TAG>  Tag for the new image (e.g. `app:v2`)

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

Cria uma imagem a partir do rootfs actual do container

delonix container commit web minha-app:debug

`container ssh`

Interactive shell inside a container (shortcut for exec -t): with no command, it tries bash and falls back to sh, which exists in any image

Usage: dlx container ssh [OPTIONS] <ID> [COMMAND]...

Arguments:
  <ID>          
  [COMMAND]...  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

Atalho para `exec -t` — tenta bash, cai para sh

delonix container ssh web

`container healthcheck`

Run the image's HEALTHCHECK inside the container. Exits with 1 if unhealthy — usable in a script/CI

Usage: dlx container healthcheck [OPTIONS] <ID>

Arguments:
  <ID>  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

Corre o HEALTHCHECK da imagem, exit 1 se unhealthy (usável em CI)

delonix container healthcheck web

`container top`

Processes running inside a container (read from cgroup.procs)

Usage: dlx container top [OPTIONS] <ID>

Arguments:
  <ID>  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

Processos a correr dentro do container

delonix container top web

`container diff`

Files changed relative to the image: A = created/changed, D = deleted

Usage: dlx container diff [OPTIONS] <ID>

Arguments:
  <ID>  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

Ficheiros alterados relativos à imagem (A/D)

delonix container diff web

`container cp`

Copy files between the host and a container. Exactly one side is container:/path (e.g. delonix container cp web:/etc/nginx.conf .)

Usage: dlx container cp [OPTIONS] <SRC> <DST>

Arguments:
  <SRC>  
  <DST>  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

Do container para o host

delonix container cp web:/etc/nginx.conf .

Do host para o container

delonix container cp ./nginx.conf web:/etc/nginx.conf

`container describe`

Human-readable detail of one or more containers, kubectl describe-style (for humans; use inspect for script-consumable JSON)

Usage: dlx container describe [OPTIONS] <IDS>...

Arguments:
  <IDS>...  

Options:
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Exemplos

Detalhe estilo `kubectl describe` (para humanos; `inspect` é para scripts)

delonix container describe web

`container update`

Reconfigure a RUNNING container without stopping it — ports, volumes, networks, and bandwidth cap.

Unlike docker (where changing a port or a volume forces recreating the container), here the dataplane doesn't belong to the process lifecycle: ports are DNAT/hostfwd in front of the network and volumes come in through the kernel's mount API (open_tree/move_mount) in the mount namespace of the already-live container. The PID doesn't change and the process is never interrupted.

The changes are persisted in the registry, so a later container start reproduces the new configuration, not the original.

Usage: dlx container update [OPTIONS] <ID>

Arguments:
  <ID>
          

Options:
      --l18n <en|pt>
          Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand

  -p, --publish-add <SPEC>
          Publish one more port hot, `hostPort:contPort[/tcp|udp]`. Repeatable

      --publish-rm <HOST_PORT>
          Unpublish a port hot, by HOST PORT. Repeatable

  -v, --volume-add <SPEC>
          Mount a volume hot, `name:/target[:ro]` or `/host:/target[:ro]`. Repeatable

      --volume-rm <TARGET>
          Unmount hot, by the TARGET path inside the container. Repeatable

      --net-connect <NETWORK>
          Connect the container to an additional network hot (multi-homing). Repeatable

      --net-disconnect <NETWORK>
          Disconnect the container from an additional network. Repeatable

      --net-rate <RATE>
          Bandwidth cap, in bit/s with a suffix (`10mbit`, `512kbit`, `1gbit`)

      --net-burst <BURST>
          Burst for the bandwidth cap (default: `32kb`). Only with `--net-rate`

      --net-rate-clear
          Remove the bandwidth cap

  -m, --memory <MEMORY>
          New memory limit hot (`64M`, `2G`, `max`)

  -c, --cpus <CPUS>
          New CPU quota hot (number of cores, e.g. `0.5`, `2`)

  -h, --help
          Print help (see a summary with '-h')

Reconfigura portas, volumes, redes, limite de banda e limites de memória/CPU de um container a correr, sem o parar — o PID não muda. Remoções correm antes das adições, para --publish-rm 8080 --publish-add 8080:9000 funcionar num só comando. --memory/--cpus reescrevem o cgroup real de imediato (memory.max/cpu.max) — nada de esperar por um restart.

Exemplos

Troca uma porta a QUENTE, sem reiniciar

delonix container update web --publish-add 9090:80

Liga a uma rede nova + limite de banda

delonix container update web --net-connect backend --net-rate 10mbit

Sobe o limite de memória/CPU a QUENTE, sem reiniciar

delonix container update web --memory 512M --cpus 2

`container attach`

Re-attach to a running container's output stream (same log file logs -f reads). Unlike docker attach, this is OUTPUT-ONLY: a detached container's stdin has nowhere to go (this engine keeps no live conduit to it once started, unlike a persistent per-container shim) — -i/--stdin is refused with a clear error instead of silently doing nothing

Usage: dlx container attach [OPTIONS] <ID>

Arguments:
  <ID>  

Options:
  -i, --interactive   Refused: stdin forwarding isn't supported (see the command's own doc above)
      --l18n <en|pt>  Output language: `en` (default) or `pt` (Portuguese, pt_AO). Also settable via `$DELONIX_L18N`. Global — works before any subcommand
  -h, --help          Print help

Deliberadamente só output — ao contrário do docker attach, não há stdin ao vivo para um container já iniciado em detached (sem shim persistente por-container). -i/--stdin é recusado com um erro claro a apontar para exec -it.

Exemplos

Volta a ligar ao stream de output de um container detached

delonix container attach web

LaboratórioLab

Sobe um nginx publicado, confirma que responde, e prova que o estado sobrevive a um stop/start (ao contrário de recriar o container).

delonix container run -d --name web -p 8080:80 nginx
curl localhost:8080
delonix container logs web
delonix container stop web
delonix container start web
curl localhost:8080

Bring up a published nginx, confirm it answers, and prove the state survives a stop/start (unlike recreating the container).

delonix container run -d --name web -p 8080:80 nginx
curl localhost:8080
delonix container logs web
delonix container stop web
delonix container start web
curl localhost:8080

DesafioChallenge

Sem parar o web, troca a porta publicada a quente com container update (o PID não muda) e confirma com container diff que escrever um ficheiro dentro do container aparece na comparação com a imagem original.

delonix container update web --publish-rm 8080 --publish-add 9090:80
delonix container exec web sh -c 'echo oi > /tmp/marca'
delonix container diff web

Without stopping web, hot-swap the published port with container update (the PID doesn't change) and confirm with container diff that writing a file inside the container shows up against the original image.

delonix container update web --publish-rm 8080 --publish-add 9090:80
delonix container exec web sh -c 'echo hi > /tmp/mark'
delonix container diff web