Watchtower (avec Healt check)

Dans le monde en constante évolution des applications et des services en ligne, la maintenance des conteneurs Docker est devenue une tâche essentielle. La nécessité de garder les logiciels à jour pour des raisons de sécurité, de performances et de fonctionnalités est une priorité pour les développeurs et les administrateurs système. C’est là que Docker Watchtower entre en jeu, offrant une solution simple et automatisée pour la mise à jour des conteneurs Docker.

Cet article a donc pour but de vous permettre de mettre en place Watchtower disposant d’un healthcheck !

Introduction

Docker Watchtower est un outil open source développé par la communauté Docker. Son objectif principal est de surveiller les images de conteneurs Docker dans un environnement et de les mettre à jour automatiquement dès qu’une nouvelle version est disponible. Cela élimine le besoin d’interventions manuelles régulières pour mettre à jour les conteneurs individuellement, ce qui permet aux développeurs et aux administrateurs de se concentrer sur d’autres tâches essentielles.

Fonctionnalités

Le fonctionnement de Docker Watchtower repose sur un processus simple mais puissant :

• Surveillance des images : Docker Watchtower surveille en permanence les registres Docker, tels que Docker Hub, à la recherche de nouvelles versions d’images de conteneurs.

• Comparaison des versions : Lorsqu’une nouvelle version d’une image est détectée, Docker Watchtower compare cette version à celle utilisée par les conteneurs en cours d’exécution.

• Mise à jour des conteneurs : Si une nouvelle version de l’image est plus récente que celle actuellement utilisée par les conteneurs, Docker Watchtower déclenche automatiquement la mise à jour des conteneurs concernés avec la nouvelle image.

• Redémarrage en douceur : Docker Watchtower peut redémarrer les conteneurs de manière transparente après la mise à jour, minimisant ainsi les interruptions de service.

L’utilisation de Docker Watchtower offre plusieurs avantages significatifs :

• Automatisation : L’automatisation de la mise à jour des conteneurs élimine le besoin d’interventions manuelles régulières, ce qui permet de gagner du temps et de réduire les erreurs humaines potentielles.

• Sécurité : Les mises à jour régulières des conteneurs sont essentielles pour maintenir un environnement sécurisé, car elles intègrent les correctifs de sécurité et les mises à jour critiques.

• Efficacité : En mettant à jour les conteneurs rapidement, Docker Watchtower assure une utilisation optimale des ressources et des performances améliorées.

• Simplicité : Son utilisation est simple, ce qui en fait une solution accessible même pour les utilisateurs moins expérimentés.

Fichiers requis

platform.sh

[Fichier]

#!/bin/bash

# Used in Docker build to set platform dependent variables

case $TARGETARCH in

    "amd64")
	echo "x86_64-unknown-linux-gnu" > /.platform
	echo "" > /.compiler
	;;
    "arm64")
	echo "aarch64-unknown-linux-gnu" > /.platform
	echo "gcc-aarch64-linux-gnu" > /.compiler
	;;
    "arm")
	echo "armv7-unknown-linux-gnueabihf" > /.platform
	echo "gcc-arm-linux-gnueabihf" > /.compiler
	;;
esac

build.sh

[Fichier]

#!/bin/bash
# 2023-08-27

clear
cd "$(dirname "$0")" || exit 1

# Docker image name and version
IMAGE_BASE=zogg/watchtower
IMAGE_NAME_LATEST=${IMAGE_BASE}:latest

# Prepare for cross compile
export DOCKER_DEFAULT_PLATFORM=linux/amd64
export DOCKER_CLI_EXPERIMENTAL=enabled

docker run --privileged --rm tonistiigi/binfmt --install all
if [ $? -eq 0 ]; then
    echo "* binfmt done!"

    # Build
    docker buildx build \
        --no-cache \
        --network host \
        --compress \
        --output=type=docker \
        --pull \
        --build-arg CONCURRENCY=$(nproc) \
        \
        --platform=linux/amd64 \
        \
        -t "${IMAGE_NAME_LATEST}" \
        . 2>&1 | tee build.log

    if [ $? -eq 0 ]; then
        echo "* buildx done!"

        # Tag
        docker tag ${IMAGE_NAME_LATEST} dockerregistry.domain.com/${IMAGE_NAME_LATEST}
        if [ $? -eq 0 ]; then
            echo "* tag done!"

            # Push
            docker image push dockerregistry.domain.com/${IMAGE_NAME_LATEST}
            if [ $? -eq 0 ]; then
                echo "* push done!"
            else
                echo "* push failed!"
            fi

        else
            echo "* tag failed!"
        fi

    else
        echo "* buildx failed!"
    fi

else
    echo "* binfmt failed!"
fi

exit 0

healthcheck.sh

[Fichier]

#!/bin/bash
# 2023-08-27

wget --quiet --spider --tries=1 --header "Authorization: Bearer ${WATCHTOWER_HTTP_API_TOKEN}" http://127.0.0.1:8080/v1/metrics

Dockerfile

[Fichier]

# 2023-08-27

## HOWTO:
## debug image with local bash session:
##
##       docker run -it --entrypoint bash zogg/watchtower:latest

