Introduction

La gestion des clusters Kubernetes est complexe, avec des problèmes fréquents tels que les erreurs de configuration, les crashes de pods, les problèmes de réseau ou les ressources mal allouées. Ces problèmes nécessitent souvent une expertise approfondie et une analyse fastidieuse des logs et des événements.

K8sGPT est un outil innovant qui combine l’intelligence artificielle et le traitement du langage naturel pour automatiser le diagnostic et la résolution des problèmes Kubernetes. En s’intégrant dans un cluster Azure Kubernetes Service (AKS), K8sGPT permet aux équipes SRE et DevOps de gagner un temps précieux en fournissant des analyses claires et des recommandations actionnables.

Ce guide technique détaillé explique comment déployer K8sGPT dans un cluster AKS, comment configurer cet outil pour surveiller et résoudre automatiquement les problèmes courants. Il s’adresse à des lecteurs ayant des connaissances intermédiaires à avancées en Kubernetes, Azure, et Terraform, et s’appuie sur des sources officielles et des retours d’expérience concrets.

Comprendre K8sGPT et son rôle dans le diagnostic Kubernetes

K8sGPT est un outil open-source qui utilise des modèles d’IA (LLM) pour analyser les ressources, logs et événements Kubernetes afin de détecter automatiquement les problèmes de configuration, les erreurs de fonctionnement, et les optimisations possibles.

Il propose deux modes principaux :

• Mode CLI : pour des analyses ponctuelles et interactives, où l’utilisateur lance des commandes pour scanner le cluster et obtenir des diagnostics détaillés.

• Mode Operator : pour une surveillance continue dans le cluster, où K8sGPT s’exécute en tant que ressource Kubernetes et génère des rapports automatiques.

K8sGPT intègre des analyseurs pour les Pods, Services, PVC, Deployments, HPA, Ingress, et d’autres ressources Kubernetes. Il peut également être étendu via des analyseurs personnalisés. L’outil s’appuie sur des backends IA tels que OpenAI, Azure OpenAI, ou des modèles locaux, pour fournir des explications claires et des solutions précises aux problèmes détectés.

Cette capacité à traduire des erreurs techniques complexes en langage naturel et à proposer des correctifs automatisés en fait un assistant précieux pour les équipes SRE, réduisant significativement le temps de résolution des incidents et améliorant la fiabilité des clusters Kubernetes.

Utilisation en CLI

Installation de K8sGPT CLI sur Windows

Pour récupérer les binaires de K8sGPT, il suffit de se rendre à la page suivante https://github.com/k8sgpt-ai/k8sgpt/releases, de télécharger et d’extraire le binaire dans un répertoire de votre poste.

Sinon vous pouvez utiliser mon script PowerShell :

# =============================================================================
# Script pour télécharger, installer et configurer la dernière version de k8sGPT
# =============================================================================

# --- Paramètres ---
$downloadUrl = "https://github.com/k8sgpt-ai/k8sgpt/releases/latest/download/k8sgpt_Windows_x86_64.zip"
$installDir = "C:\tools\k8sgpt"
$zipFileName = "k8sgpt.zip"
$tempZipPath = Join-Path $env:TEMP $zipFileName

# --- Début du Script ---

Write-Host "Début de l'installation de k8sGPT..."

# Étape 1: Télécharger la dernière version
try {
    Write-Host "Téléchargement de k8sGPT depuis $downloadUrl..."
    Invoke-WebRequest -Uri $downloadUrl -OutFile $tempZipPath -UseBasicParsing
    Write-Host "Téléchargement terminé avec succès."
}
catch {
    Write-Error "Échec du téléchargement. Erreur: $($_.Exception.Message)"
    # Arrête le script en cas d'échec du téléchargement
    exit 1
}

# Étape 2: Créer le répertoire d'installation s'il n'existe pas
if (-not (Test-Path -Path $installDir)) {
    Write-Host "Création du répertoire d'installation : $installDir"
    New-Item -ItemType Directory -Path $installDir | Out-Null
}

# Étape 3: Extraire le contenu du ZIP en écrasant les fichiers existants
try {
    Write-Host "Extraction de $tempZipPath vers $installDir..."
    # L'option -Force permet d'écraser les fichiers existants
    Expand-Archive -Path $tempZipPath -DestinationPath $installDir -Force
    Write-Host "Extraction terminée."
}
catch {
    Write-Error "Échec de l'extraction. Erreur: $($_.Exception.Message)"
    exit 1
}
finally {
    # Nettoyer le fichier ZIP téléchargé
    Write-Host "Nettoyage du fichier ZIP temporaire..."
    Remove-Item -Path $tempZipPath -Force
}

