az-cost-optimize

Par github · awesome-copilot

Analysez les ressources Azure utilisées dans l'application (fichiers IaC et/ou ressources dans un groupe de ressources cible) et optimisez les coûts en créant des GitHub issues pour les optimisations identifiées.

npx skills add https://github.com/github/awesome-copilot --skill az-cost-optimize

Azure Cost Optimize

Ce workflow analyse les fichiers Infrastructure-as-Code (IaC) et les ressources Azure pour générer des recommandations d'optimisation des coûts. Il crée des issues GitHub individuelles pour chaque opportunité d'optimisation plus une issue EPIC pour coordonner l'implémentation, ce qui permet un suivi et une exécution efficaces des initiatives d'économies.

Prérequis

  • Serveur Azure MCP configuré et authentifié
  • Serveur GitHub MCP configuré et authentifié
  • Référentiel GitHub cible identifié
  • Ressources Azure déployées (fichiers IaC optionnels mais utiles)
  • Préférer les outils Azure MCP (azmcp-*) à l'Azure CLI direct quand disponibles

Étapes du workflow

Étape 1 : Obtenir les meilleures pratiques Azure

Action : Récupérer les meilleures pratiques d'optimisation des coûts avant l'analyse Outils : Outil des meilleures pratiques Azure MCP Processus :

  1. Charger les meilleures pratiques :
    • Exécuter azmcp-bestpractices-get pour obtenir certaines des dernières directives d'optimisation Azure. Cela ne couvre peut-être pas tous les scénarios mais fournit une base.
    • Utiliser ces pratiques pour informer autant que possible l'analyse et les recommandations suivantes
    • Référencer les meilleures pratiques dans les recommandations d'optimisation, soit à partir de la sortie de l'outil MCP, soit à partir de la documentation Azure générale

Étape 2 : Découvrir l'infrastructure Azure

Action : Découvrir et analyser dynamiquement les ressources et configurations Azure Outils : Outils Azure MCP + Azure CLI en secours + Accès au système de fichiers local Processus :

  1. Découverte des ressources :

    • Exécuter azmcp-subscription-list pour trouver les abonnements disponibles
    • Exécuter azmcp-group-list --subscription <subscription-id> pour trouver les groupes de ressources
    • Obtenir une liste de toutes les ressources dans le(s) groupe(s) pertinent(s) :
      • Utiliser az resource list --subscription <id> --resource-group <name>
    • Pour chaque type de ressource, utiliser les outils MCP si possible, puis basculer vers CLI :
      • azmcp-cosmos-account-list --subscription <id> - Comptes Cosmos DB
      • azmcp-storage-account-list --subscription <id> - Comptes de stockage
      • azmcp-monitor-workspace-list --subscription <id> - Espaces de travail Log Analytics
      • azmcp-keyvault-key-list - Key Vaults
      • az webapp list - Applications web (secours - aucun outil MCP disponible)
      • az appservice plan list - Plans App Service (secours)
      • az functionapp list - Function Apps (secours)
      • az sql server list - Serveurs SQL (secours)
      • az redis list - Cache Redis (secours)
      • ... et ainsi de suite pour les autres types de ressources

  2. Détection IaC :

    • Utiliser file_search pour scanner les fichiers IaC : "/*.bicep", "*/.tf", "/main.json", "*/template*.json"
    • Parser les définitions de ressources pour comprendre les configurations prévues
    • Comparer par rapport aux ressources découvertes pour identifier les écarts
    • Noter la présence de fichiers IaC pour les recommandations d'implémentation ultérieures
    • NE PAS utiliser d'autres fichiers du référentiel, seulement les fichiers IaC. Utiliser d'autres fichiers N'EST PAS autorisé car ce n'est pas une source de vérité.
    • Si vous ne trouvez pas de fichiers IaC, ARRÊTEZ et signalez l'absence de fichiers IaC à l'utilisateur.

  3. Analyse de configuration :

    • Extraire les SKU, niveaux et paramètres actuels pour chaque ressource
    • Identifier les relations et dépendances des ressources
    • Mapper les modèles d'utilisation des ressources quand disponibles

Étape 3 : Collecter les métriques d'utilisation et valider les coûts actuels

Action : Rassembler les données d'utilisation ET vérifier les coûts réels des ressources Outils : Outils de monitoring Azure MCP + Azure CLI Processus :

  1. Trouver les sources de monitoring :

    • Utiliser azmcp-monitor-workspace-list --subscription <id> pour trouver les espaces de travail Log Analytics
    • Utiliser azmcp-monitor-table-list --subscription <id> --workspace <name> --table-type "CustomLog" pour découvrir les données disponibles

  2. Exécuter des requêtes d'utilisation :

    • Utiliser azmcp-monitor-log-query avec ces requêtes prédéfinies :
      • Requête : "recent" pour les modèles d'activité récents
      • Requête : "errors" pour les journaux au niveau erreur indiquant des problèmes
    • Pour une analyse personnalisée, utiliser des requêtes KQL :
      