# --------------------------------------------------
# Intermediary Build
# --------------------------------------------------

FROM	containrrr/watchtower:latest as BUILD

# Arguments from Docker build
ARG     TARGETPLATFORM
ARG     TARGETOS
ARG     TARGETARCH
ARG     BUILDPLATFORM
ARG     BUILDOS
ARG     BUILDARCH
ARG     BUILDVARIANT
ARG     CONCURRENCY


# --------------------------------------------------
# Final Docker Image
# --------------------------------------------------

FROM	alpine:latest

# Arguments from Docker build
ARG     TARGETPLATFORM
ARG     TARGETOS
ARG     TARGETARCH
ARG     BUILDPLATFORM
ARG     BUILDOS
ARG     BUILDARCH
ARG     BUILDVARIANT
ARG     CONCURRENCY

# Update & upgrade APK + Install required packages
USER    root
WORKDIR /
RUN             apk add --no-cache wget bash

# Set bash as default shell interpreter
SHELL   ["/bin/bash", "-c"]

# Used by Docker build to set platform dependent variables
COPY    platform.sh .
RUN             chmod +x platform.sh \
        &&      ./platform.sh \
        &&      rm -rf platform.sh

# Copy necessary files
COPY    healthcheck.sh	                        /healthcheck

# Setup execution rights
RUN             chmod +x /healthcheck


USER    root
WORKDIR /

# Copy from build
COPY    --from=build    /.                                      /

# Disable Watchtower image check
LABEL   com.centurylinklabs.watchtower.enable   false

# Define author's informations
LABEL   org.opencontainers.image.title          "Watchtower Special Edition"
LABEL   author                                  "Olivier Le Bris"
LABEL   maintainer                              "tech@zogg.fr"
LABEL   org.opencontainers.image.source         "https://zogg.fr"
LABEL   org.opencontainers.image.licenses       MIT

ENTRYPOINT ["/watchtower"]

Prérequis

Je pars du principe que vous savez vous servir d’un éditeur de texte et que vous connaissez vos machines.

Avant de commencer, assurez-vous d’avoir Docker installé sur votre serveur. Docker est une plateforme de virtualisation légère qui permet d’exécuter des applications dans des conteneurs isolés.

Vous aurez besoin de déployer une registry Docker sur votre environnement (dockerregistry.domain.com).

Il vous sera aussi nécessaire de créer le répertoire suivant :

• /opt/build/watchtower

Ces informations doivent refléter votre propre besoin ou organisation sur votre disque.

Procédure

Pour lancer la construction de l’image, il suffit de donner au script shell build.sh les droits d’exécution puis de le lancer :

sudo chmod +x build.sh && sudo bash build.sh

Exploitation

il vous suffit de placer le fichier ci-dessous, puis de lancer docker compose up -d afin d’exécuter Watchtower en mode détaché.

docker-compose.yml

version: "3.0"

#
# updated: 2023-08-27
# stack:   watchtower
#

networks:
  watchtower:
    name: watchtower
    driver: bridge
    #enable_ipv6: true

services:

  watchtower:
    user: 0:0
    privileged: true
    container_name: watchtower
    hostname: watchtower
    image: dockerregistry.domain.com/zogg/watchtower:latest
    restart: always
    ports:
      - "8080:8080"
    expose:
      - "8080"
    networks:
      - watchtower
    healthcheck:
      test: /healthcheck || exit 1
    environment:
      #WATCHTOWER_POLL_INTERVAL: 900
      WATCHTOWER_SCHEDULE: "0 0 2 * * *"
      WATCHTOWER_NO_STARTUP_MESSAGE: true
      WATCHTOWER_LABEL_ENABLE: true
      WATCHTOWER_CLEANUP: true
      WATCHTOWER_INCLUDE_STOPPED: true
      WATCHTOWER_HTTP_API_METRICS: true
      WATCHTOWER_HTTP_API_TOKEN: "...API TOKEN..."
      WATCHTOWER_NOTIFICATIONS: shoutrrr
      WATCHTOWER_NOTIFICATION_URL: "ntfy://ntfy.sh/watchtower"
      WATCHTOWER_NOTIFICATION_TEMPLATE: "{{range .}}{{.Message}}{{println}}{{end}}"
      WATCHTOWER_NOTIFICATIONS_LEVEL: "info"
      WATCHTOWER_NOTIFICATION_TITLE_TAG: "domain.com"
      WATCHTOWER_NOTIFICATIONS_HOSTNAME: "domain.com"
    labels:
      com.stack.name: "watchtower"
      com.stack.service.name: "watchtower"

Conclusion

Docker Watchtower est devenu un outil incontournable pour les équipes de développement et les administrateurs système qui utilisent Docker. Grâce à son automatisation efficace de la mise à jour des conteneurs, il offre non seulement une solution pour maintenir les applications à jour, mais aussi pour garantir la sécurité et les performances de l’environnement de conteneurisation.

L’intégration de Docker Watchtower dans le flux de travail de gestion des conteneurs peut simplifier de manière significative la gestion des mises à jour, tout en libérant du temps pour se concentrer sur d’autres aspects du développement et de l’administration système.