Agents IA pour les opérations d'infrastructure

Les grands modèles de langage ont dépassé le stade des chatbots. Dans les opérations d'infrastructure, les agents IA peuvent réduire drastiquement le temps moyen de résolution (MTTR), automatiser les tâches routinières et augmenter les capacités des ingénieurs d'astreinte. Voici comment j'intègre des agents alimentés par des LLM dans les workflows opérationnels.

L'architecture d'un agent

Un agent ops efficace a besoin de trois capacités : observer (lire les métriques, logs, alertes), raisonner (analyser les patterns, corréler les événements) et agir (exécuter des runbooks, créer des tickets, envoyer des notifications).

from openai import OpenAI
import json

client = OpenAI()

tools = [
    {
        "type": "function",
        "function": {
            "name": "query_metrics",
            "description": "Interroger les métriques Prometheus pour un service donné",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Requête PromQL"},
                    "duration": {"type": "string", "description": "Plage temporelle, ex: '1h'"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_logs",
            "description": "Rechercher dans les logs applicatifs via Loki",
            "parameters": {
                "type": "object",
                "properties": {
                    "service": {"type": "string"},
                    "query": {"type": "string"},
                    "severity": {"type": "string", "enum": ["error", "warn", "info"]}
                },
                "required": ["service", "query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "execute_runbook",
            "description": "Exécuter une action de runbook prédéfinie",
            "parameters": {
                "type": "object",
                "properties": {
                    "runbook_id": {"type": "string"},
                    "parameters": {"type": "object"}
                },
                "required": ["runbook_id"]
            }
        }
    }
]

def handle_alert(alert: dict) -> str:
    messages = [
        {
            "role": "system",
            "content": "Tu es un agent SRE. Analyse les alertes, investigue les causes racines et exécute les runbooks quand c'est approprié."
        },
        {
            "role": "user",
            "content": f"Alerte déclenchée : {json.dumps(alert)}"
        }
    ]

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=tools
    )

    # L'agent traite les appels d'outils itérativement
    return process_agent_loop(response, messages)

Automatisation de la réponse aux incidents

Quand une alerte se déclenche, l'agent suit une investigation structurée :

1. Collecter le contexte : Interroger les métriques et logs pertinents autour du timestamp de l'alerte
2. Corréler les événements : Vérifier si des services liés sont également impactés
3. Identifier la cause racine : Comparer les patterns avec les problèmes connus
4. Exécuter la remédiation : Lancer le runbook approprié si le niveau de confiance est élevé
5. Documenter les découvertes : Créer un ticket d'incident avec le contexte complet

La clé est le seuil de confiance. Pour les problèmes bien compris (disque plein, pod en crash loop, expiration de certificat), l'agent peut agir de manière autonome. Pour les problèmes inédits, il escalade à un humain avec une analyse détaillée.

Routage intelligent des alertes

Toutes les alertes ne sont pas égales. Un agent IA peut trier les alertes selon leur sévérité, rayon d'impact et propriété du service :

def triage_alert(alert: dict) -> dict:
    """Analyser l'alerte et déterminer le routage."""
    analysis = client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "system",
            "content": """Trie cette alerte. Réponds en JSON :
            {
                "severity": "critical|high|medium|low",
                "team": "platform|backend|frontend|data",
                "suggested_runbook": "runbook-id ou null",
                "summary": "résumé en une ligne"
            }"""
        }, {
            "role": "user",
            "content": json.dumps(alert)
        }],
        response_format={"type": "json_object"}
    )

    return json.loads(analysis.choices[0].message.content)

Cela élimine la fatigue d'alerte en routant la bonne alerte à la bonne personne avec le bon contexte.

Gestion automatisée des tickets

L'une des applications avec le meilleur retour sur investissement est la création et l'enrichissement automatique des tickets. Quand l'agent détecte un problème, il crée un ticket avec :

• Les détails de l'alerte et la chronologie
• Les graphiques de métriques pertinentes (capturés sous forme de liens)
• Les extraits de logs montrant le pattern d'erreur
• Les incidents similaires passés et leurs résolutions
• Les étapes de remédiation suggérées

Cela transforme une alerte cryptique en un ticket actionnable, économisant 10-15 minutes par incident.

Garde-fous de sécurité

Les agents IA en production nécessitent des garde-fous stricts :

• Lecture seule par défaut : Les agents ne doivent avoir accès en écriture que pour des runbooks spécifiques et approuvés
• Humain dans la boucle : Les actions critiques (redémarrer un service de production, scaler l'infrastructure) nécessitent une approbation
• Piste d'audit : Chaque action de l'agent est enregistrée et vérifiable
• Kill switch : Capacité à désactiver instantanément l'agent s'il dysfonctionne

Résultats

Dans mes déploiements, les opérations assistées par IA ont produit :

• 40% de réduction du MTTR pour les patterns de problèmes connus
• 60% de pages en moins escaladées aux humains pendant les heures creuses
• 80% des tickets routiniers auto-enrichis avec le contexte d'investigation

L'objectif n'est pas de remplacer les ingénieurs d'astreinte — c'est de leur donner un assistant hautement capable qui gère la routine pour qu'ils puissent se concentrer sur le complexe.