# Étape 4: Ajouter le répertoire au PATH de l'utilisateur s'il n'y est pas déjà
Write-Host "Vérification de la variable d'environnement PATH..."

# Récupère le PATH pour l'utilisateur courant
$userPath = [System.Environment]::GetEnvironmentVariable('Path', 'User')
$pathEntries = $userPath -split ';'

# Vérifie si le chemin est déjà dans le PATH (insensible à la casse)
if ($pathEntries -notcontains $installDir) {
    Write-Host "Ajout de '$installDir' à la variable PATH de l'utilisateur."

    # Construit le nouveau PATH
    $newPath = ($userPath, $installDir) -join ';'

    # Met à jour la variable d'environnement de manière persistante
    [System.Environment]::SetEnvironmentVariable('Path', $newPath, 'User')

    Write-Host "Le PATH a été mis à jour. Vous devrez redémarrer votre console pour que les changements prennent effet."
}
else {
    Write-Host "'$installDir' est déjà présent dans le PATH. Aucune modification n'est nécessaire."
}

Write-Host "Installation de k8sGPT terminée avec succès !"
Write-Host "Veuillez ouvrir une nouvelle console PowerShell pour utiliser la commande 'k8sgpt'."

Comment utiliser ce script :

1. Enregistrez le code ci-dessus dans un fichier nommé Install-K8sGPT.ps1

2. Ouvrez une console PowerShell en tant qu'administrateur (recommandé pour créer des dossiers à la racine de et modifier le PATH sans problème).

3. Naviguez jusqu'au répertoire où vous avez enregistré le script.

4. Exécutez le script. Si la politique d'exécution des scripts vous bloque, vous pouvez utiliser la commande suivante :

    Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope Process -Force
    .\Install-K8sGPT.ps1
   

   

5. Une fois le script terminé, fermez votre console PowerShell et ouvrez-en une nouvelle.

6. Vous pouvez maintenant taper k8sgpt directement dans la console pour l'utiliser:

Configuration en utilisant un backend Azure Open AI

Maintenant que l'outil k8sgpt est installé sur votre poste, l'étape suivante consiste à le connecter à un backend d'intelligence artificielle. Ce guide détaille comment le configurer pour utiliser votre propre service Azure OpenAI.

Prérequis

• Un abonnement Azure actif.

• Les permissions nécessaires pour créer et gérer des ressources Azure OpenAI (par exemple, le rôle Cognitive Services OpenAI Contributor).

• Une ressource Azure OpenAI déjà créée et un modèle déployé.

Récupérer les informations de votre service Azure OpenAI

Connectez-vous au portail Azure ou à Azure AI Studio pour rassembler les quatre informations essentielles suivantes.

1. Point de terminaison (Endpoint URL)

   • C'est l'URL de base de votre service Azure OpenAI.

   • Où le trouver ? Dans le portail Azure, naviguez vers votre ressource Azure OpenAI. Dans le menu de gauche, sous Gestion des ressources, sélectionnez Clés et point de terminaison. Copiez la valeur du champ Point de terminaison.

   • Exemple : https://mon-service-openai.openai.azure.com/

2. Nom du déploiement (Deployment Name / Engine)

   • C'est le nom personnalisé que vous avez donné à votre modèle lorsque vous l'avez déployé dans Azure OpenAI Studio. C'est ce que k8sGPT appelle le "moteur" (engine).

   • Où le trouver ? Dans Azure AI Studio, allez dans la section Déploiements. Vous y verrez le nom de votre déploiement.

   • Exemple : gpt-4-prod

3. Nom du modèle de base (Base Model)

   • Il s'agit du nom du modèle sous-jacent que votre déploiement utilise.

   • Où le trouver ? Dans la même page Déploiements d'Azure AI Studio, le nom du modèle de base est listé à côté de votre nom de déploiement.

   • Exemple : gpt-4 ou gpt-35-turbo

