Aller au contenu

Guide de migration vers Canopsis 26.10.0

Ce guide donne les instructions vous permettant de mettre à jour Canopsis 26.04 (dernière version disponible) vers la version 26.10.0.

Sommaire

Prérequis

L'ensemble de cette procédure doit être lue avant son exécution.

Ce document ne prend en compte que Canopsis Community et Canopsis Pro : tout développement personnalisé dont vous pourriez bénéficier ne fait pas partie du cadre de ce Guide de migration.

Les fichiers de référence qui sont mentionnés dans ce guide sont disponibles à ces adresses

Édition Sources
Édition Community https://git.canopsis.net/canopsis/canopsis-community/-/releases
Édition pro https://git.canopsis.net/sources/canopsis-pro-sources/-/releases

Changement majeur : séparation de l'API publique et de l'API interne

Dans cette version, l'API de Canopsis est séparée en deux services : une API publique (/api/v5), pour vos scripts et intégrations, et une API interne (/internal), réservée à l'interface web. Le service canopsis-api et la variable CPS_API_URL disparaissent, et l'API ne répond plus sur /api/v4.

Cela a un impact sur votre déploiement (services, variables d'environnement, reverse proxy) et sur vos scripts et connecteurs qui appellent l'API. Lisez le chapitre Séparation de l'API publique et de l'API interne avant de commencer la mise à jour, et faites l'inventaire de vos scripts qui appellent l'API.

Utilisateurs Helm

Pour les environnements déployés via Helm, la grande majorité des mises à jour décrites dans ce guide (TimescaleDB, RabbitMQ, services API) sont prises en charge nativement par les configurations de référence fournies par Canopsis. Sauf mention contraire dans l'onglet correspondant, aucune action manuelle n'est requise pour ces composants. Seule la commande helm upgrade finale est indispensable.

Utilisateurs Helm

L'API publique et l'API interne partagent certains répertoires en lecture et écriture. Il est donc indispensable de disposer sur votre infrastructure un StorageClass qui permet de gérer les PVs de type ReadWriteMany (RWX).

Réalisation d'une sauvegarde

Des sauvegardes sont toujours recommandées, qu'elles soient régulières ou lors de modifications importantes.

Sauvegardez en particulier les fichiers de configuration que la mise à jour modifie :

cp -a /opt/canopsis/etc/go-engines-vars.conf /opt/canopsis/etc/go-engines-vars.conf.26.04
cp -a /etc/nginx/conf.d/canopsis.conf /etc/nginx/conf.d/canopsis.conf.26.04

Conservez une copie du répertoire contenant vos fichiers docker-compose.yml, docker-compose.override.yml et canopsis.env.

Conservez une copie de votre fichier de surcharges (par exemple customer-values.yaml) et de vos éventuels fichiers de configuration personnalisés (configmaps, secrets, etc...).

Arrêt de l'environnement en cours d'exécution

Vous devez prévoir une interruption du service afin de procéder à la mise à jour qui va suivre.

systemctl stop canopsis.service

Vous devez prévoir une interruption du service afin de procéder à la mise à jour qui va suivre.

CPS_EDITION=pro docker compose down

Téléchargez ensuite le paquet de la version 26.10.0 et reportez-y vos personnalisations, comme décrit dans Mise à jour des paquets (onglet « Docker Compose »). Les mises à jour de MongoDB, TimescaleDB et RabbitMQ qui suivent utilisent les images de la version 26.10 : leurs commandes se lancent depuis le dossier de la version 26.10.0.

Vous devez prévoir une interruption du service afin de procéder à la mise à jour qui va suivre.

kubectl delete deployments -l 'app.kubernetes.io/name=canopsis-pro'

Versions des composants

Composant Canopsis 26.04 Canopsis 26.10
MongoDB 8.0 9.0
TimescaleDB 2.26 2.30.2
RabbitMQ 4.2 4.3
Valkey 9.0 9.0 (inchangé)

Valkey ne change pas de version : aucune action n'est nécessaire pour ce composant.

Mise à jour de MongoDB

Dans cette version de Canopsis, la base de données MongoDB passe de la version 8.0 à 9.0.

Vérifications MongoDB

Vérification

Avant de démarrer la procédure de mise à jour, vous devez vérifier que la valeur de featureCompatibilityVersion est bien positionnée à 8.0.

mongosh -u root -p root
> db.adminCommand( { getParameter: 1, featureCompatibilityVersion: 1 } )
> exit

Si la valeur est inférieure à 8.0, terminez d'abord la mise à jour vers MongoDB 8.0 décrite dans le guide de migration de Canopsis 25.10.0 (documentation de la version 25.10).

Mise à jour

Arrêter le service :

systemctl stop mongod.service

Remplacer le dépôt de la version 8.0 par celui de la version 9.0 de MongoDB :

rm -f /etc/yum.repos.d/mongodb-org-8.0.repo
cat << EOF > /etc/yum.repos.d/mongodb-org-9.0.repo
[mongodb-org-9.0]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/\$releasever/mongodb-org/9.0/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://pgp.mongodb.com/server-9.asc
EOF

Lancer la mise à jour :

dnf upgrade mongodb-org mongodb-org-database mongodb-org-server mongodb-org-mongos mongodb-org-tools -y

Redémarrer le service :

systemctl start mongod.service

Se connecter avec l'utilisateur root et terminer la mise à jour :

mongosh -u root -p root
> db.adminCommand( { setFeatureCompatibilityVersion: "9.0", confirm: true } )
> exit

Après la mise à jour, la télémétrie de MongoDB est activée. Pour la désactiver :

mongosh -u root -p root
> disableTelemetry()
> exit

Le fichier .env de référence de Canopsis 26.10 utilise l'image MongoDB 9.0.

Démarrez le conteneur mongodb :

CPS_EDITION=pro docker compose up -d mongodb

Entrez ensuite dans ce conteneur afin de terminer la mise à jour vers MongoDB 9.0 :

CPS_EDITION=pro docker compose exec mongodb bash
mongosh -u root -p root
> db.adminCommand( { setFeatureCompatibilityVersion: "9.0", confirm: true } )

Après la mise à jour, la télémétrie de MongoDB est activée. Pour la désactiver :

mongosh -u root -p root
> disableTelemetry()
> exit

Attention

Ce bloc est réservé uniquement aux environnements impliquant MongoDB exécuté dans un environnement Kubernetes.

Si ce n'est pas votre cas, référez-vous au bloc « RPM ».

Vous n'avez rien de particulier à prévoir, les configurations de référence livrées par Canopsis embarquent ce changement naturellement.

Mise à jour TimescaleDB

Dans cette version de Canopsis, la base de données TimescaleDB passe de la version 2.26 à 2.30.2.

Sauvegarder les bases de données canopsis et canopsis_tech_metrics

set -o allexport ; source /opt/canopsis/etc/go-engines-vars.conf
sudo -iu postgres pg_dump $(eval echo "$CPS_POSTGRES_URL") --no-owner -Fc -v -f /tmp/canopsis-$(date +"%Y-%m-%d")-canopsis-dump.sql.gz
sudo -iu postgres pg_dump $(eval echo "$CPS_POSTGRES_TECH_URL") --no-owner -Fc -v -f /tmp/canopsis-$(date +"%Y-%m-%d")-canopsis_tech_metrics-dump.sql.gz

Une fois les sauvegardes réalisées, supprimer le versionlock des paquets TimescaleDB

dnf versionlock delete timescaledb-2-postgresql-17
dnf versionlock delete timescaledb-2-loader-postgresql-17

Installer le paquet de la version de TimescaleDB :

dnf install timescaledb-2-postgresql-17-2.30.2 timescaledb-2-loader-postgresql-17-2.30.2

Réactiver le versionlock

dnf versionlock add timescaledb-2-loader-postgresql-17 timescaledb-2-postgresql-17

Redémarrer PostgreSQL, puis se connecter avec le compte administrateur sur la base :

systemctl restart postgresql-17
sudo -u postgres psql -X

Mettre à jour l'extension sur les bases de données canopsis et canopsis_tech_metrics :

postgres=# \c canopsis
canopsis=# ALTER EXTENSION timescaledb UPDATE;
canopsis=# \c canopsis_tech_metrics
canopsis_tech_metrics=# ALTER EXTENSION timescaledb UPDATE;
canopsis_tech_metrics=# \dx timescaledb

La colonne Version doit afficher 2.30.2 sur les deux bases.

Démarrez et mettez à jour l'extension TimescaleDB

CPS_EDITION=pro docker compose up -d timescaledb
CPS_EDITION=pro docker compose exec timescaledb psql -X postgresql://postgres:canopsis@timescaledb:5432/canopsis
canopsis=# ALTER EXTENSION timescaledb UPDATE;
canopsis=# \c canopsis_tech_metrics
canopsis_tech_metrics=# ALTER EXTENSION timescaledb UPDATE;
canopsis_tech_metrics=# \dx timescaledb

La colonne Version doit afficher 2.30.2 sur les deux bases.

Attention

Ce bloc est réservé uniquement aux environnements impliquant TimescaleDB exécuté dans un environnement Kubernetes.

Si ce n'est pas votre cas, référez-vous au bloc « RPM ».

Vous n'avez rien de particulier à prévoir, les configurations de référence livrées par Canopsis embarquent ce changement naturellement.

Mise à jour RabbitMQ

Dans cette version de Canopsis, le bus de données RabbitMQ passe de la version 4.2 à 4.3.

Feature flags

RabbitMQ refuse de démarrer en 4.3 si tous les feature flags de la 4.2 ne sont pas activés. Activez-les avant la mise à jour, RabbitMQ 4.2 étant démarré.

Activer tous les feature flags :

rabbitmqctl enable_feature_flag all

Retirer le versionlock de la version 4.2 de rabbitmq-server, puis appliquer celui pour la version 4.3 :

dnf versionlock delete 'rabbitmq-server-4.2*'
dnf versionlock add --raw 'rabbitmq-server-4.3*'

Stopper RabbitMQ

systemctl stop rabbitmq-server.service

Lancer la mise à jour :

dnf upgrade rabbitmq-server -y

Démarrer RabbitMQ

systemctl start rabbitmq-server.service

Vérifier la version de rabbitmq :

rabbitmqctl --version

La version affichée doit commencer par 4.3.

Avant d'arrêter l'environnement 26.04, activez les feature flags dans le conteneur rabbitmq :

CPS_EDITION=pro docker compose exec rabbitmq rabbitmqctl enable_feature_flag all

Si l'environnement est déjà arrêté, redémarrez uniquement le conteneur rabbitmq de la version 26.04 le temps de cette commande.

Les configurations de référence fournies dans Canopsis embarquent l'image RabbitMQ 4.3. Depuis le dossier de la version 26.10.0, démarrez le conteneur rabbitmq :

CPS_EDITION=pro docker compose up -d rabbitmq

Attention

Ce bloc est réservé uniquement aux environnements impliquant RabbitMQ exécuté dans un environnement Kubernetes.

Si ce n'est pas votre cas, référez-vous au bloc « RPM ».

Avant de poursuivre, activez les feature flags dans le pod canopsis-rabbitmq-0 de la version 26.04 :

kubectl exec -it -n canopsis canopsis-rabbitmq-0 -- rabbitmqctl enable_feature_flag all

Séparation de l'API publique et de l'API interne

Ce qui change

En 26.04, un seul service, canopsis-api, servait toute l'API sous /api/v4, à la fois pour l'interface web et pour vos scripts. En 26.10, il est remplacé par deux services :

Canopsis 26.04 Canopsis 26.10
Service (paquets RPM) canopsis-service@canopsis-api canopsis-service@canopsis-internal-api et canopsis-service@canopsis-public-api
Service (Docker Compose) api internalapi et publicapi
Binaire /opt/canopsis/bin/canopsis-api /opt/canopsis/bin/canopsis-internal-api et /opt/canopsis/bin/canopsis-public-api
Port 8082 8082 (API interne) et 8083 (API publique)
Préfixe des routes /api/v4 /internal (API interne) et /api/v5 (API publique)
Variable d'environnement CPS_API_URL CPS_INTERNAL_API_URL et CPS_PUBLIC_API_URL
Authentification des scripts authkey, authentification basique, jeton obtenu par /login jeton d'API publique (Authorization: Bearer <jeton>)
Documentation Swagger (-docs) /swagger/index.html /api/v5/docs/swagger.yaml

L'API interne reprend les routes de l'ancienne API v4 à l'identique, sous le préfixe /internal : /api/v4/alarms devient /internal/alarms. Elle est réservée à l'interface web et peut changer à chaque version.

L'API publique est la nouvelle API stable et versionnée, à utiliser pour tous vos scripts et intégrations. Ses routes, ses paramètres et son authentification sont différents de l'API v4 : voir Migrer vos scripts vers l'API publique.

Ce qui continue de fonctionner sans modification

Pour laisser le temps de migrer les scripts, la configuration Nginx fournie redirige /api/v4/<chemin> vers /internal/<chemin>, avec les anciennes méthodes d'authentification.

Un script qui appelle l'API à travers Nginx continue de fonctionner sans modification, par exemple :

curl -X POST -H "x-canopsis-authkey: $AUTHKEY" -H "Content-Type: application/json" \
  -d @event.json "https://canopsis.example.com/api/v4/event"

Compatibilité temporaire

Cette redirection et les anciennes méthodes d'authentification (authkey, authentification basique, jeton /login) seront supprimées dans une prochaine version. Les routes de l'API interne évoluent par ailleurs avec l'interface, sans préavis. Migrez vos scripts vers l'API publique dès cette version.

Ce qui cesse de fonctionner dès la mise à jour

Situation Exemple en 26.04 Correction en 26.10
Script qui appelle directement le port 8082 sans passer par Nginx curl -u user:mdp http://canopsis:8082/api/v4/event ... Migrer vers l'API publique : http://canopsis:8083/api/v5/event avec un jeton. À défaut, temporairement : http://canopsis:8082/internal/event
Reverse proxy personnalisé (autre que la configuration Nginx fournie) location /api/v4 { proxy_pass http://canopsis:8082; } Router /internal vers le port 8082, /api/v5 vers le port 8083, et réécrire /api/v4/<chemin> en /internal/<chemin> (voir Adapter un reverse proxy personnalisé)
Configuration Nginx fournie, mais modifiée localement (paquets RPM) /etc/nginx/conf.d/canopsis.conf personnalisé Le paquet ne remplace pas le fichier : reporter vos modifications dans le nouveau fichier (voir Adapter le déploiement)
Variable CPS_API_URL dans go-engines-vars.conf, canopsis.env, vos fichiers de surcharge ou vos outils CPS_API_URL=http://localhost:8082 CPS_INTERNAL_API_URL=http://localhost:8082 et CPS_PUBLIC_API_URL=http://localhost:8083
Commandes ou supervision qui visent le service canopsis-api systemctl restart canopsis-service@canopsis-api systemctl restart canopsis-service@canopsis-internal-api canopsis-service@canopsis-public-api
Surcharge Docker Compose du service api api: dans docker-compose.override.yml Renommer en internalapi: (ou publicapi: selon le besoin)
Option -secure ajoutée au service canopsis-api override systemd sur canopsis-service@canopsis-api.service.d Reporter l'override sur canopsis-service@canopsis-internal-api.service.d (voir Configurer le reverse proxy Nginx en HTTPS)
Outil export-alarms (Pro) configuré avec CPS_API_URL CPS_API_URL=http://localhost:8082 CPS_INTERNAL_API_URL=http://localhost:8082
Pare-feu ouvert uniquement sur le port 8082 pour les connecteurs flux connecteur → Canopsis TCP/8082 Ouvrir TCP/8083 pour les appels directs à l'API publique (ou passer par Nginx, TCP/443)
Lien vers la documentation Swagger http://canopsis:8082/swagger/index.html http://canopsis:8083/api/v5/docs/swagger.yaml

Adapter le déploiement

Ces étapes se font pendant la mise à jour, après la mise à jour des paquets ou des fichiers de configuration et avant le lancement de canopsis-reconfigure.

Avant la mise à jour des paquets, désactivez l'ancien service : son fichier d'unité est supprimé par la mise à jour.

systemctl disable canopsis-service@canopsis-api.service

Après la mise à jour des paquets :

  1. Variables d'environnement. Le fichier /opt/canopsis/etc/go-engines-vars.conf n'est pas remplacé s'il a été modifié ; la version de référence est alors installée à côté, sous le nom go-engines-vars.conf.rpmnew. Remplacez la ligne CPS_API_URL par les deux nouvelles variables :

    sed -i 's#^CPS_API_URL=.*#CPS_INTERNAL_API_URL="http://localhost:8082"\nCPS_PUBLIC_API_URL="http://localhost:8083"#' /opt/canopsis/etc/go-engines-vars.conf
    grep API_URL /opt/canopsis/etc/go-engines-vars.conf
    

    Résultat attendu :

    CPS_INTERNAL_API_URL="http://localhost:8082"
    CPS_PUBLIC_API_URL="http://localhost:8083"
    
  2. Configuration Nginx. Si /etc/nginx/conf.d/canopsis.conf avait été modifié, la nouvelle configuration est installée sous le nom canopsis.conf.rpmnew. Partez de ce nouveau fichier et reportez-y vos personnalisations :

    ls /etc/nginx/conf.d/canopsis.conf*
    diff /etc/nginx/conf.d/canopsis.conf.26.04 /etc/nginx/conf.d/canopsis.conf.rpmnew
    

    La nouvelle configuration doit contenir les deux adresses d'API et les trois routages :

    set $canopsis_internal_api_url http://127.0.0.1:8082;
    set $canopsis_public_api_url http://127.0.0.1:8083;
    ...
    location ~ ^/internal { ... proxy_pass $canopsis_internal_api_url; ... }
    location ~ ^/api/v5 { ... proxy_pass $canopsis_public_api_url; ... }
    location ~ ^/api/v4/(.*)$ { ... proxy_pass $canopsis_internal_api_url/internal/$1$is_args$args; ... }
    

    Elle modifie aussi la façon dont l'interface est servie (#6125) : les fichiers statiques sont servis directement, ou renvoient une erreur 404 s'ils n'existent pas, et toutes les autres adresses renvoient index.html. Si vous aviez personnalisé le bloc location /, reportez vos modifications sur ces deux blocs :

    location ~ \.\w+$ {
            include /etc/nginx/cors.inc;
            try_files $uri =404;
    }
    
    location / {
            try_files $uri $uri/ /index.html;
    }
    

    Vérifiez la configuration, puis rechargez Nginx :

    nginx -t && systemctl reload nginx
    
  3. Activer les deux nouveaux services :

    systemctl daemon-reload
    systemctl enable canopsis-service@canopsis-internal-api.service canopsis-service@canopsis-public-api.service
    
  4. Si vous aviez un override systemd sur l'ancien service (par exemple pour l'option -secure), recréez-le pour canopsis-service@canopsis-internal-api.service, puis supprimez l'ancien répertoire /etc/systemd/system/canopsis-service@canopsis-api.service.d.

  5. Ouvrez le port TCP/8083 dans le pare-feu si des scripts ou connecteurs appellent l'API publique sans passer par Nginx.

Les fichiers de référence 26.10 déclarent les services internalapi (port 8082) et publicapi (port 8083) à la place du service api.

  1. Dans canopsis.env, remplacez :

    CPS_API_URL=http://api:8082
    

    par :

    CPS_INTERNAL_API_URL=http://internalapi:8082
    CPS_PUBLIC_API_URL=http://publicapi:8083
    

    Le conteneur nginx utilise ces deux variables pour router /internal, /api/v5 et /api/v4.

  2. Dans docker-compose.override.yml, renommez toute surcharge du service api en internalapi. Exemple :

    # 26.04
    api:
      user: "1000:1000"
    # 26.10
    internalapi:
      user: "1000:1000"
    

    Une commande personnalisée command: /canopsis-api ... devient command: /canopsis-internal-api ....

  3. Toute commande d'exploitation qui visait le service api vise désormais internalapi :

    CPS_EDITION=pro docker compose restart internalapi
    CPS_EDITION=pro docker compose logs -f internalapi
    

Les configurations de référence livrées par Canopsis déploient les deux services. Vérifiez votre fichier de surcharges (par exemple customer-values.yaml) : toute valeur qui faisait référence à CPS_API_URL, au service api ou au chemin /api/v4 doit être adaptée comme décrit dans les onglets précédents.

Adapter un reverse proxy personnalisé

Si vous exposez Canopsis derrière un reverse proxy autre que la configuration Nginx fournie (load balancer, HAProxy, Apache, Nginx d'entreprise...), remplacez votre règle /api/v4 unique par les trois règles suivantes :

Requête reçue Destination
/internal... (dont /internal/ws) canopsis-internal-api, port 8082, chemin inchangé
/api/v5... canopsis-public-api, port 8083, chemin inchangé
/api/v4/<chemin> canopsis-internal-api, port 8082, chemin réécrit en /internal/<chemin>

Exemple pour Nginx :

location ~ ^/internal {
    proxy_pass http://canopsis:8082;
}
location ~ ^/api/v5 {
    proxy_pass http://canopsis:8083;
}
location ~ ^/api/v4/(.*)$ {
    proxy_pass http://canopsis:8082/internal/$1$is_args$args;
}

La WebSocket de l'interface utilise désormais /internal/ws : conservez les en-têtes Upgrade et Connection sur cette route.

Vérifier les deux API

Une fois Canopsis redémarré, les deux services doivent répondre :

# API publique : nom, version et lien vers la documentation, sans authentification
curl -s http://localhost:8083/api/v5/

# À travers Nginx
curl -s https://canopsis.example.com/api/v5/

# API interne, et compatibilité /api/v4 à travers Nginx
curl -s -u root:<mot de passe> https://canopsis.example.com/internal/app-info
curl -s -u root:<mot de passe> https://canopsis.example.com/api/v4/app-info

Image Nginx sans root

Concerne les installations Docker Compose et Helm.

  • L'image nginx-openshift n'est plus publiée : utilisez l'image nginx, qui convient à Docker, Kubernetes et OpenShift.
  • Le conteneur nginx s'exécute sans root, avec l'UID 101. Il écoute toujours sur les ports 8080 et 8443 du conteneur.
  • Avec HTTPS (CPS_ENABLE_HTTPS=true), le répertoire /etc/nginx/ssl et les fichiers cert.crt et key.key qu'il contient doivent être lisibles par l'UID 101. Si le répertoire est lisible mais pas les fichiers, le conteneur s'arrête avec le message TLS: certificate files found in /etc/nginx/ssl but cert.crt and key.key are not both readable by UID 101. Sans certificat monté, un certificat auto-signé est généré à chaque démarrage.

Répertoire /etc/nginx/ssl illisible

Si le répertoire /etc/nginx/ssl lui-même n'est pas lisible par l'UID 101, Nginx ne voit pas les certificats : il démarre sans erreur, avec le message TLS: no certificate provided in /etc/nginx/ssl, generating a self-signed one, et sert un certificat auto-signé à la place des vôtres. C'est le cas du volume nginxcerts créé par une version antérieure de l'environnement Docker Compose de référence.

Avec l'environnement Docker Compose de référence, les certificats sont dans le volume nginxcerts. Pour rendre le répertoire et les certificats lisibles par l'UID 101 :

CPS_EDITION=pro docker compose run --rm --no-deps --user 0 --entrypoint chown nginx 101:101 /etc/nginx/ssl /etc/nginx/ssl/cert.crt /etc/nginx/ssl/key.key

Cette commande est à lancer une seule fois : les droits sont conservés dans le volume. Relancez-la seulement si vous y déposez de nouveaux certificats, par exemple lors de leur renouvellement.

Après le démarrage de Canopsis, vérifiez que Nginx utilise bien vos certificats :

CPS_EDITION=pro docker compose logs nginx | grep TLS

Le message attendu est TLS: using the certificate mounted in /etc/nginx/ssl.

Mise à jour de Canopsis

Mise à jour des paquets

Désactiver l'ancien service API (voir Adapter le déploiement)

systemctl disable canopsis-service@canopsis-api.service

Supprimer le versionlock, mettre à jour les paquets de Canopsis, puis ajouter le versionlock de la version 26.10 :

dnf versionlock delete 'canopsis-26.04.*'
dnf versionlock delete 'canopsis-common-26.04.*'
dnf versionlock delete 'canopsis-webui-26.04.*'

dnf upgrade canopsis canopsis-webui

dnf versionlock add --raw 'canopsis-26.10.*'
dnf versionlock add --raw 'canopsis-common-26.10.*'
dnf versionlock add --raw 'canopsis-webui-26.10.*'
dnf versionlock delete 'canopsis-pro-26.04.*'
dnf versionlock delete 'canopsis-common-26.04.*'
dnf versionlock delete 'canopsis-webui-26.04.*'

dnf upgrade canopsis-pro canopsis-webui

dnf versionlock add --raw 'canopsis-pro-26.10.*'
dnf versionlock add --raw 'canopsis-common-26.10.*'
dnf versionlock add --raw 'canopsis-webui-26.10.*'

Le paquet canopsis-pro 26.10 demande MongoDB 9.0 (mongodb-org-tools 9.0) : la mise à jour de MongoDB doit avoir été faite avant cette étape.

Appliquer ensuite les étapes « Après la mise à jour des paquets » de Adapter le déploiement.

Information

Canopsis 26.10 est livré avec un nouveau jeu de configurations de référence. Vous devez télécharger ces configurations et y reporter vos personnalisations.

Cette étape est à réaliser dès l'arrêt de l'environnement, avant la mise à jour de MongoDB : si c'est déjà fait, passez à la section suivante.

Si vous êtes utilisateur de l'édition community, voici les étapes à suivre.

Télécharger le paquet de la version 26.10.0 (canopsis-community-docker-compose-26.10.0.tar.gz) disponible à cette adresse https://git.canopsis.net/canopsis/canopsis-community/-/releases.

export CPS_EDITION=community
tar xvfz canopsis-community-docker-compose-26.10.0.tar.gz
cd canopsis-community-docker-compose-26.10.0

Si vous êtes utilisateur de l'édition pro, voici les étapes à suivre.

Télécharger le paquet de la version 26.10.0 (canopsis-pro-docker-compose-26.10.0.tar.gz) disponible à cette adresse https://git.canopsis.net/sources/canopsis-pro-sources/-/releases.

export CPS_EDITION=pro
tar xvfz canopsis-pro-docker-compose-26.10.0.tar.gz
cd canopsis-pro-docker-compose-26.10.0

À ce stade, vous devez synchroniser les modifications réalisées sur vos anciens fichiers de configuration docker-compose avec les fichiers docker-compose.yml et/ou docker-compose.override.yml, en tenant compte du renommage du service api (voir Adapter le déploiement).

Information

Les valeurs par défaut des variables sont disponibles dans le fichier README.md disponible en faisant :

helm pull canopsis/canopsis-pro
tar xzvf canopsis-pro-*.tgz
cat canopsis-pro/README.md

Il est nécessaire de vérifier que vos valeurs sont bien à jour avant de réaliser les étapes suivantes.

Synchronisation du fichier de configuration canopsis.toml ou fichier de surcharge

Si vous avez modifié le fichier canopsis.toml (vous le voyez via une définition de volume dans votre fichier docker-compose.yml), vous devez vérifier qu'il soit bien à jour par rapport au fichier de référence.

Information

Pour éviter ce type de synchronisation fastidieuse, la bonne pratique est d'utiliser un fichier de surcharge de cette configuration.

Si vous avez utilisé un fichier de surcharge, alors vous n'avez rien à faire, uniquement continuer à le présenter dans un volume.

Lancement du provisioning canopsis-reconfigure et terminer la mise à jour.

Attention

Si vous avez personnalisé la ligne de commande de l'outil canopsis-reconfigure, nous vous conseillons de supprimer cette personnalisation. L'outil est en effet pré paramétré pour fonctionner naturellement.

Si un fichier d'override du canopsis.toml est utilisé, ajouter à la ligne de commande suivante l'option -override suivie du chemin du fichier en question.

Il est nécessaire de vérifier que les services postgresql-17.service et mongod.service sont bien démarrés puis lancer le reconfigure

systemctl status postgresql-17 mongod
set -o allexport ; source /opt/canopsis/etc/go-engines-vars.conf
/opt/canopsis/bin/canopsis-reconfigure -migrate-postgres=true -migrate-tech-postgres=true -migrate-mongo=true -edition pro

Information

Cette opération peut prendre plusieurs minutes pour s'exécuter.

Vous pouvez ensuite vérifier que le mécanisme de reconfigure s'est correctement déroulé en lisant les logs sur la sortie standard de la commande.

Activer et démarrer les deux services API, puis redémarrer Canopsis :

systemctl enable --now canopsis-service@canopsis-internal-api.service canopsis-service@canopsis-public-api.service
systemctl start canopsis

Vérifier que l'ensemble des services soient correctement exécutés, en particulier les deux services API.

systemctl status canopsis canopsis-service@canopsis-internal-api canopsis-service@canopsis-public-api

Par ailleurs, le mécanisme de bilan de santé intégré à Canopsis ne doit pas présenter d'erreur, et les deux API doivent répondre.

CPS_EDITION=pro docker compose up -d reconfigure

Information

Cette opération peut prendre plusieurs minutes pour s'exécuter.

Vous pouvez ensuite vérifier que le mécanisme de provisioning/reconfigure s'est correctement déroulé. Le conteneur doit présenter un "exit 0"

CPS_EDITION=pro docker compose ps -a|grep reconfigure
canopsis-pro-reconfigure-1            "/canopsis-reconfigu..."   reconfigure            exited (0)

Enfin, il vous reste à mettre à jour et à démarrer tous les composants applicatifs de Canopsis

CPS_EDITION=pro docker compose up -d

Vous pouvez ensuite vérifier que l'ensemble des conteneurs soient correctement exécutés, en particulier internalapi et publicapi.

CPS_EDITION=pro docker compose ps

Par ailleurs, le mécanisme de bilan de santé intégré à Canopsis ne doit pas présenter d'erreur, et les deux API doivent répondre.

Définir le nom de votre instance

export RELEASE_NAME="canopsis-prod"

Mise à jour des repos helm

helm repo update

Attention

Veillez à bien adapter la commande ci-dessous avec vos paramètres présent dans votre fichier de surcharges, par exemple customer-values.yml

Mise à jour de Canopsis

helm upgrade ${RELEASE_NAME} canopsis/canopsis-pro -f customer-values.yaml

Par ailleurs, le mécanisme de bilan de santé intégré à Canopsis ne doit pas présenter d'erreur, et les deux API doivent répondre.

Migrer vos scripts vers l'API publique

Cette étape peut être réalisée après la mise à jour, tant que vos scripts passent par Nginx (voir Ce qui continue de fonctionner sans modification). Elle doit être terminée avant la version qui supprimera la compatibilité /api/v4.

Dans les exemples suivants, $CPS est l'adresse de Canopsis (par exemple https://canopsis.example.com), $AUTHKEY l'authkey d'un utilisateur et $TOKEN un jeton d'API publique.

1. Créer un jeton d'API publique

L'API publique n'accepte ni l'authkey, ni l'authentification basique, ni les jetons obtenus par /login. Créez un jeton dans Administration > Jetons d'accès API, onglet Jetons d'API publique, avec un compte dédié à l'intégration (le jeton hérite de ses droits). La valeur du jeton n'est affichée qu'une seule fois, à sa création.

# 26.04
curl "$CPS/api/v4/entities?authkey=$AUTHKEY"
curl -H "x-canopsis-authkey: $AUTHKEY" "$CPS/api/v4/entities"
curl -u script:motdepasse "$CPS/api/v4/entities"

# 26.10
curl -H "Authorization: Bearer $TOKEN" "$CPS/api/v5/entities"

Les droits nécessaires ne changent pas : api_event pour envoyer des événements, api_alarm_read pour lire les alarmes, api_entity, api_pbehavior, api_acl...

2. Envoyer des événements

Le corps de la requête et la réponse sont identiques : seuls le préfixe et l'authentification changent. C'est la migration la plus fréquente, et la plus simple.

# 26.04
curl -X POST -u root:root -H "Content-Type: application/json" \
  "http://canopsis:8082/api/v4/event" -d @event.json

# 26.10
curl -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  "http://canopsis:8083/api/v5/event" -d @event.json

Contrôlez toujours failed_events et retry_events dans la réponse : un code 200 ne signifie pas que tous les événements ont été acceptés.

3. Lister des alarmes

Le paramètre resolution (open ou resolved) remplace opened et devient obligatoire. Les dates se filtrent avec time_field, from et to.

# 26.04 : alarmes en cours d'un composant, triées par date de création
curl -H "x-canopsis-authkey: $AUTHKEY" \
  "$CPS/api/v4/alarms?opened=true&search=srv-web-01&sort_by=t&sort=desc&page=1&limit=100"

# 26.10
curl -H "Authorization: Bearer $TOKEN" \
  "$CPS/api/v5/alarms?resolution=open&entity_component=srv-web-01&sort=creation_date:desc&offset=0&limit=100"
# 26.04 : alarmes résolues sur une période
curl -H "x-canopsis-authkey: $AUTHKEY" \
  "$CPS/api/v4/alarms?opened=false&tstart=1760479200&tstop=1760565600"

# 26.10
curl -H "Authorization: Bearer $TOKEN" \
  "$CPS/api/v5/alarms?resolution=resolved&time_field=resolved&from=1760479200&to=1760565600"

Les filtres category et tag acceptent désormais plusieurs valeurs (?tag=prod&tag=web). Les paramètres propres à l'interface (active_columns[], filters[], correlation, with_instructions, with_links, only_bookmarks...) n'existent pas dans l'API publique ; les liens (links) sont toujours inclus dans la réponse.

Les étapes d'une alarme ont une route dédiée : GET /api/v5/alarms/{id}/steps.

4. Paginer

La pagination par page est remplacée par une pagination par décalage, et le nombre total de résultats n'est plus calculé.

// 26.04
{ "data": [ ... ], "meta": { "page": 1, "per_page": 50, "page_count": 12, "total_count": 573 } }

// 26.10
{ "data": [ ... ], "meta": { "offset": 0, "limit": 50, "has_more": true } }
26.04 26.10
?page=3&limit=50 ?offset=100&limit=50
boucle tant que page <= meta.page_count boucle tant que meta.has_more vaut true
meta.total_count supprimé
# 26.04
page=1
while :; do
  body=$(curl -s -H "x-canopsis-authkey: $AUTHKEY" "$CPS/api/v4/entities?page=$page&limit=500")
  echo "$body" | jq -c '.data[]'
  [ "$page" -lt "$(echo "$body" | jq '.meta.page_count')" ] || break
  page=$((page + 1))
done

# 26.10
offset=0
while :; do
  body=$(curl -s -H "Authorization: Bearer $TOKEN" "$CPS/api/v5/entities?offset=$offset&limit=500")
  echo "$body" | jq -c '.data[]'
  [ "$(echo "$body" | jq '.meta.has_more')" = "true" ] || break
  offset=$((offset + 500))
done

5. Trier

26.04 26.10
?sort_by=name&sort=asc ?sort=name:asc
?multi_sort[]=t,asc&multi_sort[]=v.resource,desc ?sort=creation_date:asc,resource:desc

6. Filtrer avec un pattern

Les patterns ne passent plus dans l'URL, encodés : ils sont envoyés en JSON dans le corps d'une route POST .../search. La syntaxe des patterns ne change pas.

# 26.04 : alarmes en cours de criticité critique
curl -G -H "x-canopsis-authkey: $AUTHKEY" "$CPS/api/v4/alarms" \
  --data-urlencode 'opened=true' \
  --data-urlencode 'alarm_pattern=[[{"field":"v.state.val","cond":{"type":"eq","value":3}}]]'

# 26.10
curl -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  "$CPS/api/v5/alarms/search" -d '{
    "resolution": "open",
    "alarm_pattern": [[{"field":"v.state.val","cond":{"type":"eq","value":3}}]]
  }'

Même principe pour les entités : POST /api/v5/entities/search avec entity_pattern et pbehavior_pattern.

7. Exporter des alarmes ou des entités

Les routes passent au pluriel. Le déroulé ne change pas (création de la tâche, suivi, téléchargement), et le format json s'ajoute au csv.

# 26.04
curl -X POST -H "x-canopsis-authkey: $AUTHKEY" -H "Content-Type: application/json" \
  "$CPS/api/v4/alarm-export" -d '{"separator":"semicolon","fields":[...]}'

# 26.10
curl -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  "$CPS/api/v5/alarm-exports" -d '{
    "format": "csv", "delimiter": "semicolon", "resolution": "open",
    "fields": [{"name":"_id","label":"ID"},{"name":"entity.name","label":"Entité"}]
  }'

