# Iniciar contenedores automáticamente


Docker proporciona [políticas de reinicio](/reference/cli/docker/container/run/#restart) para controlar si tus contenedores se inician automáticamente al finalizar, o cuando Docker se reinicia. Las políticas de reinicio inician los contenedores vinculados en el orden correcto. Docker recomienda utilizar políticas de reinicio y evitar el uso de gestores de procesos para iniciar los contenedores.

Las políticas de reinicio son diferentes de la opción `--live-restore` del comando `dockerd`. El uso de `--live-restore` te permite mantener tus contenedores en ejecución durante una actualización de Docker, aunque la red y la entrada del usuario se interrumpen.

## Usar una política de reinicio

Para configurar la política de reinicio de un contenedor, utiliza la opción [`--restart`](/reference/cli/docker/container/run/#restart) al usar el comando `docker run`. El valor de la opción `--restart` puede ser cualquiera de los siguientes:

| Opción                     | Descripción                                                                                                                                                                                                                                                                                                                                                                                                               |
| :------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `no`                       | No reinicia automáticamente el contenedor. (Predeterminado)                                                                                                                                                                                                                                                                                                                                                               |
| `on-failure[:max-retries]` | Reinicia el contenedor si finaliza debido a un error, lo cual se manifiesta como un código de salida distinto de cero. Opcionalmente, limita el número de veces que el demonio de Docker intenta reiniciar el contenedor mediante la opción `:max-retries`. La política `on-failure` solo activa un reinicio si el contenedor finaliza con un fallo. No reinicia el contenedor si el demonio se reinicia.               |
| `always`                   | Reinicia siempre el contenedor si se detiene. Si se detiene manualmente, se reinicia solo cuando el demonio de Docker se reinicia o el propio contenedor se reinicia de forma manual. (Consulta el segundo punto de [detalles de las políticas de reinicio](#detalles-de-las-politicas-de-reinicio))                                                                                                                      |
| `unless-stopped`           | Similar a `always`, excepto que cuando el contenedor se detiene (manualmente o de otro modo), no se reinicia incluso después de que el demonio de Docker se reinicie.                                                                                                                                                                                                                                                     |

El siguiente comando inicia un contenedor de Redis y lo configura para que se reinicie siempre, a menos que el contenedor se detenga explícitamente o el demonio se reinicie.

```console
$ docker run -d --restart unless-stopped redis
```

El siguiente comando cambia la política de reinicio para un contenedor en ejecución llamado `redis`.

```console
$ docker update --restart unless-stopped redis
```

El siguiente comando garantiza que todos los contenedores en ejecución se reinicien.

```console
$ docker update --restart unless-stopped $(docker ps -q)
```

### Detalles de las políticas de reinicio

Ten en cuenta lo siguiente al utilizar políticas de reinicio:

- Una política de reinicio solo tiene efecto después de que un contenedor se inicia correctamente. En este caso, iniciarse correctamente significa que el contenedor está activo durante al menos 10 segundos y Docker ha comenzado a supervisarlo. Esto evita que un contenedor que no se inicia en absoluto entre en un bucle de reinicio infinito.

- Si detienes manualmente un contenedor, la política de reinicio se ignora hasta que el demonio de Docker se reinicie o el contenedor se reinicie manualmente. Esto evita un bucle de reinicio.

- Las políticas de reinicio solo se aplican a contenedores. Para configurar políticas de reinicio para servicios de Swarm, consulta [opciones relacionadas con el reinicio de servicios](/reference/cli/docker/service/create/).

### Reinicio de contenedores en primer plano (foreground)

Cuando ejecutas un contenedor en primer plano, detener el contenedor hace que la CLI acoplada también finalice, independientemente de la política de reinicio del contenedor. Este comportamiento se ilustra en el siguiente ejemplo:

1. Crea un Dockerfile que imprima los números del 1 al 5 y luego finalice.

   ```dockerfile
   FROM busybox:latest
   COPY --chmod=755 <<"EOF" /start.sh
   echo "Starting..."
   for i in $(seq 1 5); do
     echo "$i"
     sleep 1
   done
   echo "Exiting..."
   exit 1
   EOF
   ENTRYPOINT /start.sh
   ```

2. Construye una imagen a partir del Dockerfile.

   ```console
   $ docker build -t startstop .
   ```

3. Ejecuta un contenedor a partir de la imagen, especificando `always` para su política de reinicio.

   El contenedor imprime los números 1..5 en la salida estándar y luego finaliza. Esto hace que la CLI acoplada también finalice.

   ```console
   $ docker run --restart always startstop
   Starting...
   1
   2
   3
   4
   5
   Exiting...
   $
   ```

4. Al ejecutar `docker ps` se muestra que todavía se está ejecutando o reiniciando, gracias a la política de reinicio. Sin embargo, la sesión de la CLI ya ha finalizado. No sobrevive a la finalización inicial del contenedor.

   ```console
   $ docker ps
   CONTAINER ID   IMAGE       COMMAND                  CREATED         STATUS         PORTS     NAMES
   081991b35afe   startstop   "/bin/sh -c /start.sh"   9 seconds ago   Up 4 seconds             gallant_easley
   ```

5. Puedes volver a acoplar tu terminal al contenedor entre reinicios, utilizando el comando `docker container attach`. Se desacoplará de nuevo la próxima vez que el contenedor finalice.

   ```console
   $ docker container attach 081991b35afe
   4
   5
   Exiting...
   $
   ```

## Usar un gestor de procesos

Si las políticas de reinicio no se adaptan a tus necesidades, por ejemplo, cuando procesos fuera de Docker dependen de contenedores Docker, puedes utilizar en su lugar un gestor de procesos como [systemd](https://systemd.io/) o [supervisor](http://supervisord.org/).

> [!WARNING]
>
> No combines las políticas de reinicio de Docker con gestores de procesos a nivel de host, ya que esto genera conflictos.

Para usar un gestor de procesos, configúralo para iniciar tu contenedor o servicio utilizando el mismo comando `docker start` o `docker service` que usarías normalmente para iniciar el contenedor de forma manual. Consulta la documentación del gestor de procesos específico para obtener más detalles.

### Usar un gestor de procesos dentro de contenedores

Los gestores de procesos también pueden ejecutarse dentro del contenedor para comprobar si un proceso está en ejecución e iniciarlo/reiniciarlo si no es así.

> [!WARNING]
>
> Estos no detectan el estado de Docker y solo supervisan los procesos del sistema operativo dentro del contenedor. Docker no recomienda este enfoque porque depende de la plataforma y puede diferir entre las versiones de una distribución de Linux determinada.