4. Clé API (API Key)

   • C'est le secret qui permet à k8sGPT de s'authentifier auprès de votre service.

   • Où la trouver ? Retournez dans la section Clés et point de terminaison de votre ressource. Vous pouvez utiliser soit la CLÉ 1 soit la CLÉ 2.

   • Exemple : a1b2c3d4e5f67890a1b2c3d4e5f67890

Configurer l'authentification dans k8sGPT

Ouvrez une nouvelle console PowerShell et utilisez la commande k8sgpt auth add avec les informations que vous venez de collecter.

Remplacez les valeurs entre <...> par les vôtres.

k8sgpt auth add --backend azureopenai 
                --baseurl https://<your Azure OpenAI endpoint> 
                --engine <deployment_name> 
                --model <model_name>

Exemple concret:

k8sgpt auth add --backend azureopenai 
                --baseurl https://demo-openai.openai.azure.com/ 
                --engine gpt-5-mini
                --model gpt-5-mini

Puis ajouter votre clé API :

Vérifier la configuration

Pour vous assurer que la configuration est correcte, vous pouvez lister les fournisseurs configurés :

k8sgpt auth list

Vous pouvez modifier la configuration par défaut pour utiliser azureopenai via cette commande:

k8sgpt auth default -p azureopenai

Prérequis pour le déploiement de K8sGPT dans AKS

Avant de déployer K8sGPT, il est nécessaire de disposer d’un cluster AKS opérationnel avec les configurations suivantes :

• Cluster AKS : Créé avec des zones de disponibilité pour assurer la haute disponibilité des nœuds et des services.

• Réseau : Configuration des paramètres réseau adaptés, notamment la gestion des dépendances sortantes via FQDN.

• Azure Monitor : Intégration pour la centralisation des logs et métriques, permettant à K8sGPT d’exploiter ces données pour le diagnostic.

• Outils : Azure CLI, kubectl, Helm, Terraform installés localement.

• Permissions : Accès aux ressources Azure avec les droits nécessaires pour créer et gérer AKS, ainsi que pour déployer des applications dans le cluster.

• Backend IA : Clé API et configuration pour OpenAI, Azure OpenAI, ou autre backend IA compatible.

Ces prérequis garantissent que K8sGPT pourra fonctionner efficacement dans un environnement AKS sécurisé et scalable.

Architecture du déploiement K8sGPT dans AKS

K8sGPT s’intègre dans AKS selon l’architecture suivante :

• Plan de contrôle AKS : Géré par Microsoft, il inclut le serveur API Kubernetes, le scheduler, et etcd, répliqués dans plusieurs zones de disponibilité.

• Nœuds AKS : Un pool de nœuds système (obligatoire) héberge les pods critiques (CoreDNS, metrics-server), et des pools utilisateurs hébergent les applications, dont K8sGPT.

• K8sGPT Operator : Déployé en tant que ressource Kubernetes, il agit comme un intermédiaire entre le plan de contrôle, les charges de travail de diagnostic, et les outils d’observabilité (Prometheus, Azure Monitor).

• Backend IA : K8sGPT communique avec un modèle LLM (OpenAI, Azure OpenAI) pour analyser les problèmes et générer des recommandations.

• Flux de données : Collecte des événements et logs Kubernetes → Analyse par K8sGPT → Envoi des diagnostics et alertes vers Slack/Teams, Grafana, ou outils de ticketing (Jira, GitHub Issues).

Cette architecture assure une surveillance continue, une analyse intelligente, et une intégration fluide dans les workflows DevOps et SRE.

Déploiement d’AKS avec Terraform

Pour automatiser la création du cluster AKS, Terraform est l’outil recommandé. Voici un exemple de configuration Terraform pour déployer un cluster AKS avec les paramètres essentiels :

module "aks" {
     source = "Azure/aks/azurerm"
     resource_group_name = azurerm_resource_group.rg.name
     cluster_name = "my-aks-cluster"
     kubernetes_version = "1.34"
     node_count = 3
     vm_size = "Standard_D2_v3"
     network_profile {
         network_plugin = "azure"
         service_cidr = "10.0.0.0/16"
         dns_service_ip = "10.0.0.10"
     }
     identity {
        type = "SystemAssigned"
     }
     tags = {
         Application = "K8sGPT"
         Environment = "Demo"
     }
}

Cette configuration crée un cluster AKS avec 3 nœuds, une version Kubernetes 1.34, et un profil réseau adapté. Le module Terraform gère automatiquement la création du groupe de ressources, la configuration réseau, et les identités nécessaires.