Le suivi se fait sur GET /api/v5/alarm-exports/{id} (attendre status à done), le téléchargement sur GET /api/v5/alarm-exports/{id}/download. Même chose pour entity-export qui devient entity-exports.

8. Importer des entités

L'import de contexte devient POST /api/v5/entity-imports, avec un paramètre source obligatoire qui identifie le système d'origine. Seul l'import partiel est conservé : chaque élément porte son action, et les entités absentes de l'import ne sont pas modifiées.

# 26.04
curl -X PUT -H "x-canopsis-authkey: $AUTHKEY" -H "Content-Type: application/json" \
  "$CPS/api/v4/contextgraph-import-partial" -d @entities.json
curl -H "x-canopsis-authkey: $AUTHKEY" "$CPS/api/v4/contextgraph-import-status/<id>"

# 26.10
curl -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  "$CPS/api/v5/entity-imports?source=cmdb" -d '[
    {"action":"set","name":"srv-web-01","type":"component","category":"web","impact_level":5},
    {"action":"disable","name":"srv-old-02","type":"component"}
  ]'
curl -H "Authorization: Bearer $TOKEN" "$CPS/api/v5/entity-imports/<id>"

Import complet

L'ancien import complet (PUT /api/v4/contextgraph-import) désactivait les entités absentes du fichier. Ce comportement n'existe plus : désactivez ou supprimez explicitement les entités avec l'action disable ou delete.

