# docker

**Descripción:** El comando base para la CLI de Docker.












## Descripción

Dependiendo de la configuración de tu sistema Docker, es posible que debas anteponer cada comando `docker` con `sudo`. To avoid having to use `sudo` with the
`docker` command, tu administrador del sistema puede crear un grupo de Unix llamado
`docker` y agregar usuarios a él.

Para obtener más información sobre la instalación de Docker o la configuración de `sudo`, consulta las instrucciones de
[instalación](/install/) para tu sistema operativo.

### Mostrar el texto de ayuda

Para ver la ayuda de cualquier comando, simplemente ejecútalo seguido de la
opción `--help`.

```console
$ docker run --help

Usage: docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

Create and run a new container from an image

Options:
      --add-host value             Add a custom host-to-IP mapping (host:ip) (default [])
  -a, --attach value               Attach to STDIN, STDOUT or STDERR (default [])
<...>
```

### Variables de entorno

Las siguientes variables de entorno controlan el comportamiento del cliente de línea de comandos `docker`:

| Variable | Descripción |
| :---------------------------- |:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `DOCKER_API_VERSION`          | Invalida la versión de la API negociada para usar en depuración (por ejemplo, `1.19`) |
| `DOCKER_CERT_PATH`            | Ubicación de tus claves de autenticación. Esta variable es utilizada tanto por la CLI de `docker` como por el demonio [`dockerd`](/reference/cli/dockerd/) |
| `DOCKER_CONFIG`               | La ubicación de los archivos de configuración de tu cliente. |
| `DOCKER_CONTEXT`              | Nombre del `docker context` a utilizar (invalida la variable de entorno `DOCKER_HOST` y el contexto predeterminado establecido con `docker context use`) |
| `DOCKER_CUSTOM_HEADERS`       | (Experimental) Configura [cabeceras HTTP personalizadas](#custom-http-headers) para ser enviadas por el cliente. Las cabeceras deben proporcionarse como una lista separada por comas de pares `nombre=valor`. Esto equivale al campo `HttpHeaders` en el archivo de configuración. |
| `DOCKER_DEFAULT_PLATFORM`     | Plataforma predeterminada para los comandos que aceptan la opción `--platform`. |
| `DOCKER_HIDE_LEGACY_COMMANDS` | Cuando se establece, Docker oculta los comandos de nivel superior "heredados" (como `docker rm` y `docker pull`) en la salida de `docker help`, y solo se imprimen los comandos de administración (`Management commands`) por tipo de objeto (por ejemplo, `docker container`). Esto podría convertirse en el comportamiento predeterminado en una versión futura. |
| `DOCKER_HOST`                 | Socket del demonio al que conectarse. |
| `DOCKER_TLS`                  | Habilita TLS para las conexiones realizadas por la CLI de `docker` (equivalente a la opción de línea de comandos `--tls`). Establécelo en un valor no vacío para habilitar TLS. Ten en cuenta que TLS se habilita automáticamente si se establece cualquiera de las otras opciones de TLS. |
| `DOCKER_TLS_VERIFY`           | Cuando se establece, Docker utiliza TLS y verifica el extremo remoto. Esta variable es utilizada tanto por la CLI de `docker` como por el demonio [`dockerd`](/reference/cli/dockerd/) |
| `BUILDKIT_PROGRESS`           | Establece el tipo de salida de progreso (`auto`, `plain`, `tty`, `rawjson`) al [construir](/reference/cli/docker/image/build/) con el [motor BuildKit](/build/buildkit/). Utiliza `plain` para mostrar la salida del contenedor (por defecto `auto`). |
| `NO_COLOR`                    | Desactiva los códigos de escape ANSI en la salida de acuerdo con https://no-color.org/ |

Dado que Docker está desarrollado con Go, también puedes utilizar cualquier variable de entorno utilizada por el entorno de ejecución de Go. En particular, te pueden resultar útiles las siguientes:

| Variable      | Descripción |
|:--------------|:-------------------------------------------------------------------------------|
| `HTTP_PROXY`  | URL del proxy para solicitudes HTTP a menos que sea invalidada por NoProxy. |
| `HTTPS_PROXY` | URL del proxy para solicitudes HTTPS a menos que sea invalidada por NoProxy. |
| `NO_PROXY`    | Valores separados por comas que especifican los hosts que deben excluirse del proxy. |

Consulta la [especificación de Go](https://pkg.go.dev/golang.org/x/net/http/httpproxy#Config) para obtener detalles sobre estas variables.

### Tipos de opciones

Las opciones de línea de comandos de un solo carácter se pueden combinar, por lo que en lugar de escribir `docker run -i -t --name test busybox sh`, puedes escribir `docker run -it --name test busybox sh`.

#### Booleanas

Las opciones booleanas adoptan la forma `-d=false`. El valor que ves en el texto de ayuda es el valor predeterminado que se establece si **no** especificas esa opción. Si especificas una opción booleana sin un valor, esta se establecerá en `true`, independientemente del valor predeterminado.

Por ejemplo, al ejecutar `docker run -d` se establecerá el valor en `true`, por lo que tu contenedor se ejecutará en modo desasociado ("detached"), en segundo plano.

Las opciones cuyo valor predeterminado es `true` (por ejemplo, `docker build --rm=true`) solo se pueden establecer en el valor no predeterminado configurándolas explícitamente en `false`:

```console
$ docker build --rm=false .
```

#### Múltiples

Puedes especificar opciones como `-a=[]` varias veces en una sola línea de comandos, por ejemplo, en estos comandos:

```console
$ docker run -a stdin -a stdout -i -t ubuntu /bin/bash

$ docker run -a stdin -a stdout -a stderr ubuntu /bin/ls
```

A veces, las opciones múltiples pueden requerir una cadena de valor más compleja, como ocurre con `-v`:

```console
$ docker run -v /host:/container example/mysql
```

> [!NOTE]
> No utilices las opciones `-t` y `-a stderr` juntas debido a limitaciones en la implementación de `pty`. Todo el flujo de `stderr` en modo `pty` simplemente se dirige a `stdout`.

#### Cadenas y números enteros

Las opciones como `--name=""` esperan una cadena de texto y solo se pueden especificar una vez. Las opciones como `-c=0` esperan un número entero y solo se pueden especificar una vez.

### Archivos de configuración

Por defecto, la línea de comandos de Docker almacena sus archivos de configuración en un directorio llamado `.docker` dentro de tu directorio `$HOME`.

Docker administra la mayoría de los archivos en el directorio de configuración y no deberías modificarlos. Sin embargo, puedes modificar el archivo `config.json` para controlar ciertos aspectos del comportamiento del comando `docker`.

Puedes modificar el comportamiento del comando `docker` utilizando variables de entorno u opciones de línea de comandos. También puedes usar opciones dentro de `config.json` para modificar parte de ese mismo comportamiento. Si se configuran tanto una variable de entorno como la opción `--config`, la opción tiene prioridad sobre la variable de entorno. Las opciones de línea de comandos invalidan las variables de entorno, y las variables de entorno invalidan las propiedades que especifiques en un archivo `config.json`.

#### Cambiar el directorio `.docker`

Para especificar un directorio diferente, utiliza la variable de entorno `DOCKER_CONFIG` o la opción de línea de comandos `--config`. Si se especifican ambas, la opción `--config` invalida la variable de entorno `DOCKER_CONFIG`. El siguiente ejemplo invalida el comando `docker ps` utilizando un archivo `config.json` ubicado en el directorio `~/testconfigs/`:

```console
$ docker --config ~/testconfigs/ ps
```

Esta opción solo se aplica al comando que se está ejecutando. Para una configuración persistente, puedes establecer la variable de entorno `DOCKER_CONFIG` en tu shell (por ejemplo, `~/.profile` o `~/.bashrc`). El siguiente ejemplo establece el nuevo directorio en `$HOME/newdir/.docker`.

```console
$ echo export DOCKER_CONFIG=$HOME/newdir/.docker > ~/.profile
```

### Propiedades del archivo de configuración de la CLI de Docker (`config.json`)

<a name="configjson-properties"><!-- included for deep-links to old section --></a>

Utiliza la configuración de la CLI de Docker para personalizar los ajustes de la CLI de `docker`. El archivo de configuración utiliza formato JSON y las propiedades:

Por defecto, el archivo de configuración se almacena en `~/.docker/config.json`. Consulta la sección [cambiar el directorio .docker](#change-the-docker-directory) para utilizar una ubicación diferente.

> [!WARNING]
> El archivo de configuración y otros archivos dentro del directorio de configuración `~/.docker` pueden contener información confidencial, como información de autenticación para proxies o, dependiendo de tu almacén de credenciales, credenciales para tus registros de imágenes. Revisa el contenido de tu archivo de configuración antes de compartirlo con otros y evita guardar el archivo en el control de versiones.

#### Personalizar el formato de salida predeterminado para los comandos

Estos campos te permiten personalizar el formato de salida predeterminado para algunos comandos si no se proporciona la opción `--format`.

| Propiedad | Descripción |
| :--------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `configFormat`         | Formato predeterminado personalizado para la salida de `docker config ls`. Consulta [`docker config ls`](/reference/cli/docker/config/ls/#format) para obtener una lista de las directivas de formato admitidas. |
| `imagesFormat`         | Formato predeterminado personalizado para la salida de `docker images` / `docker image ls`. Consulta [`docker images`](/reference/cli/docker/image/ls/#format) para obtener una lista de las directivas de formato admitidas. |
| `networksFormat`       | Formato predeterminado personalizado para la salida de `docker network ls`. Consulta [`docker network ls`](/reference/cli/docker/network/ls/#format) para obtener una lista de las directivas de formato admitidas. |
| `nodesFormat`          | Formato predeterminado personalizado para la salida de `docker node ls`. Consulta [`docker node ls`](/reference/cli/docker/node/ls/#format) para obtener una lista de las directivas de formato admitidas. |
| `pluginsFormat`        | Formato predeterminado personalizado para la salida de `docker plugin ls`. Consulta [`docker plugin ls`](/reference/cli/docker/plugin/ls/#format) para obtener una lista de las directivas de formato admitidas. |
| `psFormat`             | Formato predeterminado personalizado para la salida de `docker ps` / `docker container ps`. Consulta [`docker ps`](/reference/cli/docker/container/ls/#format) para obtener una lista de las directivas de formato admitidas. |
| `secretFormat`         | Formato predeterminado personalizado para la salida de `docker secret ls`. Consulta [`docker secret ls`](/reference/cli/docker/secret/ls/#format) para obtener una lista de las directivas de formato admitidas. |
| `serviceInspectFormat` | Formato predeterminado personalizado para la salida de `docker service inspect`. Consulta [`docker service inspect`](/reference/cli/docker/service/inspect/#format) para obtener una lista de las directivas de formato admitidas. |
| `servicesFormat`       | Formato predeterminado personalizado para la salida de `docker service ls`. Consulta [`docker service ls`](/reference/cli/docker/service/ls/#format) para obtener una lista de las directivas de formato admitidas. |
| `statsFormat`          | Formato predeterminado personalizado para la salida de `docker stats`. Consulta [`docker stats`](/reference/cli/docker/container/stats/#format) para obtener una lista de las directivas de formato admitidas. |
| `tasksFormat`          | Formato predeterminado personalizado para la salida de `docker stack ps`. Consulta [`docker stack ps`](/reference/cli/docker/stack/ps/#format) para obtener una lista de las directivas de formato admitidas. |
| `volumesFormat`        | Formato predeterminado personalizado para la salida de `docker volume ls`. Consulta [`docker volume ls`](/reference/cli/docker/volume/ls/#format) para obtener una lista de las directivas de formato admitidas. |

#### Cabeceras HTTP personalizadas

La propiedad `HttpHeaders` especifica un conjunto de cabeceras a incluir en todos los mensajes enviados desde el cliente Docker al demonio. Docker no intenta interpretar ni entender estas cabeceras; simplemente las incluye en los mensajes. Docker no permite que estas cabeceras cambien ninguna cabecera que establezca para sí mismo.

Alternativamente, utiliza la variable de entorno `DOCKER_CUSTOM_HEADERS` (disponible en v27.1 y superiores). Esta variable de entorno es experimental y su comportamiento exacto puede cambiar.

#### Opciones del almacén de credenciales

La propiedad `credsStore` especifica un binario externo para que actúe como almacén de credenciales predeterminado. Cuando se establece esta propiedad, `docker login` intentará almacenar las credenciales en el binario especificado por `docker-credential-<valor>` que sea visible en la variable de entorno `$PATH`. Si esta propiedad no está establecida, las credenciales se almacenan en la propiedad `auths` del archivo de configuración de la CLI. Para obtener más información, consulta la sección [**Almacenes de credenciales** en la documentación de `docker login`](/reference/cli/docker/login/#credential-stores).

La propiedad `credHelpers` especifica un conjunto de asistentes de credenciales (credential helpers) a utilizar preferentemente sobre `credsStore` o `auths` al almacenar y recuperar credenciales para registros específicos. Si se establece esta propiedad, se utilizará el binario `docker-credential-<valor>` al almacenar o recuperar credenciales para un registro específico. Para obtener más información, consulta la sección [**Asistentes de credenciales** en la documentación de `docker login`](/reference/cli/docker/login/#credential-helpers).

#### Configuración automática de proxy para contenedores

La propiedad `proxies` especifica las variables de entorno del proxy que se establecerán automáticamente en los contenedores, y que se configurarán como `--build-arg` en los contenedores utilizados durante `docker build`. Se puede configurar un conjunto de proxies "predeterminado" (default) que se utilizará para cualquier demonio Docker al que se conecte el cliente, o bien una configuración por host (demonio Docker), por ejemplo, `https://docker-daemon1.example.com`. Se pueden establecer las siguientes propiedades para cada entorno:

| Propiedad | Descripción |
|:---------------|:--------------------------------------------------------------------------------------------------------|
| `httpProxy`    | Valor predeterminado de `HTTP_PROXY` y `http_proxy` para contenedores, y como `--build-arg` en `docker build` |
| `httpsProxy`   | Valor predeterminado de `HTTPS_PROXY` y `https_proxy` para contenedores, y como `--build-arg` en `docker build` |
| `ftpProxy`     | Valor predeterminado de `FTP_PROXY` y `ftp_proxy` para contenedores, y como `--build-arg` en `docker build` |
| `noProxy`      | Valor predeterminado de `NO_PROXY` y `no_proxy` para contenedores, y como `--build-arg` en `docker build` |
| `allProxy`     | Valor predeterminado de `ALL_PROXY` and `all_proxy` para contenedores, y como `--build-arg` en `docker build` |

Estos ajustes se utilizan para configurar los parámetros de proxy únicamente para los contenedores, y no se utilizan como ajustes de proxy para la CLI de `docker` ni el demonio `dockerd`. Consulta la sección de [variables de entorno](#environment-variables) y la guía de [configuración de proxy del demonio](/engine/daemon/proxy/) para configurar los ajustes de proxy para la CLI y el demonio.

> [!WARNING]
> Los ajustes del proxy pueden contener información confidencial (por ejemplo, si el proxy requiere autenticación). Las variables de entorno se almacenan como texto plano en la configuración del contenedor y, como tales, se pueden inspeccionar a través de la API remota o guardarse en una imagen al usar `docker commit`.

#### Secuencia de teclas predeterminada para desconectarse de los contenedores

Una vez conectados a un contenedor, los usuarios se desconectan de él y lo dejan en ejecución utilizando la secuencia de teclas `CTRL-p CTRL-q`. Esta secuencia de teclas de desconexión se puede personalizar utilizando la propiedad `detachKeys`. Especifica un valor `<sequence>` (secuencia) para la propiedad. El formato de la `<sequence>` es una lista separada por comas de una letra [a-Z] o el prefijo `ctrl-` combinado con cualquiera de los siguientes:

* `a-z` (un único carácter alfabético en minúscula)
* `@` (el signo arroba)
* `[` (corchete izquierdo)
* `\\` (dos barras invertidas)
* `_` (guion bajo)
* `^` (circunflejo)

Tu personalización se aplica a todos los contenedores iniciados con tu cliente Docker. Los usuarios pueden invalidar tu secuencia de teclas personalizada o la predeterminada para cada contenedor de forma individual. Para ello, el usuario especifica la opción `--detach-keys` con los comandos `docker attach`, `docker exec`, `docker run` o `docker start`.

#### Opciones de plugins de la CLI

La propiedad `plugins` contiene ajustes específicos para los plugins de la CLI. La clave es el nombre del plugin, mientras que el valor es un mapa adicional de opciones específicas de ese plugin.

#### Ejemplo de archivo de configuración

A continuación se muestra un ejemplo de archivo `config.json` para ilustrar el formato utilizado para los distintos campos:

```json
{
  "HttpHeaders": {
    "MyHeader": "MyValue"
  },
  "psFormat": "table {{.ID}}\\t{{.Image}}\\t{{.Command}}\\t{{.Labels}}",
  "imagesFormat": "table {{.ID}}\\t{{.Repository}}\\t{{.Tag}}\\t{{.CreatedAt}}",
  "pluginsFormat": "table {{.ID}}\t{{.Name}}\t{{.Enabled}}",
  "statsFormat": "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}",
  "servicesFormat": "table {{.ID}}\t{{.Name}}\t{{.Mode}}",
  "secretFormat": "table {{.ID}}\t{{.Name}}\t{{.CreatedAt}}\t{{.UpdatedAt}}",
  "configFormat": "table {{.ID}}\t{{.Name}}\t{{.CreatedAt}}\t{{.UpdatedAt}}",
  "serviceInspectFormat": "pretty",
  "nodesFormat": "table {{.ID}}\t{{.Hostname}}\t{{.Availability}}",
  "detachKeys": "ctrl-e,e",
  "credsStore": "secretservice",
  "credHelpers": {
    "awesomereg.example.org": "hip-star",
    "unicorn.example.com": "vcbait"
  },
  "plugins": {
    "plugin1": {
      "option": "value"
    },
    "plugin2": {
      "anotheroption": "anothervalue",
      "athirdoption": "athirdvalue"
    }
  },
  "proxies": {
    "default": {
      "httpProxy":  "http://user:pass@example.com:3128",
      "httpsProxy": "https://my-proxy.example.com:3129",
      "noProxy":    "intra.mycorp.example.com",
      "ftpProxy":   "http://user:pass@example.com:3128",
      "allProxy":   "socks://example.com:1234"
    },
    "https://manager1.mycorp.example.com:2377": {
      "httpProxy":  "http://user:pass@example.com:3128",
      "httpsProxy": "https://my-proxy.example.com:3129"
    }
  }
}
```

#### Características experimentales

Las características experimentales proporcionan acceso temprano a futuras funcionalidades del producto. Estas características están destinadas a pruebas y comentarios, y pueden cambiar entre versiones sin previo aviso o pueden eliminarse en una versión futura.

A partir de Docker 20.10, las características experimentales de la CLI están habilitadas por defecto y no requieren configuración alguna para habilitarse.

#### Notary

Si utilizas tu propio servidor de Notary y un certificado autofirmado o una Autoridad de Certificación interna, debes colocar el certificado en `tls/<url_registro>/ca.crt` en tu directorio de configuración de Docker.

Alternativamente, puedes confiar en el certificado de forma global añadiéndolo a la lista de Autoridades de Certificación raíz de tu sistema.


## Opciones

| Opción                                                        | Predeterminado                                        | Descripción                                                                                                                                    |
| ------------------------------------------------------------- | ----------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|  | `--config` | `/root/.docker` |  Ubicación de los archivos de configuración del cliente |

 | `-c`, `--context` |  |  Nombre del contexto a utilizar para conectarse al demonio (invalida la variable de entorno DOCKER_HOST y el contexto predeterminado establecido con `docker context use`)<br> |

 | `-D`, `--debug` |  |  Habilita el modo de depuración (debug) |

 | `-H`, `--host` |  |  Socket del demonio al que conectarse |

 | `-l`, `--log-level` | `info` |  Nivel de registro (`debug`, `info`, `warn`, `error`, `fatal`) |

 | `--tls` |  |  Utiliza TLS; implícito por --tlsverify |

 | `--tlscacert` | `/root/.docker/ca.pem` |  Confía en los certificados firmados únicamente por esta CA |

 | `--tlscert` | `/root/.docker/cert.pem` |  Ruta al archivo del certificado TLS |

 | `--tlskey` | `/root/.docker/key.pem` |  Ruta al archivo de la clave TLS |

 | `--tlsverify` |  |  Utiliza TLS y verifica el extremo remoto |




## Ejemplos

### Especificar el host del demonio (-H, --host) {#host}

Puedes utilizar la opción `-H`, `--host` para especificar el socket a utilizar al invocar un comando `docker`. Puedes utilizar los siguientes protocolos:

| Protocolo (Scheme) | Descripción | Ejemplo |
|----------------------------------------|---------------------------|----------------------------------|
| `unix://[<ruta>]`                      | Socket de Unix (solo Linux) | `unix:///var/run/docker.sock` |
| `tcp://[<IP o host>[:puerto]]`          | Conexión TCP | `tcp://174.17.0.1:2376` |
| `ssh://[usuario@]<IP o host>[:puerto]` | Conexión SSH | `ssh://user@192.168.64.5` |
| `npipe://[<nombre>]`                     | Tubería con nombre (Named pipe, solo Windows) | `npipe:////./pipe/docker_engine` |

Si no especificas la opción `-H` y no estás utilizando un contexto personalizado, los comandos utilizan los siguientes sockets predeterminados:

- `unix:///var/run/docker.sock` en macOS y Linux
- `npipe:////./pipe/docker_engine` en Windows

Para lograr un efecto similar sin tener que especificar la opción `-H` para cada comando, también puedes [crear un contexto](/reference/cli/docker/context/create/) o, alternativamente, utilizar la [variable de entorno `DOCKER_HOST`](#environment-variables).

Para obtener más información sobre la opción `-H`, consulta [Opción del socket del demonio](/reference/cli/dockerd/#daemon-socket-option).

#### Uso de sockets TCP

El siguiente ejemplo muestra cómo invocar `docker ps` sobre TCP hacia un demonio remoto con la dirección IP `174.17.0.1`, que escucha en el puerto `2376`:

```console
$ docker -H tcp://174.17.0.1:2376 ps
```

> [!NOTE]
> Por convención, el demonio Docker utiliza el puerto `2376` para conexiones TLS seguras, y el puerto `2375` para conexiones no seguras (sin TLS).

#### Uso de sockets SSH

Cuando utilizas SSH para invocar un comando en un demonio remoto, la solicitud se reenvía al socket de Unix `/var/run/docker.sock` en el host SSH.

```console
$ docker -H ssh://user@192.168.64.5 ps
```

Opcionalmente, puedes especificar la ubicación del socket añadiendo un componente de ruta al final de la dirección SSH.

```console
$ docker -H ssh://user@192.168.64.5/var/run/docker.sock ps
```


## Subcomandos

| Comando                                                                                                                                     | Descripción                        |
| ------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- | -------------------- |
|  | [`docker builder`](https://docs-docker.esdocu.com/reference/cli/docker/builder/) | Gestiona construcciones (builds) |

 | [`docker buildx`](https://docs-docker.esdocu.com/reference/cli/docker/buildx/) | Docker Buildx |

 | [`docker checkpoint`](https://docs-docker.esdocu.com/reference/cli/docker/checkpoint/) | Gestiona puntos de control (checkpoints) |

 | [`docker compose`](https://docs-docker.esdocu.com/reference/cli/docker/compose/) | Docker Compose |

 | [`docker config`](https://docs-docker.esdocu.com/reference/cli/docker/config/) | Gestiona las configuraciones (configs) de Swarm |

 | [`docker container`](https://docs-docker.esdocu.com/reference/cli/docker/container/) | Administra contenedores |

 | [`docker context`](https://docs-docker.esdocu.com/reference/cli/docker/context/) | Administra contextos |

 | [`docker debug`](https://docs-docker.esdocu.com/reference/cli/docker/debug/) | Obtén una shell en cualquier contenedor o imagen. Una alternativa para depurar con `docker exec`. |

 | [`docker desktop`](https://docs-docker.esdocu.com/reference/cli/docker/desktop/) | Docker Desktop |

 | [`docker dhi`](https://docs-docker.esdocu.com/reference/cli/docker/dhi/) | CLI para gestionar Docker Hardened Images |

 | [`docker image`](https://docs-docker.esdocu.com/reference/cli/docker/image/) | Gestiona imágenes |

 | [`docker init`](https://docs-docker.esdocu.com/reference/cli/docker/init/) | Crea archivos iniciales relacionados con Docker para tu proyecto |

 | [`docker inspect`](https://docs-docker.esdocu.com/reference/cli/docker/inspect/) | Devuelve información de bajo nivel sobre los objetos de Docker |

 | [`docker login`](https://docs-docker.esdocu.com/reference/cli/docker/login/) | Se autentica ante un registro |

 | [`docker logout`](https://docs-docker.esdocu.com/reference/cli/docker/logout/) | Cierra la sesión en un registro |

 | [`docker manifest`](https://docs-docker.esdocu.com/reference/cli/docker/manifest/) | Gestiona manifiestos e índices de manifiestos de imágenes Docker |

 | [`docker mcp`](https://docs-docker.esdocu.com/reference/cli/docker/mcp/) | Gestiona servidores y clientes MCP |

 | [`docker model`](https://docs-docker.esdocu.com/reference/cli/docker/model/) | Docker Model Runner |

 | [`docker network`](https://docs-docker.esdocu.com/reference/cli/docker/network/) | Gestiona redes |

 | [`docker node`](https://docs-docker.esdocu.com/reference/cli/docker/node/) | Administra los nodos de Swarm |

 | [`docker offload`](https://docs-docker.esdocu.com/reference/cli/docker/offload/) | Controla Docker Offload desde la CLI |

 | [`docker pass`](https://docs-docker.esdocu.com/reference/cli/docker/pass/) | Gestiona los secretos de tu llavero del sistema operativo local. |

 | [`docker plugin`](https://docs-docker.esdocu.com/reference/cli/docker/plugin/) | Gestiona plugins |

 | [`docker sandbox`](https://docs-docker.esdocu.com/reference/cli/docker/sandbox/) | Docker Sandbox |

 | [`docker scout`](https://docs-docker.esdocu.com/reference/cli/docker/scout/) | Herramienta de línea de comandos para Docker Scout |

 | [`docker search`](https://docs-docker.esdocu.com/reference/cli/docker/search/) | Busca imágenes en Docker Hub |

 | [`docker secret`](https://docs-docker.esdocu.com/reference/cli/docker/secret/) | Gestiona secretos de Swarm |

 | [`docker service`](https://docs-docker.esdocu.com/reference/cli/docker/service/) | Administra servicios de Swarm |

 | [`docker stack`](https://docs-docker.esdocu.com/reference/cli/docker/stack/) | Administra pilas (stacks) de Swarm |

 | [`docker swarm`](https://docs-docker.esdocu.com/reference/cli/docker/swarm/) | Administra Swarm |

 | [`docker system`](https://docs-docker.esdocu.com/reference/cli/docker/system/) | Administra Docker |

 | [`docker trust`](https://docs-docker.esdocu.com/reference/cli/docker/trust/) | Administra la confianza en las imágenes de Docker |

 | [`docker version`](https://docs-docker.esdocu.com/reference/cli/docker/version/) | Show the Docker version information |

 | [`docker volume`](https://docs-docker.esdocu.com/reference/cli/docker/volume/) | Administra volúmenes |