# Driver Docker container


El driver Docker container permite crear un entorno de BuildKit gestionado y personalizable en un contenedor Docker dedicado.

El uso del driver Docker container ofrece algunas ventajas sobre el driver Docker predeterminado. Por ejemplo:

- Especificar versiones personalizadas de BuildKit a utilizar.
- Compilar imágenes multi-arquitectura, consulta [QEMU](#qemu).
- Opciones avanzadas para la [importación y exportación de caché](/build/cache/backends/).

## Sinopsis

Ejecuta el siguiente comando para crear un nuevo builder, llamado `container`, que utilice el driver Docker container:

```console
$ docker buildx create \
  --name container \
  --driver=docker-container \
  --driver-opt=[key=value,...]
container
```

La siguiente tabla describe las opciones específicas del driver disponibles que puedes pasar a `--driver-opt`:

| Parámetro            | Tipo    | Predeterminado   | Descripción                                                                                                                            |
| :------------------- | :------ | :--------------- | :------------------------------------------------------------------------------------------------------------------------------------- |
| `image`              | String  |                  | Establece la imagen de BuildKit que se utilizará para el contenedor.                                                                   |
| `memory`             | String  |                  | Establece la cantidad de memoria que puede utilizar el contenedor.                                                                     |
| `memory-swap`        | String  |                  | Establece el límite de memoria swap para el contenedor.                                                                                |
| `cpu-quota`          | String  |                  | Impone una cuota CPU CFS en el contenedor.                                                                                             |
| `cpu-period`         | String  |                  | Establece el período del planificador CPU CFS para el contenedor.                                                                      |
| `cpu-shares`         | String  |                  | Configura las cuotas de CPU (peso relativo) del contenedor.                                                                            |
| `cpuset-cpus`        | String  |                  | Limita el conjunto de núcleos de CPU que puede utilizar el contenedor.                                                                 |
| `cpuset-mems`        | String  |                  | Limita el conjunto de nodos de memoria de CPU que puede utilizar el contenedor.                                                        |
| `default-load`       | Boolean | `false`          | Carga automáticamente las imágenes en el almacenamiento de imágenes de Docker Engine.                                                  |
| `network`            | String  |                  | Establece el modo de red para el contenedor.                                                                                           |
| `cgroup-parent`      | String  | `/docker/buildx` | Establece el cgroup padre del contenedor si Docker utiliza el driver "cgroupfs".                                                       |
| `restart-policy`     | String  | `unless-stopped` | Establece la [política de reinicio](/engine/containers/start-containers-automatically/#use-a-restart-policy) del contenedor. |
| `env.<key>`          | String  |                  | Establece la variable de entorno `key` con el `value` especificado en el contenedor.                                                   |
| `provenance-add-gha` | Boolean | `true`           | Escribe automáticamente el contexto de GitHub Actions en el builder para la procedencia (provenance).                                  |

Antes de configurar los límites de recursos para el contenedor, consulta [Configuración de restricciones de recursos en tiempo de ejecución para contenedores](/engine/containers/resource_constraints/).

## Uso

Cuando ejecutas una compilación, Buildx descarga la imagen (`image`) especificada (por defecto, [`moby/buildkit`](https://hub.docker.com/r/moby/buildkit)). Una vez iniciado el contenedor, Buildx envía la compilación solicitada al servidor de compilación contenido dentro del contenedor.

```console
$ docker buildx build -t <image> --builder=container .
WARNING: No output specified with docker-container driver. Build result will only remain in the build cache. To push result image into registry use --push or to load image into docker use --load
#1 [internal] booting buildkit
#1 pulling image moby/buildkit:buildx-stable-1
#1 pulling image moby/buildkit:buildx-stable-1 1.9s done
#1 creating container buildx_buildkit_container0
#1 creating container buildx_buildkit_container0 0.5s done
#1 DONE 2.4s
...
```

## Persistencia de caché

El driver `docker-container` admite la persistencia de caché, ya que almacena todo el estado de BuildKit y la caché relacionada en un volumen de Docker dedicado.

Para conservar la caché del driver `docker-container`, incluso después de volver a crear el driver usando `docker buildx rm` y `docker buildx create`, puedes destruir el builder utilizando la bandera `--keep-state`:

Por ejemplo, para crear un builder llamado `container` y luego eliminarlo conservando su estado:

```console
# configurar un builder
$ docker buildx create --name=container --driver=docker-container --use --bootstrap
container
$ docker buildx ls
NAME/NODE       DRIVER/ENDPOINT              STATUS   BUILDKIT PLATFORMS
container *     docker-container
  container0    desktop-linux                running  v0.10.5  linux/amd64
$ docker volume ls
DRIVER    VOLUME NAME
local     buildx_buildkit_container0_state

# eliminar el builder conservando su estado
$ docker buildx rm --keep-state container
$ docker volume ls
DRIVER    VOLUME NAME
local     buildx_buildkit_container0_state

# ¡el nuevo driver creado con el mismo nombre tendrá todo el estado del anterior!
$ docker buildx create --name=container --driver=docker-container --use --bootstrap
container
```

## QEMU

El driver `docker-container` admite el uso de [QEMU](https://www.qemu.org/) (modo de usuario) para compilar en plataformas no nativas. Utiliza la bandera `--platform` para especificar las arquitecturas para las que deseas realizar la compilación.

Por ejemplo, para compilar una imagen de Linux para `amd64` y `arm64`:

```console
$ docker buildx build \
  --builder=container \
  --platform=linux/amd64,linux/arm64 \
  -t <registry>/<image> \
  --push .
```

> [!NOTE]
>
> La emulación con QEMU puede ser mucho más lenta que las compilaciones nativas, especialmente para tareas con un uso intensivo de procesamiento, como la compilación y la compresión o descompresión.

## Red personalizada

Puedes personalizar la red que utiliza el contenedor del builder. Esto es útil si necesitas emplear una red específica para tus compilaciones.

Por ejemplo, [creemos una red](/reference/cli/docker/network/create/) llamada `foonet`:

```console
$ docker network create foonet
```

Ahora crea un [builder `docker-container`](/reference/cli/docker/buildx/create/) que utilizará esta red:

```console
$ docker buildx create --use \
  --name mybuilder \
  --driver docker-container \
  --driver-opt "network=foonet"
```

Inicia e [inspecciona `mybuilder`](/reference/cli/docker/buildx/inspect/):

```console
$ docker buildx inspect --bootstrap
```

[Inspecciona el contenedor del builder](/reference/cli/docker/inspect/) y comprueba qué red se está utilizando:

```console
$ docker inspect buildx_buildkit_mybuilder0 --format={{.NetworkSettings.Networks}}
map[foonet:0xc00018c0c0]
```

## Lectura adicional

Para obtener más información sobre el driver Docker container, consulta la [referencia de buildx](/reference/cli/docker/buildx/create/#driver).