• lien nᵒ 1 : Site web
• lien nᵒ 2 : Code source
• lien nᵒ 3 : Documentation
• lien nᵒ 4 : Image Docker

labels:
  maintenant.endpoint.http: "https://api:3000/health"
  maintenant.endpoint.interval: "15s"
  maintenant.alert.severity: "critical"
  maintenant.group: "production"

services:
  maintenant:
    image: ghcr.io/kolapsis/maintenant:latest
    ports:
      - "8080:8080"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /proc:/host/proc:ro
      - maintenant-data:/data
    environment:
      MAINTENANT_ADDR: "0.0.0.0:8080"
      MAINTENANT_DB: "/data/maintenant.db"
    restart: unless-stopped

volumes:
  maintenant-data:

Commentaires : voir le flux Atom ouvrir dans le navigateur

Le gaspillage du cloud, c'est un peu le secret de polichinelle du devops. Tout le monde sait qu'il y a des volumes EBS détachés qui traînent, des snapshots vieux de 6 mois, des Elastic IP à 3,65 $/mois qui servent à rien... mais bon, on nettoie pas. Parce qu'on a trop les miquettes de casser un truc en prod. Mais entre le volume de 500 Go "temporaire" créé en 2024 et le NAT Gateway qui facture 32 $/mois dans le vide, ça chiffre assez vite.

CleanCloud va vous permettre de remédier à ça. Il s'agit d'un petit CLI Python compatible Linux, macOS et Windows (dispo via pip ou pipx) qui va scanner vos comptes AWS et Azure pour débusquer toutes ces ressources orphelines. Le truc, c'est qu'il tourne uniquement en lecture seule, donc pas de mutation, pas de suppression, et zéro modification de tags. Lui se contente de regarder, de prendre des notes, et de vous sortir un bon vieux report.json ou CSV avec tout le détail.

Du coup, côté permissions IAM, c'est le strict minimum... 14 permissions en lecture seule type ec2:Describe*, s3:List* ou rds:DescribeDBInstances. C'est d'ailleurs bien fichu puisque le code vérifie statiquement via AST qu'aucun appel en écriture ne passe. Donc pas besoin de filer vos clés IAM à un outil tiers, et ça c'est plutôt rassurant pour les équipes sécu qui flippent (à juste titre) dès qu'on parle d'accès cloud.

L'outil embarque 20 règles de détection. 10 pour AWS, 10 pour Azure. Côté AWS, ça scanne comme vous l'aurez deviné les volumes EBS non attachés, les vieux snapshots, les logs CloudWatch en rétention infinie, les Elastic IP orphelines, les ENI détachées, les AMI créées en 2022 qui traînent, les NAT Gateways au repos, les instances RDS à l'arrêt...etc.

Côté Azure, même combat avec les disques managés, les IP publiques inutilisées, les VMs stoppées qui continuent de bouffer du stockage Premium SSD.

Pour chaque trouvaille, vous avez un score de confiance (LOW, MEDIUM, HIGH) et une estimation du coût mensuel gaspillé en dollars. En fait c'est assez bien foutu, le rapport vous donne le type de ressource, la région, l'âge du truc et combien ça vous coûte.

Hop, un pipx install cleancloud et c'est parti :

cleancloud scan --provider aws --all-regions

cleancloud demo

Ansible, c'est bien. Mais du YAML à perte de vue pour configurer trois serveurs c'est pas non plus l'idéal. Hé bien ça tombe bien car y'a maintenant pyinfra , qui fait tout pareil sauf qu'on écrit du Python. En gros, votre script de déploiement c'est juste du code Python normal avec des imports, des boucles, des conditions... tout ça, tout ça...

Ce projet existe depuis 2014, il est sous licence MIT et côté perfs, c'est de ce que j'ai lu, jusqu'à 10 fois plus rapide qu'Ansible sur des déploiements massifs (genre plusieurs milliers de machines). Bon, sur le papier c'est bien, mais en fait ça dépend surtout de votre infra SSH et de la latence réseau.

