Un nœud Linux ralentit, top affiche 80 % de CPU, et personne ne sait quel processus gêne les autres. C’est la question de départ de Linnix, et elle explique pourquoi la Linnix observabilité Linux mérite un coup d’œil : le projet cherche qui provoque les blocages, pas seulement qui consomme. Il s’appuie sur eBPF, sur les compteurs de pression du noyau (PSI) et, en option, sur un modèle de langage pour expliquer les incidents. Le dépôt est linnix-os/linnix.
Je pars de quatre décisions d’exploitation plutôt que d’un tour des fonctions : quel signal croire, ce qu’on accepte d’automatiser, quelle licence on signe, et comment surveiller l’agent lui-même.
Précision d’honnêteté : span.observer n’a pas installé ni lancé Linnix. Les faits viennent du README, de la documentation et des fichiers du dépôt, lus le 11 novembre 2026. Le nombre d’étoiles n’a pas pu être relu à la source : je ne le cite pas. Le dernier commit lu date du 19 septembre 2026, et cognitod/Cargo.toml indique la version 0.3.0. Un projet jeune : traitez-le comme un candidat à tester, pas comme une référence.
Linnix observabilité Linux : de l’usage CPU au temps perdu
Un conteneur qui consomme 100 % de CPU peut très bien ne rien perdre. Un autre, à 40 %, peut attendre son tour la moitié du temps. Le README défend cette idée : la pression (PSI) mesure l’attente réelle, alors que l’usage ne mesure que l’activité. Il donne un exemple : un pod à 40 % de CPU et 60 % de pression est plus mal en point qu’un pod à 100 % de CPU et 5 % de pression.
Le projet décrit trois étages. Le collecteur eBPF observe fork, exec, exit et les événements d’ordonnancement. Le démon cognitod agrège ces signaux avec l’arbre de processus. Une couche d’analyse, facultative, rédige l’explication. Le schéma ci-dessous est celui du dépôt, dans docs/images.

Un détail à noter : ce schéma affiche « Apache 2.0 license » en bas, alors que le reste du dépôt parle d’AGPL. Je reviens sur cette incohérence dans la partie licence.
Première décision : quel signal croire quand un pod ralentit ?
Le point fort annoncé est l’attribution : qui a volé du temps à qui. D’après le README, Linnix détecte les voisins bruyants, les tempêtes de fork, la saturation PSI et les fuites de mémoire. Le tableau de détection du README donne des seuils : un « circuit breaker » quand la pression dépasse 40 % avec plus de 90 % de CPU, et une tempête de fork au-delà de 10 créations par seconde pendant 2 secondes.
L’attribution sort en métriques Prometheus. Deux comptent pour un SRE :
linnix_pod_psi_pressure_total: la pression subie, en microsecondes, par pod victime ;linnix_stall_induced_seconds_total: le temps de blocage imputé à un pod coupable, étiqueté par couple coupable et victime.
Le README donne aussi des requêtes PromQL prêtes à l’emploi, par exemple celle qui classe les coupables d’une victime donnée :
sum by (offender_pod) (rate(linnix_stall_induced_seconds_total{victim_pod="payment-api"}[5m]))
Après coup, la commande linnix-cli investigate résume ces données. L’exemple ci-dessous vient du README : il n’a pas été exécuté ici.

Le projet insiste sur une nuance utile : c’est de l’attribution, pas de la causalité prouvée. Si rien n’a rivalisé, l’outil le dit au lieu de nommer un suspect. Pour confirmer, changez une chose et regardez si le blocage baisse. Cette prudence va dans le sens d’un tri des signaux, voir https://span.observer/fr/garde-fous-agents-ia-production/ pour la même logique appliquée aux agents.
Deuxième décision : que laisse-t-on faire à l’IA ?
Voici le point qui tient au titre du sujet. Dans la configuration d’exemple configs/linnix.toml, la section [reasoner] est activée et pointe vers un serveur local compatible OpenAI, avec le modèle linnix-3b-distilled. Le README précise pourtant que le modèle d’analyse est facultatif et désactivé par défaut au démarrage rapide ; l’option ./quickstart.sh --with-ai télécharge un modèle de 2,1 Go.