Les entités importées portent la source : elles se filtrent avec ?import_source=cmdb sur GET /api/v5/entities.

9. Opérations en masse

Les routes /bulk/... répondent toujours 207 Multi-Status, mais le résultat ne reprend plus l'élément envoyé (item). Associez les résultats aux éléments envoyés par leur position (même ordre que la requête) ou par id.

// 26.04
[ { "id": "pbh-1", "status": 200, "item": { "name": "Maintenance", ... } },
  { "status": 400, "item": { ... }, "errors": { "name": "The field is a required field" } } ]

// 26.10
[ { "id": "pbh-1", "status": 200 },
  { "status": 400, "errors": { "name": "The field is a required field" } } ]

Les routes d'activation et de désactivation en masse disparaissent au profit d'un PATCH :

# 26.04
curl -X PUT -H "x-canopsis-authkey: $AUTHKEY" -H "Content-Type: application/json" \
  "$CPS/api/v4/bulk/pbehaviors/disable" -d '[{"_id":"pbh-1"},{"_id":"pbh-2"}]'

# 26.10
curl -X PATCH -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  "$CPS/api/v5/bulk/pbehaviors" -d '[{"_id":"pbh-1","enabled":false},{"_id":"pbh-2","enabled":false}]'

Même principe pour les utilisateurs avec PATCH /api/v5/bulk/users.