Alors ça marche comment ?

Hé bien vous installez le bazar avec uv tool install pyinfra et hop, vous pouvez déjà lancer des commandes sur vos serveurs comme ceci :

pyinfra mon-serveur.net exec -- echo "hello world"

Ça fonctionne en SSH sur le port 22, sur des conteneurs Docker, ou même en local. Le truc est complètement agentless, du coup pas besoin d'installer quoi que ce soit sur les machines cibles. Suffit d'un accès shell POSIX tout ce qu'il y a de plus classique et c'est réglé.

Bon, ça c'est pour l'ad-hoc mais en fait le vrai kiff, ce sont les opérations déclaratives. Je vous montre... Vous créez un fichier deploy.py et dedans, vous mettez ça :

from pyinfra.operations import apt, systemd

apt.packages(
 name="Install nginx",
 packages=["nginx"],
)

systemd.service(
 name="Ensure nginx is running",
 service="nginx.service",
 running=True,
 enabled=True,
)

targets = ["@docker/ubuntu", "mon-serveur.net", "autre-serveur.net"]

À l’heure où les infrastructures deviennent de plus en plus éphémères et complexes, les méthodes de monitoring traditionnelles atteignent leurs limites. De l’émergence de l’eBPF, qui permet une visibilité profonde et sans agent au cœur du noyau Linux, à l’adaptation de l’observabilité pour le Serverless, les entreprises basculent vers un modèle « as-Code ».

Cette convergence technologique ne se contente plus de surveiller la disponibilité des services ; elle intègre la donnée de performance dès la conception logicielle (Observability-as-Code), transformant l’infrastructure invisible en un système transparent, automatisé et hautement résilient.

eBPF : Le « super-pouvoir » du noyau

Cet article sur l’eBPF (Extended Berkeley Packet Filter) explique comment cette technologie révolutionne le DevOps. Traditionnellement, pour surveiller un système, il fallait modifier le code de l’application ou charger des modules noyau risqués.

> Le concept : eBPF permet d’exécuter des programmes directement dans le noyau Linux de manière sécurisée, sans changer une seule ligne de code applicatif.

> L’avantage DevOps : Une visibilité totale sur le réseau, la sécurité et les performances avec un impact quasi nul sur les ressources. C’est la fin des agents « lourds » qui ralentissent les serveurs.

A lire : https://www.silicon.fr/cloud-1370/ebpf-devops-225348

Le défi de l’observabilité Serverless

Cet article traite de la complexité du Serverless (comme AWS Lambda). Puisque vous ne gérez plus le serveur, vous perdez l’accès aux métriques matérielles classiques.

> Le problème : Les fonctions sont éphémères (elles apparaissent et disparaissent en quelques millisecondes). Les outils de monitoring classiques sont souvent trop lents pour les capturer.

> La solution : Le traçage distribué. L’accent est mis sur le suivi de la requête à travers tous les services plutôt que sur la santé d’un serveur spécifique.

A lire : https://www.silicon.fr/cloud-1370/observabilite-serverless-225361

L’Observability-as-Code (OaC)

Cet article prône l’intégration de l’observabilité directement dans le cycle de développement, au même titre que l’Infrastructure-as-Code (Terraform, CloudFormation).

> L’idée : Au lieu de configurer manuellement des alertes et des tableaux de bord après le déploiement, vous les définissez dans votre code YAML ou JSON.

> L’objectif : Garantir que chaque nouveau microservice est « né » avec ses propres outils de mesure, évitant ainsi les angles morts lors des mises en production rapides.

A lire :  https://www.silicon.fr/cloud-1370/observability-as-code-225520

The post Observabilité native : la nouvelle frontière du Cloud et du DevOps appeared first on Silicon.fr.

Pas besoin de scripts ; juste des fichiers de configuration décrivant l’état des hôtes.

Telle était la promesse de CFEngine lorsqu’il émergea dans les années 90. Avec son langage dédié, l’outil devait faciliter la maintenance des environnements BSD et System V (UNIX) en les organisant en classes. Il s’agissait déjà de répondre à la fragmentation des systèmes d’information…