Deux garde-fous ressortent de la documentation :
- le fichier
SAFETY.mdannonce un mode « monitor-first » : le projet détecte et propose, mais ne tue ni ne bride rien sans configuration explicite ; - d’après la FAQ, on peut utiliser son propre modèle via un point d’accès compatible OpenAI, ou vider l’endpoint pour ne garder que les règles et les événements bruts.
Le CHANGELOG ajoute un détail rassurant : l’analyseur doit citer des faits numérotés, et une hypothèse qui cite un fait jamais fourni est écartée. Le projet stocke aussi la confiance déclarée par le modèle comme son estimation, non calibrée. Ma lecture : commencez sans IA, vérifiez que l’attribution tient, puis ajoutez le résumé en langage naturel. Les décisions importantes restent aux règles et aux humains.
Le dépôt propose enfin un serveur MCP, linnix-cli mcp serve, pour qu’un assistant interroge ce que le démon a observé. Pour l’isolation d’un tel serveur, voir https://span.observer/fr/serveur-mcp-stdio-isolation-commandes/.
Troisième décision : peut-on l’utiliser en entreprise ?
Le fichier LICENSE est le texte de l’AGPL-3.0, et Cargo.toml déclare AGPL-3.0-or-later pour l’agent. Le README sépare les composants : l’agent cognitod en AGPL-3.0, les programmes eBPF en « GPL-2.0 ou MIT », parce que le noyau exige une licence compatible GPL au chargement. Les fichiers Cargo.toml de ces programmes disent pourtant Apache-2.0, et le schéma aussi. Trois sources, trois réponses : demandez au projet de trancher avant d’embarquer ce code.
Que change l’AGPL pour vous ? La FAQ de licence du projet répond : installer et exécuter Linnix en interne, sans le modifier, ne pose pas de problème. L’obligation de partager les sources vise celui qui distribue le logiciel, ou qui en propose un service modifié à des tiers. Le projet propose aussi une licence commerciale pour les équipes dont le service juridique refuse l’AGPL.
Ceci n’est pas un avis juridique. Votre juriste doit lire le texte, surtout si vous modifiez le code, l’intégrez dans un produit ou l’exposez à des clients. Un point pratique : si vous patchez cognitod pour un usage interne, gardez les patchs dans un dépôt dont vous pourriez publier le contenu.
Mise en route et vérification
Le README propose deux voies. Sur Kubernetes, un DaemonSet :
kubectl create secret generic linnix-api-token \
--namespace default \
--from-literal=token="$(openssl rand -base64 32)"
kubectl apply -f k8s/
En local, avec Docker :
git clone https://github.com/linnix-os/linnix.git && cd linnix
./quickstart.sh
- Vérifiez la version du noyau : la FAQ fixe le minimum à Linux 5.12 sur x86_64 et 5.18 sur arm64.
- Contrôlez la présence de
/sys/kernel/btf/vmlinux: sans BTF, la télémétrie est dégradée. - Interrogez
/readyz: il renvoie 503 si les sondes eBPF ne sont pas attachées. - Importez
k8s/grafana/linnix-noisy-neighbor.jsondans Grafana pour la vue « qui bloque qui ».
Attention : le README signale que le DaemonSet fonctionne aujourd’hui en mode privilégié « pour simplifier ». SAFETY.md évoque, lui, les capacités CAP_BPF et CAP_PERFMON sans privileged: true. Les deux textes ne se recoupent pas : mesurez ce que votre politique de sécurité accepte. Le fichier de configuration d’exemple exige un jeton d’API (variable LINNIX_API_TOKEN) si l’API écoute hors boucle locale. Ne le stockez jamais dans un dépôt.
Observer l’observateur
Un agent qui voit tout doit aussi être surveillé. La FAQ explique que, si eBPF ne peut pas s’attacher, cognitod continue de servir la pression lue dans /proc/pressure : vous gardez le symptôme, mais vous perdez le coupable. Pour ne pas le découvrir pendant un incident, alertez sur linnix_kernel_instrumentation_active (1 si les sondes sont attachées, 0 sinon), exposée sur /metrics/prometheus.
Sur le coût, deux chiffres du projet coexistent. Le README annonce moins de 1 % de CPU pour le collecteur eBPF. Le document OVERHEAD.md mesure le démon en espace utilisateur, avec BPF désactivé, entre 3,63 % et 4,10 % d’un cœur selon le scénario. Le lien vers performance-proof.md, qui doit étayer le chiffre du noyau, pointe vers un fichier absent du dépôt cloné. Je ne reprends donc pas le « moins de 1 % » comme un fait mesuré : testez sur vos nœuds. Pour comparer avec d’autres approches eBPF, voir https://span.observer/fr/ebpf-kubernetes-cilium-hubble-flux-reseau/ et /?s=ebpf+sans+sidecar+service+mesh.
Limites à connaître
- Projet récent : version 0.3.0 dans le code, aucune page de versions relue, dernier commit lu en septembre 2026.
- Documentation parfois contradictoire (licence, privilèges), comme vu plus haut.
- Le DaemonSet est privilégié ; l’agent lit l’activité de tous les processus du nœud.
- Le README annonce que l’analyse reste locale, sauf si vous configurez Slack. Je n’ai pas audité le code pour le confirmer.
- Aucun chiffre de performance indépendant : tous viennent du projet.
Bonnes pratiques
- Testez sur un nœud hors production, avec un noyau récent et BTF.
- Gardez le mode « monitor » : pas d’action automatique avant des semaines d’observation.
- Alertez sur l’état de l’instrumentation, pas seulement sur les incidents.
- Faites relire la licence par votre juriste avant le déploiement.
- Complétez l’attribution par vos traces et vos journaux : elle désigne un voisin, pas une cause prouvée.
Questions fréquentes
Linnix est-il sous licence libre ?
L’agent est en AGPL-3.0, une licence libre avec copyleft réseau. Les programmes eBPF sont décrits en GPL-2.0 ou MIT, avec des mentions Apache-2.0 ailleurs : vérifiez avant de réutiliser ce code.
Faut-il un modèle de langage pour l’utiliser ?
Non, d’après le README et la FAQ. L’attribution des blocages fonctionne sans modèle ; l’IA ajoute des résumés en langage naturel.
Linnix remplace-t-il Prometheus ou un outil d’APM ?
Non. Il exporte ses métriques vers Prometheus et Grafana. Il répond à « qui gêne qui sur ce nœud », pas à « quelle requête est lente ».
Conclusion
Linnix pose une bonne question : qui provoque le blocage, pas qui consomme. Testez-le d’abord sans IA, mesurez son coût sur vos nœuds, clarifiez la licence, puis décidez. La promesse est séduisante et le projet jeune. Pour un autre projet du registre « Top repos », voir /?s=gatus+page+de+statut+alertes+yaml.
Ce blog est indépendant et non affilié à Dynatrace LLC. Linnix est un projet tiers, non édité par Dynatrace.