10. Comportements périodiques de connecteur

Les plages de maintenance poussées par un outil de supervision (Centreon, Nagios...) passent par /bulk/connector-pbehaviors. Le corps ne change pas : seuls le préfixe et l'authentification changent.

# 26.04
curl -X POST -H "x-canopsis-authkey: $AUTHKEY" -H "Content-Type: application/json" \
  "$CPS/api/v4/bulk/connector-pbehaviors" -d @downtimes.json

# 26.10
curl -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  "$CPS/api/v5/bulk/connector-pbehaviors" -d '[{
    "origin": "centreon", "entities": ["srv-web-01/srv-web-01", "disk/srv-web-01"],
    "tstart": 1760518800, "tstop": 1760526000,
    "name": "Maintenance srv-web-01", "comment": "Changement de disque",
    "reason": "<id du motif>", "type": "<id du type>"
  }]'

PUT /api/v5/bulk/connector-pbehaviors crée et supprime en un seul appel (champ action à create ou delete sur chaque élément).

La route /api/v4/bulk/entity-pbehaviors (un comportement périodique sans dates par entité) n'a pas d'équivalent dans l'API publique : utilisez /bulk/connector-pbehaviors avec des dates de début et de fin.

11. Envoyer des résultats de tests JUnit (Pro)