Dans les années 2000, Puppet et Chef sont arrivés sur le même créneau, chacun avec son langage basé sur Ruby. L’un et l’autre fonctionnaient en mode pull, le client contactant régulièrement le serveur pour récupérer la configuration. On ne parlait pas encore de DevOps, mais d’automatisation du travail des sysadmins.

Au début des années 2010, AWS pousse le templating JSON/YAML avec CloudFormation. Ansible décline le concept en playbooks. Terraform l’adopte avec son propre langage (HCL) et le porte à l’échelle de déploiements multifournisseurs.

Face aux limites des langages dédiés et de l’option « tout YAML » apparaissent des outils comme Pulumi, qui adaptent les langages impératifs (Go, Python…) à la gestion d’infrastructure.

La recette IaC déclinée sur l’observabilité…

Avec ce bagage, l’approche « as code » s’est développée sur d’autres pans des systèmes informatiques : documentation, sécurité, politiques organisationnelles… ou encore observabilité. Dashboards, alertes, logs, traces, métriques, SLO/SLI, etc. deviennent autant d’éléments « codifiés » sur le même plan que l’infra ; et, in fine, déployés en parallèle, avec un repo Git comme « source de vérité ».

Corollaire de cette convergence, l’observability as code (OaC) porte globalement les mêmes promesses que l’infrastructure as code (IaC). À commencer par les bénéfices de l’automatisation.
Sur le papier, outre la réduction du potentiel d’erreurs humaines, on a des configurations reproductibles favorisant la cohérence entre environnements et la mise à l’échelle dans le contexte d’architectures dynamiques (microservices, workloads IA). On crée par ailleurs une boucle de rétroaction avec l’IaC, en bénéficiant de la traçabilité de Git – lequel permet aussi, en théorie, une reconstruction rapide de la stack d’observabilité.

… avec un bouquet d’abstractions

En parallèle de leurs API, les principales solutions d’observabilité sont pilotables via Terraform, grâce à un provider. Elles proposent aussi d’empaqueter des configurations en charts Helm et d’utiliser des CRD pour définir des artefacts en tant qu’objets Kubernetes standards.

À cheval entre ces deux univers, il y a le projet Upjet. Celui-ci transforme les providers Terraform en providers Crossplane, tout en générant les contrôleurs de réconciliation et la documentation API avec des exemples de manifestes.

Du côté de Grafana, on expérimente actuellement une fonctionnalité Git Sync. Elle assure une synchronisation bidirectionnelle l’UI et le Git, avec la possibilité d’imposer que les changements réalisés sur l’interface passent par des PR. Pour le moment, certains artefacts ne sont pas pris en charge (alertes, panels…) et seul GitHub est géré (authentification par PAT uniquement).

Grafana a aussi, dans sa boîte à outils, un SDK Foundation orienté sur les langages à typage fort (on définit des dashboards en chaînant des appels de méthodes). Il a également une bibliothèque qui met en œuvre Jsonnet. Cette extension de JSON a été influencée par plusieurs langages de configuration utilisés chez Google. Elle facilite les regroupements logiques de configurations avec ajustement des variables à la volée pour contextualiser les artefacts.

À partir de Jsonnet, Prometheus a créé les mixins. Ce format encapsule des alertes/règles et des dashboards Grafana en compagnie du code avec lequel ils sont déployés.

Autre langage qui a ses racines chez Google : CUE (Configure, Unify, Execute). Il s’est en l’occurrence inspiré du langage utilisé pour configurer Borg, le prédécesseur de Kubernetes. En son cœur, une technique communément exploitée en linguistique informatique pour gérer grammaires et lexiques : l’unification de graphe. Types et valeurs sont fusionnés en un seul concept et ordonnés en une hiérarchie unique.
Associatif, CUE est aussi commutatif et idempotent : peu importe leur ordre, les valeurs produisent toujours le même résultat. On s’en servira typiquement pour la validation de schémas ou de données. Les types agissent alors comme des contraintes, réconciliables depuis plusieurs sources sans avoir à effectuer d’importations.