// CPU utilization for App Services
AppServiceAppLogs
| where TimeGenerated > ago(7d)
| summarize avg(CpuTime) by Resource, bin(TimeGenerated, 1h)

    // Cosmos DB RU consumption
    AzureDiagnostics | where ResourceProvider == "MICROSOFT.DOCUMENTDB" | where TimeGenerated > ago(7d) | summarize avg(RequestCharge) by Resource

    // Storage account access patterns StorageBlobLogs | where TimeGenerated > ago(7d) | summarize RequestCount=count() by AccountName, bin(TimeGenerated, 1d)

  3. Calculer les métriques de base :

    • Moyennes d'utilisation CPU/mémoire
    • Modèles de débit des bases de données
    • Fréquence d'accès au stockage
    • Taux d'exécution des fonctions

  4. VALIDER LES COÛTS ACTUELS :

    • En utilisant les configurations de SKU/niveau découvertes à l'étape 2
    • Consulter les tarifs Azure actuels sur https://azure.microsoft.com/pricing/ ou utiliser les commandes az billing
    • Documenter : Ressource → SKU actuel → Coût mensuel estimé
    • Calculer le total mensuel actuel réaliste avant de procéder aux recommandations

Étape 4 : Générer des recommandations d'optimisation des coûts

Action : Analyser les ressources pour identifier les opportunités d'optimisation Outils : Analyse locale utilisant les données collectées Processus :

  1. Appliquer les modèles d'optimisation en fonction des types de ressources trouvés :

    Optimisations de calcul :

    • Plans App Service : Dimensionnement adapté en fonction de l'utilisation CPU/mémoire
    • Function Apps : Premium → plan Consommation pour utilisation faible
    • Machines virtuelles : Réduire les instances surdimensionnées

    Optimisations de base de données :

    • Cosmos DB :
      • Approvisionné → Sans serveur pour charges variables
      • Dimensionnement adapté des RU/s en fonction de l'utilisation réelle
    • SQL Database : Dimensionnement adapté des niveaux de service en fonction de l'utilisation DTU

    Optimisations de stockage :

    • Implémenter des politiques de cycle de vie (Hot → Cool → Archive)
    • Consolider les comptes de stockage redondants
    • Dimensionnement adapté des niveaux de stockage en fonction des modèles d'accès

    Optimisations d'infrastructure :

    • Supprimer les ressources inutilisées/redondantes
    • Implémenter la mise à l'échelle automatique le cas échéant
    • Planifier les environnements non-production

  2. Calculer les économies basées sur les preuves :

    • Coût actuel validé → Coût cible = Économies
    • Documenter la source de tarification pour les configurations actuelles et cibles

  3. Calculer le score de priorité pour chaque recommandation :

    Priority Score = (Value Score × Monthly Savings) / (Risk Score × Implementation Days)

High Priority: Score > 20
Medium Priority: Score 5-20
Low Priority: Score < 5

  4. Valider les recommandations :

    • S'assurer que les commandes Azure CLI sont exactes
    • Vérifier les calculs d'économies estimées
    • Évaluer les risques d'implémentation et les prérequis
    • S'assurer que tous les calculs d'économies ont des preuves à l'appui

Étape 5 : Confirmation de l'utilisateur

Action : Présenter le résumé et obtenir l'approbation avant de créer les issues GitHub Processus :

  1. Afficher le résumé d'optimisation :

    🎯 Azure Cost Optimization Summary

📊 Analysis Results:
• Total Resources Analyzed: X
• Current Monthly Cost: $X 
• Potential Monthly Savings: $Y 
• Optimization Opportunities: Z
• High Priority Items: N

🏆 Recommendations:
1. [Resource]: [Current SKU] → [Target SKU] = $X/month savings - [Risk Level] | [Implementation Effort]
2. [Resource]: [Current Config] → [Target Config] = $Y/month savings - [Risk Level] | [Implementation Effort]
3. [Resource]: [Current Config] → [Target Config] = $Z/month savings - [Risk Level] | [Implementation Effort]
... and so on

💡 This will create:
• Y individual GitHub issues (one per optimization)
• 1 EPIC issue to coordinate implementation

❓ Proceed with creating GitHub issues? (y/n)

  2. Attendre la confirmation de l'utilisateur : Ne procéder que si l'utilisateur confirme

Étape 6 : Créer les issues d'optimisation individuelles

Action : Créer des issues GitHub séparées pour chaque opportunité d'optimisation. Les étiqueter avec "cost-optimization" (couleur verte), "azure" (couleur bleue). Outils MCP requis : create_issue pour chaque recommandation Processus :

  1. Créer des issues individuelles en utilisant ce modèle :

    Format du titre : [COST-OPT] [Resource Type] - [Brief Description] - $X/month savings

    Modèle de corps :

    ## 💰 Cost Optimization: [Brief Title]

**Monthly Savings**: $X | **Risk Level**: [Low/Medium/High] | **Implementation Effort**: X days