# 26.04
curl -X POST "$CPS/api/v4/cat/junit/upload/reports?authkey=$AUTHKEY" -F 'files=@report.xml'

# 26.10 : plusieurs fichiers possibles par appel
curl -X POST -H "Authorization: Bearer $TOKEN" "$CPS/api/v5/test-reports" \
  -F 'files=@report-1.xml' -F 'files=@report-2.xml'
curl -X POST -H "Authorization: Bearer $TOKEN" "$CPS/api/v5/test-screenshots?suite_name=smoke-tests" \
  -F 'files=@login-failure.png'

12. Gérer des utilisateurs

L'API publique gère les utilisateurs à authentification externe (LDAP, CAS, SAML, OAuth...) : source et external_id sont obligatoires à la création, et il n'y a pas de champ password. Les comptes locaux se gèrent dans l'interface. Les préférences d'interface (defaultview, ui_language, ui_theme...) ne sont pas exposées.

curl -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  "$CPS/api/v5/users" -d '{
    "name": "jdupont", "email": "jean.dupont@example.com", "enabled": true,
    "roles": ["pilote"], "source": "ldap", "external_id": "uid=jdupont,ou=people,dc=example,dc=com"
  }'

Correspondance des routes

API v4 (26.04) API publique (26.10)
GET /api/v4/alarms GET /api/v5/alarms (sans pattern) ou POST /api/v5/alarms/search (avec pattern)
GET /api/v4/alarms/{id}, /alarm-details (étapes) GET /api/v5/alarms/{id}/steps
POST /api/v4/alarm-export, GET .../{id}, GET .../{id}/download POST /api/v5/alarm-exports, GET .../{id}, GET .../{id}/download
POST /api/v4/event POST /api/v5/event
GET /api/v4/entities GET /api/v5/entities ou POST /api/v5/entities/search
POST /api/v4/entity-export, GET .../{id}, GET .../{id}/download POST /api/v5/entity-exports, GET .../{id}, GET .../{id}/download
PUT /api/v4/contextgraph-import, PUT /api/v4/contextgraph-import-partial POST /api/v5/entity-imports?source=<nom>
GET /api/v4/contextgraph-import-status/{id} GET /api/v5/entity-imports/{id}
/api/v4/pbehaviors, /api/v4/pbehaviors/{id} /api/v5/pbehaviors, /api/v5/pbehaviors/{id}
/api/v4/bulk/pbehaviors /api/v5/bulk/pbehaviors
PUT /api/v4/bulk/pbehaviors/enable, /disable PATCH /api/v5/bulk/pbehaviors avec enabled
/api/v4/bulk/connector-pbehaviors /api/v5/bulk/connector-pbehaviors
/api/v4/pbehavior-reasons, /api/v4/pbehavior-types /api/v5/pbehavior-reasons, /api/v5/pbehavior-types
/api/v4/users, /api/v4/bulk/users /api/v5/users, /api/v5/bulk/users
PUT /api/v4/bulk/users/enable, /disable PATCH /api/v5/bulk/users avec enabled
POST /api/v4/cat/junit/upload/reports, /screenshots, /videos POST /api/v5/test-reports, /test-screenshots, /test-videos