Après application (terraform apply), il faut récupérer le kubeconfig pour accéder au cluster :

az aks get-credentials --resource-group <resource-group> --name <cluster-name>
kubelogin convert-kubeconfig -l azurecli

Valider l’accès au cluster via cette commande pour lister les nodes :

kubectl get nodes

Cette étape est fondamentale pour disposer d’une infrastructure AKS fonctionnelle avant d’y déployer K8sGPT.

Installation et configuration de K8sGPT dans AKS

L’objectif est de déployer l’ensemble des éléments présents sur ce schémas au sein de notre cluster AKS:

1. Installation de Prometheus via helm

   Créer un fichier prometheus-values.yaml dans un répertoire yaml tel que :

prometheus:
  prometheusSpec:
    serviceMonitorSelector:
      matchLabels: {}
    serviceMonitorNamespaceSelector:
      matchLabels: {}

Puis exécutez ces commandes helm pour utiliser la chart Helm prometheus-community :

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install prometheus prometheus-community/kube-prometheus-stack --version 78.2.0  
    -f ./yaml/prometheus-values.yaml -n observability --create-namespace

2. Validation du fonctionnement de Prometheus

kubectl --namespace observability get pods -l "release=prometheus"
kubectl port-forward -n observability svc/prometheus-grafana 3000:80&

3. Ajout de l’opérateur k8sGPT

   K8sGPT est distribué sous forme de chart Helm, facilitant son déploiement dans AKS, exécuter ces commandes helm :

helm repo add k8sgpt https://charts.k8sgpt.ai
helm repo update
helm install release k8sgpt/k8sgpt-operator -n k8sgpt-operator --create-namespace --set interplex.enabled=true --set grafanaDashboard.enabled=true --set serviceMonitor.enabled=true

4. Création du namespace et ajout de la clé du service Azure Open AI

   Via le portail Azure AI Foundry, récupérer la clé du modèle GPT que vous souhaitez utiliser pour k8sGPT:

   

   Une fois la clé récupérer nous allons créer le namespace et le secret.

    kubectl create namespace k8sgpt
    kubectl create secret generic k8sgpt-secret -n k8sgpt 
            --from-literal=azureopenai_secret="< YOUR_AZURE_OPENAI_KEY />"
   

5. Déploiement de l’analyse continue

   Créer un fichier k8sgpt-analyzer.yaml pour configurer les paramètres spécifiques, notamment :

   • Le backend IA (OpenAI, Azure OpenAI, etc.) avec les clés API nécessaires.

   • La langue utilisée lors de la création du rapport final.

   • L’intervalle d’exécution de l’analyse k8sGPT.

   • L’anonymisation des données.

   • L’usage d’un cache.

   • …

Voici un exemple de configuration pour Azure OpenAI :

    apiVersion: core.k8sgpt.ai/v1alpha1
    kind: K8sGPT
    metadata:
      name: k8sgpt-analyzer
      namespace: k8sgpt
    spec:
      ai:
        enabled: true # Désactivez l'IA pour les tests initiaux
        secret:
          name: k8sgpt-secret
          key: azureopenai_secret
        model: gpt-4o-mini
        backend: azureopenai
        baseUrl: https://k8sgpt-openai-france.cognitiveservices.azure.com/
        engine: gpt-4o-mini
        language: french
        anonymized: true
      analysis:
        interval: "10m" # Set analysis interval to 10 minutes
      noCache: false
      repository: ghcr.io/k8sgpt-ai/k8sgpt
      version: v0.4.25
      # targetNamespace: default

Puis exécuter cette commande pour déployer l’analyse continue k8sGPT :

    kubectl apply -f k8sgpt-analyzer.yaml

Ajout d’applications en erreur

Pour pouvoir valider le fonctionnement de k8sGPT, il faut ajouter des applications “brokens”.
Voici exemple un déploiement où j’utilise de façon volontaire une image inexistante:

apiVersion: v1
kind: Pod
metadata:
  name: broken-pod
  namespace: default
spec:
  containers:
    - name: broken-pod
      # Image invalide pour provoquer un CrashLoopBackOff,
      # corriger la version de l'image avec une version valide comme "1.29.3"
      image: nginx:a.b.c 
      resources:
        requests:
          cpu: "100m"
          memory: "128Mi"
        limits:
          cpu: "250m"
          memory: "256Mi"