### 📋 Description
[Clear explanation of the optimization and why it's needed]

### 🔧 Implementation

**IaC Files Detected**: [Yes/No - based on file_search results]

```bash
# If IaC files found: Show IaC modifications + deployment
# File: infrastructure/bicep/modules/app-service.bicep
# Change: sku.name: 'S3' → 'B2'
az deployment group create --resource-group [rg] --template-file infrastructure/bicep/main.bicep

# If no IaC files: Direct Azure CLI commands + warning
# ⚠️ No IaC files found. If they exist elsewhere, modify those instead.
az appservice plan update --name [plan] --sku B2

    📊 Evidence

    • Current Configuration: [details]
    • Usage Pattern: [evidence from monitoring data]
    • Cost Impact: $X/month → $Y/month
    • Best Practice Alignment: [reference to Azure best practices if applicable]

    ✅ Validation Steps

    • [ ] Test in non-production environment
    • [ ] Verify no performance degradation
    • [ ] Confirm cost reduction in Azure Cost Management
    • [ ] Update monitoring and alerts if needed

    ⚠️ Risks & Considerations

    • [Risk 1 and mitigation]
    • [Risk 2 and mitigation]

    Priority Score: X | Value: X/10 | Risk: X/10

Étape 7 : Créer une issue EPIC de coordination

Action : Créer une issue maître pour suivre tout le travail d'optimisation. L'étiqueter avec "cost-optimization" (couleur verte), "azure" (couleur bleue) et "epic" (couleur violette). Outils MCP requis : create_issue pour l'EPIC Remarque sur les diagrammes mermaid : S'assurer que vous vérifiez que la syntaxe mermaid est correcte et que vous créez les diagrammes en tenant compte des directives d'accessibilité (style, couleurs, etc.). Processus :

  1. Créer une issue EPIC :

    Titre : [EPIC] Azure Cost Optimization Initiative - $X/month potential savings

    Modèle de corps :

    # 🎯 Azure Cost Optimization EPIC

**Total Potential Savings**: $X/month | **Implementation Timeline**: X weeks

## 📊 Executive Summary
- **Resources Analyzed**: X
- **Optimization Opportunities**: Y  
- **Total Monthly Savings Potential**: $X
- **High Priority Items**: N

## 🏗️ Current Architecture Overview

```mermaid
graph TB
    subgraph "Resource Group: [name]"
        [Generated architecture diagram showing current resources and costs]
    end

    📋 Implementation Tracking

    🚀 High Priority (Implement First)

    • [ ] #[issue-number]: [Title] - $X/month savings
    • [ ] #[issue-number]: [Title] - $X/month savings

    ⚡ Medium Priority

    • [ ] #[issue-number]: [Title] - $X/month savings
    • [ ] #[issue-number]: [Title] - $X/month savings

    🔄 Low Priority (Nice to Have)

    • [ ] #[issue-number]: [Title] - $X/month savings

    📈 Progress Tracking

    • Completed: 0 of Y optimizations
    • Savings Realized: $0 of $X/month
    • Implementation Status: Not Started

    🎯 Success Criteria

    • [ ] All high-priority optimizations implemented
    • [ ] >80% of estimated savings realized
    • [ ] No performance degradation observed
    • [ ] Cost monitoring dashboard updated

    📝 Notes

    • Review and update this EPIC as issues are completed
    • Monitor actual vs. estimated savings
    • Consider scheduling regular cost optimization reviews

Gestion des erreurs

  • Validation des coûts : Si les estimations d'économies manquent de preuves à l'appui ou semblent incohérentes avec les tarifs Azure, re-vérifier les configurations et les sources de tarification avant de procéder
  • Échec de l'authentification Azure : Fournir les étapes de configuration manuelle d'Azure CLI
  • Aucune ressource trouvée : Créer une issue informative sur le déploiement des ressources Azure
  • Échec de la création GitHub : Exporter les recommandations formatées vers la console
  • Données d'utilisation insuffisantes : Noter les limitations et fournir uniquement les recommandations basées sur la configuration

Critères de succès

  • ✅ Toutes les estimations de coûts vérifiées par rapport aux configurations réelles des ressources et aux tarifs Azure
  • ✅ Issues individuelles créées pour chaque optimisation (traçables et assignables)
  • ✅ Issue EPIC fournit une coordination et un suivi complets
  • ✅ Toutes les recommandations incluent des commandes Azure CLI spécifiques et exécutables
  • ✅ La notation de priorité permet une implémentation basée sur le ROI
  • ✅ Le diagramme d'architecture représente précisément l'état actuel
  • ✅ La confirmation de l'utilisateur prévient la création d'issues indésirables

Skills similaires

cosmosdb-datamodeling
github / awesome-copilot

Concevoir un modèle de données Azure Cosmos DB NoSQL adapté aux besoins applicatifs.

33 040
azure-reliability
microsoft / azure-skills

Évaluer et configurer la fiabilité des Azure Functions avec redondance et failover multi-région.

954
import-infrastructure-as-code
github / awesome-copilot

Convertir une infrastructure Azure existante en code Terraform maintenable avec Azure Verified Modules.

33 040
arize-instrumentation
github / awesome-copilot

Instrumenter une application avec le tracing Arize AX via une analyse guidée.

33 040
containerize-aspnet-framework
github / awesome-copilot

Conteneuriser une application ASP.NET Framework dans un conteneur Windows Docker.

33 040