Routes sans équivalent dans l'API publique :

  • DELETE /api/v4/pbehaviors?name=<nom> (suppression par nom) : recherchez le comportement périodique, puis supprimez-le par identifiant.
  • /api/v4/bulk/entity-pbehaviors : utilisez /api/v5/bulk/connector-pbehaviors, avec des dates de début et de fin.
  • Toutes les autres routes de l'API v4 (configuration des règles, scénarios, vues, widgets, bilan de santé...) relèvent de l'API interne. Si l'un de vos scripts en dépend, il continue de fonctionner à travers Nginx pendant la période de transition ; contactez le support pour signaler le besoin.

Liste de contrôle

  1. Faire l'inventaire des scripts, connecteurs et outils qui appellent /api/v4, et noter ceux qui appellent directement le port 8082 : ils cessent de fonctionner dès la mise à jour.
  2. Créer un jeton d'API publique par intégration, avec un compte dédié.
  3. Remplacer l'authkey, l'authentification basique ou le jeton /login par Authorization: Bearer <jeton>.
  4. Remplacer /api/v4 par /api/v5, et le port 8082 par 8083 pour les appels directs.
  5. Renommer les routes déplacées : alarm-export, entity-export, contextgraph-import, cat/junit/upload/*, et remplacer bulk/entity-pbehaviors par bulk/connector-pbehaviors.
  6. Ajouter resolution à chaque appel sur les alarmes.
  7. Passer la pagination de page à offset, boucler sur meta.has_more et ne plus utiliser meta.total_count.
  8. Passer le tri à sort=<champ>:<sens>.
  9. Déplacer les patterns vers POST /alarms/search et POST /entities/search.
  10. Adapter la lecture des réponses en masse (plus de champ item).

Autres changements à vérifier

Modèles de l'interface (Vue 3)

L'interface web utilise désormais Vue 3 et Vuetify 4. Les modèles que vous avez personnalisés (colonnes du Bac à alarmes, Plus d'infos, Météo des services) peuvent contenir des composants ou des classes CSS de Vuetify 2 qui n'ont plus d'effet.

  • Tailles d'icônes : remplacez les propriétés booléennes par la propriété size.

    <!-- 26.04 -->
    <v-icon small>help</v-icon>
    <!-- 26.10 -->
    <v-icon size="small">help</v-icon>
    
  • Classes internes des composants Vuetify 2 (v-tabs__bar, v-card__text, theme--light...) : elles ne produisent plus de mise en forme. Remplacez-les par vos propres styles.

  • Navigateurs : l'interface demande Chrome ou Edge 111, Firefox 114 ou Safari 16.4, ou plus récent. Vérifiez en particulier les postes et écrans d'affichage dont le navigateur n'est pas mis à jour.
  • Widgets et modules personnalisés (src/features) : ils doivent être portés vers Vue 3 avant d'être intégrés à cette version.

Après la mise à jour, ouvrez les vues qui utilisent des modèles personnalisés et vérifiez leur affichage.

Filtrage des modèles et des icônes personnalisées

Pour corriger des failles de sécurité (#6401), le contenu des modèles et des icônes personnalisées est désormais filtré plus strictement avant son affichage.

  • Modèles (widget Texte, colonnes du Bac à alarmes, Plus d'infos, Météo des services...) : les attributs Vue (v-if, v-for, v-html, :propriété, @événement...) et les attributs d'événement HTML (onclick, onerror...) sont supprimés, sauf ceux produits par les helpers de Canopsis. Un élément affiché sous condition avec v-if est donc toujours affiché. Utilisez les helpers Handlebars à la place.

    <!-- 26.04 -->
    <span v-if="alarm.v.state.val === 3">Critique</span>
    <!-- 26.10 -->
    {{#compare alarm.v.state.val '==' 3}}<span>Critique</span>{{/compare}}
    
  • Icônes personnalisées (menu Administration > Objets personnalisés > Icônes) : les éléments script, foreignObject, iframe, object et embed des fichiers SVG sont retirés à l'affichage.

Après la mise à jour, vérifiez l'affichage des vues dont les modèles contiennent des attributs Vue, et celui des icônes personnalisées.

Nom des règles et identifiants

Les filtres d'événements, les règles de méta-alarme et les informations dynamiques ont désormais un nom obligatoire et unique, et leur identifiant est généré automatiquement.

  • La migration de la base de données attribue un nom aux règles existantes : leur description, ou leur identifiant si la description est vide. Les noms en double reçoivent un suffixe (-1, -2...). Vérifiez les noms obtenus après la mise à jour.
  • Un script qui crée ces règles par l'API en imposant leur _id doit être adapté : l'identifiant envoyé à la création est ignoré (un identifiant est généré), et le champ name devient obligatoire pour les filtres d'événements.

Comportements périodiques de type Pause

La nouvelle action Pause remplace les comportements périodiques de type Pause sans date de fin, créés puis terminés au fil de l'eau. Les comportements périodiques existants continuent de s'appliquer : la migration vers l'action Pause n'est pas obligatoire, mais elle est recommandée si vous en créez un grand nombre.

  1. Dans les paramètres des widgets Bac à alarmes, section Pause, choisissez Action Pause et définissez les types de pause proposés aux pilotes.
  2. Dans vos scripts, remplacez la création d'un comportement périodique de type Pause par POST /api/v5/entities/pause, et l'ajout de sa date de fin par POST /api/v5/entities/resume.
  3. Dans les scénarios, remplacez l'action de création de comportement périodique par l'action Mettre en pause.
  4. Dans les filtres des vues, utilisez le champ d'entité Pause pour inclure ou exclure les alarmes en pause.

Voir Mettre une entité en pause.

Connecteur SNMP

Le connecteur snmp2canopsis n'accepte plus que les communautés SNMP v1/v2c listées dans communities (valeur par défaut : public). C'est le nouveau comportement par défaut (community_mode = allowlist) : après la mise à jour, les traps d'un équipement qui utilise une autre communauté sont rejetés, et n'arrivent plus dans Canopsis.

Avant la mise à jour du connecteur, recensez les communautés configurées sur vos équipements et ajoutez-les toutes au fichier de configuration :

[snmp]
community_mode = allowlist
communities = public, supervision-prod

Si vous ne connaissez pas toutes les communautés en service, utilisez temporairement community_mode = any, qui accepte toutes les communautés comme avant, le temps de les recenser, puis revenez à allowlist. Le connecteur journalise un avertissement au démarrage tant que ce mode est actif.

Après la mise à jour, un trap rejeté produit dans les journaux du connecteur l'avertissement Rejecting v1/v2c notification with community string not present in [snmp] communities. Pour des raisons de sécurité, la communauté rejetée n'y figure pas en clair : seule une empreinte (community_sha256_12) permet de distinguer les communautés rejetées.

En Docker, l'image du connecteur s'exécute avec un compte non root (UID/GID 10001) : donnez-lui la propriété du fichier de configuration monté et restreignez ses droits (chown 10001:10001 et chmod 0600). Voir SNMP trap vers Canopsis.

Réponse de la route healthcheck

La réponse de la route healthcheck de l'API interne, utilisée par le module Bilan de santé, remplace les booléens d'état par un statut et une liste d'anomalies (#6152) :

  • pour les services (MongoDB, Valkey, RabbitMQ, TimescaleDB), is_running est remplacé par status ;
  • pour les moteurs, is_running, is_queue_overflown, is_too_few_instances et is_diff_instances_config sont remplacés par status et issues.

status vaut healthy, degraded ou unhealthy. issues liste les anomalies détectées : node_down, quorum_degraded et no_quorum pour RabbitMQ, queue_overflowed, too_few_instances et instances_config_mismatch pour les moteurs.

Une supervision externe qui interroge cette route et lit is_running doit être adaptée :

// 26.04
{"name": "RabbitMQ", "is_running": true, "nodes": 3, "running_nodes": 2}

// 26.10
{"name": "RabbitMQ", "status": "degraded", "issues": ["node_down"], "nodes": 3, "running_nodes": 2}

Scénarios et règles de déclaration de ticket créés par l'API

Le champ emit_trigger est renommé emit_trigger_success, et un champ emit_trigger_fail est ajouté :

  • dans les actions des scénarios : emit_trigger_success est obligatoire. emit_trigger_fail est obligatoire pour une action webhook qui déclare un ticket (parameters.declare_ticket renseigné), et interdit pour toutes les autres actions ;
  • dans les règles de déclaration de ticket : les deux champs sont obligatoires.

Les scénarios et les règles existants sont migrés automatiquement. Un script qui crée ou modifie des scénarios ou des règles de déclaration de ticket par l'API doit être adapté :

// 26.04
"emit_trigger": true,

// 26.10, action sans déclaration de ticket
"emit_trigger_success": true,

// 26.10, webhook qui déclare un ticket, ou règle de déclaration de ticket
"emit_trigger_success": true,
"emit_trigger_fail": false,

Une requête qui envoie emit_trigger_fail pour une action sans déclaration de ticket est refusée (erreur 400).