Pour le déployer, créé un fichier ImagePullBackOff.yaml avec le contenu précédent et déployez le sur votre cluster:

kubectl apply -f ".\ImagePullBackOff.yaml"

Vous devez avoir un pod en erreur avec un état ImagePullBackOff :

Fonctionnement de K8sGPT

• L’Operator k8sGPT s’exécute en permanence dans le cluster et génère des rapports stockés sous forme de ressources Kubernetes (YAML).

  Ces rapports peuvent être consultés via cette commande :

    kubectl get results -n k8sgpt -o yaml
  

  En cherchant dans les résultats vous trouverez l’analyse du pod déployer dans le chapitre précédent:

  

Dashboard Grafana

• Lorsque l'observabilité est activée, l'opérateur k8sGPT expose des métriques au format Prometheus. Le dashboard Grafana déployer précédemment permet de visualiser l’état des analyses, vous pouvez y accéder via une redirection de port, tel que:

    kubectl port-forward -n observability svc/prometheus-grafana 3000:80&
  

  

• Puis ouvrer votre navigateur à cette url: http://localhost:3000/ pour accéder à Grafana et utiliser le user / password par défaut: admin / prom-operator. Une fois connecté naviguer jusqu’aux dashbord et cliquer sur K8sGPT Overview

  

  Le dashboard Grafana officiel permet de visualiser :

  • Le nombre total de problèmes détectés.

  • La répartition des problèmes par type (Kind).

  • Les namespaces les plus affectés.

  • L'évolution du nombre de problèmes dans le temps.

  • La durée des analyses.

Bonnes pratiques et optimisations

Sécurité

• Limiter les permissions Kubernetes de K8sGPT avec des ClusterRoles personnalisés.

• Chiffrer et gérer les secrets (clés API) via Azure Key Vault ou Kubernetes Secrets.

• Appliquer des Network Policies pour filtrer le trafic entre pods.

• Mettre à jour régulièrement les images des nœuds pour isoler et drainer les pods en toute sécurité.

• Utiliser l’option d’anonymisation des données transmises au service IA.

Performances

• Ajustez les ressources allouées à K8sGPT (limits/requests) pour éviter la surcharge.

• Filtrez les namespaces et types de ressources analysés pour cibler les environnements critiques.

• Surveiller les traitements de l’outil au travers du dashboard Grafana.

Gestion des coûts

• Estimez les coûts liés à l’utilisation du backend IA (OpenAI, Azure OpenAI) et identifier le modèle en fonction de vos besoins.

• Utiliser un service backend IA via une IA intégrée à votre cluster: Local AI ou Ollama.

• Réduire le nombre de tokens utiliser pour les responses AI via le paramétre maxToken qui est par défaut à 2048.

• Adopter l’usage du cache via le paramétrage du remoteCache.

• Améliorer le suivi de vos coûts via l’outil Kubecost.

Dépannage

• Erreurs de connexion au backend IA : Vérifiez les clés API, les endpoints, et la connectivité réseau.

• Permissions manquantes : Vérifiez les ClusterRoles et ServiceAccounts.

• Latence dans les analyses : Ajustez les timeouts et les ressources allouées.

• Logs et métriques : Consultez les logs des pods K8sGPT et intégrez-les à votre stack de supervision ou Azure Log Analytics.

Conclusion et perspectives

Le déploiement de K8sGPT dans un cluster AKS via Terraform permet d’automatiser la surveillance et la résolution des problèmes Kubernetes, améliorant significativement l’efficacité opérationnelle. En combinant l’intelligence artificielle et les outils cloud natifs, K8sGPT facilite la gestion des clusters complexes et réduit la charge des équipes SRE.

Les perspectives incluent l’intégration avec des outils de ticketing pour une auto-remédiation complète, l’utilisation dans les pipelines CI/CD pour des vérifications pré-déploiement, et l’amélioration continue des modèles IA via Azure IA Foudry pour une analyse encore plus précise.

Repository GitHub

Le dépôt GitHub contient tout ce dont vous avez besoin pour déployer et personnaliser la solution détailler dans cet article se trouve ici:

🔗 aloizeau/AzuRex-k8sGPT

Pour ceux qui veulent récupérer le support de ma présentation de l’AzuRex #27 vous pourrez la télécharger ici.