# Entornos de ejecución de contenedores alternativos


Docker Engine utiliza containerd para gestionar el ciclo de vida de los contenedores, lo que incluye crearlos, iniciarlos y detenerlos. De forma predeterminada, containerd utiliza runc como su entorno de ejecución de contenedores.

## ¿Qué entornos de ejecución puedo usar?

Puedes usar cualquier entorno de ejecución que implemente la [API de shim de containerd](https://github.com/containerd/containerd/blob/main/core/runtime/v2/README.md). Dichos entornos de ejecución se distribuyen con un shim de containerd y puedes usarlos sin ninguna configuración adicional. Consulta [Usar shims de containerd](#usar-shims-de-containerd).

Ejemplos de entornos de ejecución que implementan sus propios shims de containerd incluyen:

- [Wasmtime](https://wasmtime.dev/)
- [gVisor](https://github.com/google/gvisor)
- [Kata Containers](https://katacontainers.io/)

También puedes utilizar entornos de ejecución diseñados como sustitutos directos de runc. Estos entornos de ejecución dependen del shim de runc de containerd para invocar el binario del entorno de ejecución. Debes registrar manualmente estos entornos de ejecución en la configuración del demonio.

[youki](https://github.com/youki-dev/youki) es un ejemplo de un entorno de ejecución que puede funcionar como sustituto directo de runc. Consulta el [ejemplo de youki](#youki) que explica la configuración.

## Usar shims de containerd

Los shims de containerd te permiten utilizar entornos de ejecución alternativos sin tener que cambiar la configuración del demonio de Docker. Para utilizar un shim de containerd, instala el binario del shim en el `PATH` del sistema donde se está ejecutando el demonio de Docker.

Para usar un shim con `docker run`, especifica el nombre completo del entorno de ejecución como valor de la opción `--runtime`:

```console
$ docker run --runtime io.containerd.kata.v2 hello-world
```

### Usar un shim de containerd sin instalar en el PATH

Puedes usar un shim sin instalarlo en el `PATH`. En ese caso, debes registrar el shim en la configuración del demonio de la siguiente manera:

```json
{
  "runtimes": {
    "foo": {
      "runtimeType": "/ruta/a/containerd-shim-foobar-v1"
    }
  }
}
```

Para utilizar el shim, especifica el nombre que le asignaste:

```console
$ docker run --runtime foo hello-world
```

### Configurar shims

Si necesitas pasar una configuración adicional para un shim de containerd, puedes utilizar la opción `runtimes` en el archivo de configuración del demonio.

1. Edita el archivo de configuración del demonio agregando una entrada `runtimes` para el shim que deseas configurar.

   - Especifica el nombre completo del entorno de ejecución en la clave `runtimeType`.
   - Agrega la configuración de tu entorno de ejecución bajo la clave `options`.

   ```json
   {
     "runtimes": {
       "gvisor": {
         "runtimeType": "io.containerd.runsc.v1",
         "options": {
           "TypeUrl": "io.containerd.runsc.v1.options",
           "ConfigPath": "/etc/containerd/runsc.toml"
         }
       }
     }
   }
   ```

2. Recarga la configuración del demonio.

   ```console
   # systemctl reload docker
   ```

3. Utiliza el entorno de ejecución personalizado mediante la opción `--runtime` de `docker run`.

   ```console
   $ docker run --runtime gvisor hello-world
   ```

Para obtener más información sobre las opciones de configuración para los shims de containerd, consulta [Configurar shims de containerd](/reference/cli/dockerd/#configure-containerd-shims).

## Ejemplos

Los siguientes ejemplos muestran cómo configurar y utilizar entornos de ejecución de contenedores alternativos con Docker Engine.

- [youki](#youki)
- [Wasmtime](#wasmtime)

### youki

youki es un entorno de ejecución de contenedores escrito en Rust. youki afirma ser más rápido y utilizar menos memoria que runc, lo que lo convierte en una buena opción para entornos con recursos limitados.

youki funciona como un reemplazo directo de runc, lo que significa que depende del shim de runc para invocar el binario del entorno de ejecución. Al registrar entornos de ejecución que actúan como reemplazos de runc, configuras la ruta al ejecutable del entorno de ejecución y, opcionalmente, un conjunto de argumentos. Para obtener más información, consulta [Configurar reemplazos directos de runc](/reference/cli/dockerd/#configure-runc-drop-in-replacements).

Para agregar youki como un entorno de ejecución de contenedores:

1. Instala youki y sus dependencias.

   Para obtener instrucciones, consulta la [guía de configuración oficial](https://youki-dev.github.io/youki/user/basic_setup.html).

2. Registra youki como entorno de ejecución para Docker editando el archivo de configuración del demonio de Docker, ubicado por defecto en `/etc/docker/daemon.json`.

   La clave `path` debe especificar la ruta donde instalaste youki.

   ```console
   # cat > /etc/docker/daemon.json <<EOF
   {
     "runtimes": {
       "youki": {
         "path": "/usr/local/bin/youki"
       }
     }
   }
   EOF
   ```

3. Recarga la configuración del demonio.

   ```console
   # systemctl reload docker
   ```

Ahora puedes ejecutar contenedores que utilicen youki como entorno de ejecución.

```console
$ docker run --rm --runtime youki hello-world
```

### Wasmtime




Wasmtime es un proyecto de la [Bytecode Alliance](https://bytecodealliance.org/) y un entorno de ejecución Wasm que te permite ejecutar contenedores Wasm. Ejecutar contenedores Wasm con Docker proporciona dos capas de seguridad. Obtienes todos los beneficios del aislamiento de contenedores, más el entorno de aislamiento (sandboxing) adicional proporcionado por el entorno de ejecución Wasm.

Para agregar Wasmtime como entorno de ejecución de contenedores, sigue estos pasos:

1. Activa la función de [almacenamiento de imágenes de containerd](/engine/storage/containerd/) en el archivo de configuración del demonio.

   ```json
   {
     "features": {
       "containerd-snapshotter": true
     }
   }
   ```

2. Reinicia el demonio de Docker.

   ```console
   # systemctl restart docker
   ```

3. Instala el shim de containerd de Wasmtime en el `PATH`.

   El siguiente comando de Dockerfile compila el binario de Wasmtime desde el código fuente y lo exporta a `./containerd-shim-wasmtime-v1`.

   ```console
   $ docker build --output . - <<EOF
   FROM rust:latest as build
   RUN cargo install \
       --git https://github.com/containerd/runwasi.git \
       --bin containerd-shim-wasmtime-v1 \
       --root /out \
       containerd-shim-wasmtime
   FROM scratch
   COPY --from=build /out/bin /
   EOF
   ```

   Coloca el binario en un directorio dentro del `PATH`.

   ```console
   $ mv ./containerd-shim-wasmtime-v1 /usr/local/bin
   ```

Ahora puedes ejecutar contenedores que utilicen Wasmtime como entorno de ejecución.

```console
$ docker run --rm \
 --runtime io.containerd.wasmtime.v1 \
 --platform wasi/wasm32 \
 michaelirwin244/wasm-example
```

## Información relacionada

- Para conocer más sobre las opciones de configuración para entornos de ejecución de contenedores, consulta [Configurar entornos de ejecución de contenedores](/reference/cli/dockerd/#configure-container-runtimes).
- Puedes configurar qué entorno de ejecución debe usar el demonio por defecto. Consulta [Configurar el entorno de ejecución de contenedores predeterminado](/reference/cli/dockerd/#configure-the-default-container-runtime).