Des stacks open source aux plates-formes d’observabilité

À petite échelle, un pattern traditionnel de déploiement de l’OaC repose sur la pile open source* Prometheus/Grafana/Loki/Jaeger. Souvent en monorepo avec un dossier pour les artefacts d’observabilité, un déploiement Helm ou CI/CD simple et une synchro par Git Sync ou API/webhooks.

À un deuxième niveau, chaque équipe possède son repo et sa configuration d’observabilité (« You build it, you run it »). Le déploiement peut impliquer Kustomize. Cet outil de gestion intégré à Kubernetes se distingue de Helm en permettant de surcharger toute valeur d’une configuration de base.
À ce même niveau, on voit souvent apparaître une gestion GitOps (réconciliation automatisée avec Flux ou Argo CD). Et le recours au collecteur OpenTelemetry pour standardiser la collecte sans modifier la couche d’instrumentation.

Viennent ensuite les plates-formes d’observabilité. À ce niveau, les identités machine se généralisent dans les pipelines. Et, avec elles, les systèmes de promotion automatisée, le contrôle de cardinalité (liste blanche de tags, politiques d’échantillonnage avec des outils comme Cribl et Vector) voire l’exploitation d’eBPF.

« Tout le monde échantillonne la data. La seule raison pour laquelle on le fait, c’est le coût de stockage », explique à ce sujet Stéphane Estevez, EMEA Market Advisor observabilité chez Splunk. Sa société, poursuit-il, a l’avantage de la taille : « Par rapport à nos concurrents, nos économies d’échelle ne sont pas les mêmes. On peut se permettre d’être compétitif tout en garantissant toutes les données ».

Vodafone en est arrivé à ce dernier stade. Il a plus précisément mis en place des modules d’observabilité Terraform. Ses développeurs consomment en self-service (ils n’ont qu’à déclarer les variables) et peuvent les modifier par PR.
Vu le nombre de développeurs, de services et d’artefacts d’observabilité, il a fallu diviser le fichier d’état (Terraform mettait sinon 17 minutes à s’exécuter).

Accepter la codebase comme « source de vérité »

Que ce soit pour créer un dashboard lors d’un incident ou modifier des seuils afin de « faire taire » des alertes, dans une approche OaC, l’utilisation de l’UI soulève la question de la réconciliation avec la partie as code. Une des réponses consiste à n’autoriser que ce qui passe par cette dernière, au minimum en production. Une autre, à verrouiller les états pour éviter les corruptions.

« Si on pousse la logique OaC, il faut accepter que la source de vérité, c’est ce qui est dans la codebase », confirme Pejman Tabassomi, Field CTO EMEA de Datadog.

Quant à enrichir l’OaC avec du machine learning, ce n’est pas forcément si évident. IBM, qui a son Cloud Pak for AIOps (évolutions des outils de Tivoli), en témoigne par la voie d’Éric Cattoir. L’intéressé fait partie d’une équipe technique au niveau EMEA couvrant les sujets regroupés sous la marque IT Automation. « On a essayé de faire des modèles basés sur l’analyse des logs, explique-t-il. On s’est aperçu que cette fonctionnalité dépend beaucoup de la structure et de la stabilité des fichiers. Chez certains clients, ça a nécessité beaucoup de rééducation des modèles, car il y avait trop de variabilité entre leurs systèmes ».

* Dans le domaine de l’open source, le projet Perses, en sandbox à la CNCF, pousse une spécification ouverte pour la visualisation des données d’observabilité. Pour le moment, métriques Prometheus, traces Tempo, logs Loki et profilage Pyroscope. Il inclut un vérificateur statique, un opérateur Kubernetes et un CLI pour réaliser des actions dans les pipelines CI/CD. Des SDK Go et CUE implémentent l’approche « as code ».

Illustration principale © Aryan – Adobe Stock

The post De l’infra à l’observabilité, mille et une nuances « as code » appeared first on Silicon.fr.