# Aplicar actualizaciones continuas a un servicio


En un paso anterior del tutorial, [escalaste](/engine/swarm/swarm-tutorial/rolling-update/scale-service/) el número de instancias de un servicio. En esta parte del tutorial, implementarás un servicio basado en la etiqueta de contenedor de Redis 7.4.0. Luego, actualizarás el servicio para usar la imagen de contenedor de Redis 7.4.1 utilizando actualizaciones continuas (rolling updates).

1.  Si aún no lo has hecho, abre una terminal y conéctate por SSH a la máquina donde ejecutas tu nodo administrador. Por ejemplo, el tutorial utiliza una máquina llamada `manager1`.

2.  Implementa tu etiqueta de Redis en el swarm y configura el swarm con un retraso de actualización de 10 segundos. Ten en cuenta que el siguiente ejemplo muestra una etiqueta de Redis más antigua:

    ```console
    $ docker service create \
      --replicas 3 \
      --name redis \
      --update-delay 10s \
      redis:7.4.0

    0u6a4s31ybk7yw2wyvtikmu50
    ```

    Configuras la política de actualización continua en el momento de la implementación del servicio.

    La bandera `--update-delay` configura el retraso de tiempo entre las actualizaciones de una tarea de servicio o conjuntos de tareas. Puedes representar el tiempo `T` como una combinación de números para segundos `Ts`, minutos `Tm` u horas `Th`. De este modo, `10m30s` indica un retraso de 10 minutos y 30 segundos.

    Por defecto, el programador actualiza 1 tarea a la vez. Puedes pasar la bandera `--update-parallelism` para configurar la cantidad máxima de tareas de servicio que el programador actualizará automáticamente al mismo tiempo.

    Por defecto, cuando la actualización de una tarea individual devuelve el estado `RUNNING`, el programador programa la actualización de otra tarea hasta que todas estén actualizadas. Si en cualquier momento durante la actualización una tarea devuelve `FAILED`, el programador pausará la actualización. Puedes controlar este comportamiento mediante la bandera `--update-failure-action` para `docker service create` o `docker service update`.

3.  Inspecciona el servicio `redis`:

    ```console
    $ docker service inspect --pretty redis

    ID:             0u6a4s31ybk7yw2wyvtikmu50
    Name:           redis
    Service Mode:   Replicated
     Replicas:      3
    Placement:
     Strategy:	    Spread
    UpdateConfig:
     Parallelism:   1
     Delay:         10s
    ContainerSpec:
     Image:         redis:7.4.0
    Resources:
    Endpoint Mode:  vip
    ```

4.  Ahora puedes actualizar la imagen del contenedor para `redis`. El administrador de swarm aplica la actualización a los nodos según la política de `UpdateConfig`:

    ```console
    $ docker service update --image redis:7.4.1 redis
    redis
    ```

    El programador aplica las actualizaciones continuas de la siguiente manera de forma predeterminada:

    * Detiene la primera tarea.
    * Programa la actualización para la tarea detenida.
    * Inicia el contenedor para la tarea actualizada.
    * Si la actualización de una tarea devuelve `RUNNING`, espera el período de retraso especificado y luego inicia la siguiente tarea.
    * Si en cualquier momento durante la actualización una tarea devuelve `FAILED`, pausa la actualización.

5.  Ejecuta `docker service inspect --pretty redis` para ver la nueva imagen en el estado deseado:

    ```console
    $ docker service inspect --pretty redis

    ID:             0u6a4s31ybk7yw2wyvtikmu50
    Name:           redis
    Service Mode:   Replicated
     Replicas:      3
    Placement:
     Strategy:	    Spread
    UpdateConfig:
     Parallelism:   1
     Delay:         10s
    ContainerSpec:
     Image:         redis:7.4.1
    Resources:
    Endpoint Mode:  vip
    ```

    La salida de `service inspect` muestra si tu actualización se pausó debido a un fallo:

    ```console
    $ docker service inspect --pretty redis

    ID:             0u6a4s31ybk7yw2wyvtikmu50
    Name:           redis
    ...snip...
    Update status:
     State:      paused
     Started:    11 seconds ago
     Message:    update paused due to failure or early termination of task 9p7ith557h8ndf0ui9s0q951b
    ...snip...
    ```

    Para reiniciar una actualización pausada, ejecuta `docker service update <SERVICE-ID>`. Por ejemplo:

    ```console
    $ docker service update redis
    ```

    Para evitar repetir ciertos fallos de actualización, es posible que necesites reconfigurar el servicio pasando banderas a `docker service update`.

6.  Ejecuta `docker service ps <SERVICE-ID>` para observar la actualización continua:

    ```console
    $ docker service ps redis

    NAME                                   IMAGE        NODE       DESIRED STATE  CURRENT STATE            ERROR
    redis.1.dos1zffgeofhagnve8w864fco      redis:7.4.1  worker1    Running        Running 37 seconds
     \_ redis.1.88rdo6pa52ki8oqx6dogf04fh  redis:7.4.0  worker2    Shutdown       Shutdown 56 seconds ago
    redis.2.9l3i4j85517skba5o7tn5m8g0      redis:7.4.1  worker2    Running        Running About a minute
     \_ redis.2.66k185wilg8ele7ntu8f6nj6i  redis:7.4.0  worker1    Shutdown       Shutdown 2 minutes ago
    redis.3.egiuiqpzrdbxks3wxgn8qib1g      redis:7.4.1  worker1    Running        Running 48 seconds
     \_ redis.3.ctzktfddb2tepkr45qcmqln04  redis:7.4.0  mmanager1  Shutdown       Shutdown 2 minutes ago
    ```

    Antes de que Swarm actualice todas las tareas, podrás observar que algunas ejecutan `redis:7.4.0` mientras que otras ejecutan `redis:7.4.1`. La salida anterior muestra el estado una vez finalizadas las actualizaciones continuas.

## Siguientes pasos

A continuación, aprenderás a drenar un nodo en el swarm.

[Drenar un nodo](/engine/swarm/swarm-tutorial/rolling-update/drain-node/)