Des LLM si brûlants qu'ils trouent votre portefeuille
Vous vous souvenez des débuts du cloud ? Notre plus gros casse-tête FinOps, c'était la VM non taguée. Un dev lançait un serveur surdimensionné, oubliait de l'étiqueter, et BAM ! Une dépense non allouée, mystérieuse et agaçante, surgissait en fin de mois. Pénible, certes, mais le coût ne grimpait généralement que sur plusieurs semaines.
Eh bien, accrochez-vous. Le FinOps pour l'IA est là, et il va vous donner le tournis. Le nouveau trou noir budgétaire, ce n'est plus un serveur clandestin, ce sont les tokens hors de contrôle.
Quand un prompt non optimisé sollicite un LLM coûteux 100 fois par seconde, votre budget ne fuit pas… il explose. On parle de pics de coûts qui pulvérisent les budgets en quelques heures, pas en quelques mois.
La solution ? Déplacer notre attention du tagging d'infrastructure vers la télémétrie applicative. Suivre le coût de chaque token, en temps réel.
Cela devient particulièrement crucial dès qu'on parle d'agents IA — pas les chatbots où chaque session se rattache facilement à un utilisateur précis, mais bien un agent autonome susceptible de travailler pour toute une équipe.
FinOps pour l'IA : la télémétrie cloud ne suffit plus
L'ancienne méthode de suivi des coûts — via les factures du fournisseur cloud (Cost Explorer, Cost Management, etc.) — est trop lente et trop grossière pour l'usage des API d'IA.
Le tableau ci-dessous compare le FinOps 1.0 au FinOps émergent pour l'IA :
| Caractéristique | FinOps cloud des débuts | FinOps actuel pour l'IA (API)
|------------------|--------------------------------|----------------------------------------
| Unité de coût | Heure de VM, Go de stockage | Token d'entrée, token de sortie
-------------------|--------------------------------|-----------------------------------------
| Moteur de coût | Ressources inactives, | Efficacité du prompt,
| | egress réseau | choix du modèle
-------------------|--------------------------------|-----------------------------------------
| Visibilité | Logs de facturation quotidiens | Télémétrie temps réel par transaction
-------------------|--------------------------------|-----------------------------------------
| Outil d'optim. | Arrêter des serveurs | - Réécrire le prompt/code
| | | - Sélection de modèle en temps réel
-------------------|--------------------------------|-----------------------------------------
Pour vraiment maîtriser les coûts des applications d'IA, impossible d'attendre la facture. Il faut intégrer l'intelligence FinOps directement dans la couche applicative, en remontant chaque token envoyé ou reçu. C'est là qu'OpenTelemetry (OTel) entre en scène.
Tutoriel : instrumenter votre agent IA avec OpenTelemetry
OpenTelemetry est un framework open source qui propose un standard unique pour collecter les données d'observabilité (traces, métriques et logs). Nous allons utiliser ses capacités de tracing pour encapsuler nos appels LLM et y injecter le contexte FinOps qu'il nous faut.
L'exemple suivant montre comment mettre en œuvre le suivi de l'allocation des coûts FinOps pour les agents IA avec OpenTelemetry et l'Agent Development Kit (ADK) de Google.
Ce code est votre passeport vers la liberté FinOps. Il garantit que chaque token consommé par votre agent IA est instantanément tagué avec le bon propriétaire de budget. Fini les devinettes !
Le code entièrement exécutable est disponible ici : https://github.com/antweiss/finops-ai-otel.
AVERTISSEMENT IMPORTANT : à ne pas utiliser en production !
Pour ce tutoriel, nous utilisons ConsoleSpanExporter pour afficher les données de trace brutes dans votre terminal. En production, vous ne feriez JAMAIS cela !
À la place, vous remplaceriez l'exporteur console par un exporteur OTLP dédié qui envoie les données vers un backend robuste, par exemple :
- Google Cloud Trace : l'option native pour les utilisateurs de Google Cloud.
- Un backend d'observabilité managé : Jaeger, Datadog ou New Relic.
- Une plateforme dédiée à la gestion FinOps comme DoiT Cloud Intelligence
Ces backends vous permettent d'interroger et d'agréger les données, et d'exécuter des rapports FinOps du type : Affiche-moi le nombre total de tokens consommés où finops.project_code vaut "BLOG-FINOPS-001" sur les 30 derniers jours. Voilà comment transformer une trace en rapport de coûts !
Étapes 1 et 2 : préparer le terrain
Vous connaissez la chanson ! Clonez le dépôt, installez les dépendances et configurez votre clé API.
git clone https://github.com/antweiss/finops-ai-otel.git
cd finops-ai-otel
pip install -r requirements.txt
export GEMINI_API_KEY="YOUR_API_KEY_HERE"
Étape 3 : exécutez le code et regardez les tokens défiler !
Quand vous lancez le fichier agent.py, le superpouvoir FinOps s'active à l'intérieur de la fonction run_finops_session.
python agent.py
Comment les tags FinOps s'intègrent (décortiquons le code)
L'objectif : encapsuler toute l'activité de l'agent dans un span OpenTelemetry personnalisé qui transporte les détails de notre budget.
Démarrer le span FinOps :
with tracer.start_as_current_span("adk-agent-session") as span:
Toute l'astuce tient dans cette ligne ! On démarre un span et on le déclare comme span actif courant. Tout code instrumenté ensuite avec OTel (comme les appels LLM internes du Google ADK) créera automatiquement ses propres spans en tant qu'enfants de ce span parent actif.
Ajouter les métadonnées FinOps (tags) :
span.set_attribute("finops.team_id", team_id)
span.set_attribute("finops.project_code", project_code)
C'est ici que nous injectons les détails du centre de coûts ! Comme les spans internes de l'ADK (qui contiennent le décompte des tokens) sont enfants de ce span, votre backend de traces verra l'intégralité de l'usage des tokens directement rattachée au finops.project_code. Allocation résolue !
Les métriques FinOps essentielles
def setup_opentelemetry_tracer():
"""Configures the Tracer to output to the console for a runnable demo."""
# 1. Create a TracerProvider
provider = TracerProvider()
# 2. Add a simple processor that exports traces to the console
# This shows the raw trace data and attributes!
provider.add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))
# 3. Set it as the global provider
trace.set_tracer_provider(provider)
return trace.get_tracer("finops.adk.agent")
La sortie de ConsoleSpanExporter est votre rapport de coûts immédiat. Cherchez le span imbriqué de l'appel LLM pour obtenir le tableau complet et facturable (les attributs finops.* sont définis par le code d'exemple, tandis que les attributs et métriques llm.* proviennent du LLMAgent de l'ADK) :
FinOps avancé : propager les spans dans les flux multi-agents
Et qu'en est-il des workflows complexes où un agent délègue son travail à un autre ? C'est là que toute la puissance d'OpenTelemetry se révèle.
- Dans le modèle OTel, lorsqu'un agent (le parent) appelle un autre agent ou outil (l'enfant), le contexte de trace du span parent est automatiquement transmis tout au long de la chaîne d'appels.
- L'ensemble de la séquence d'agents et d'outils s'exécute au sein du contexte du span FinOps initial.
- Conséquence : un seul tag FinOps de haut niveau couvre toute la chorégraphie d'agents, complexe et multi-étapes — vous obtenez un rapport de coûts unifié et auditable pour l'ensemble du workflow ! Cette fonctionnalité est héritée de l'instrumentation OTel standard utilisée par l'ADK.
Liens
Pour aller plus loin sur les fondations qui rendent cette solution FinOps possible :
Confirme la prise en charge native et intégrée de l'instrumentation OpenTelemetry par l'ADK.
Explique les principes sous-jacents des spans, du contexte et de sa propagation.
Détaille les types d'agents (LlmAgent, SequentialAgent) qui tirent parti de ce tracing.
Dans le prochain article, nous verrons comment mettre en place des garde-fous efficaces pour maîtriser les coûts de vos applications d'IA.