Dot.Blog

Azure AI - Bonnes pratiques : sécurité, quotas, versionnement, suivi des coûts pour Azure AI

odahan@e-naxos.com — ven., 6 mars 2026 13:00:00 +0000

Utiliser Azure AI dans vos applications .NET nécessite non seulement de maîtriser la technique, mais aussi d’adopter des pratiques solides pour garantir la sécurité, maîtriser les coûts, gérer les quotas, et organiser les versions de vos API et modèles. Cet article vous guide pas à pas sur ces aspects essentiels.

Sécurité

Protection des clés API

Ne jamais exposer votre clé API dans le code client (applications web, mobile, frontend).
Stockez les clés dans Azure Key Vault ou dans les paramètres d’environnement des services backend.
Utilisez des API intermédiaires (ex : Azure Functions) pour sécuriser les appels.

Authentification et contrôle d’accès

Configurez des rôles et permissions dans Azure pour limiter l’accès aux ressources.
Activez l’authentification basée sur Azure AD quand c’est possible.
Surveillez les logs d’accès via Azure Monitor pour détecter les usages anormaux.

Gestion des quotas et limitations

Azure OpenAI impose des quotas sur :

Le nombre de requêtes par minute.
Le nombre total de tokens traités.
Le nombre d’instances déployées.

Bonnes pratiques

Implémentez une file d’attente ou un mécanisme de throttling côté client ou serveur.
Surveillez l’utilisation via le portail Azure ou Azure Monitor.
Demandez une augmentation de quotas si nécessaire, en justifiant vos usages.

Versionnement des API et modèles

Pourquoi versionner ?

Permet de déployer de nouvelles fonctionnalités sans casser l’existant.
Gère la compatibilité entre clients et services.
Facilite les tests A/B et les rollbacks.

Comment versionner ?

Utilisez les versions d’API dans les URL (ex : api-version=2024-02-15-preview).
Donnez des noms explicites aux déploiements de modèles (ex : chatbot-v1, chatbot-v2).
Documentez clairement les changements dans vos API.

Suivi et maîtrise des coûts

Facturation Azure OpenAI

Le coût dépend du nombre de tokens traités (entrée + sortie).
Les modèles plus puissants (GPT-4) sont plus coûteux que GPT-3.5.

Recommandations

Surveillez les consommations via le portail Azure et configurez des alertes budgétaires.
Optimisez les prompts pour limiter la taille des requêtes et réponses.
Cachez les réponses fréquentes pour éviter des appels redondants.

Outils et services complémentaires

Azure Monitor pour logs et alertes.
Azure Cost Management pour analyse des coûts.
Application Insights pour surveiller les performances et erreurs.

Conclusion

La maîtrise des aspects sécurité, quotas, versionnement et coûts est indispensable pour déployer sereinement vos solutions Azure AI à l’échelle professionnelle.

Ces bonnes pratiques vous aideront à garantir robustesse, scalabilité et contrôle budgétaire.

Ici s'achève la série de 12 articles sur Azure AI, j'espère qu'elle vous aura permis de vous initier à cet environnement indispensable à connaître. Et comme je suis de nature généreuse, comme dans mon enfance où les oeufs se vendaient 13 à la douzaine, il y aura un prochain article pour clore réellement la série qui s'intitulera : Créer un chatbot contextuel avec Azure OpenAI + mémoire conversationnelle en C#

Une excellente raison de plus de ... Stay Tuned !

Créer un micro moteur RAG en C# avec API + index vectoriel local

odahan@e-naxos.com — ven., 27 févr. 2026 13:00:00 +0000

Le principe du RAG (Retrieval-Augmented Generation) est de combiner un moteur de recherche sémantique avec un LLM (Large Language Model) afin de générer des réponses contextualisées à partir de documents locaux. Cette approche permet de créer des assistants personnalisés, sans avoir à fine-tuner un modèle.

Dans cet article, nous allons construire un moteur RAG minimaliste en C# qui interroge un index vectoriel local (via QDrant) et appelle l’API OpenAI pour générer des réponses.

🧩 Architecture cible

Documents vectorisés (embeddings)
Index vectoriel local (QDrant)
API Web locale (ASP.NET Minimal API)
Appel à OpenAI pour générer la réponse finale

📦 Étape 1 : préparer les documents vectorisés

string[] documents = [
    "Le C# est un langage de programmation orienté objet.",
    "Les records permettent de modéliser des données immuables.",
    "Span<T> optimise l’accès mémoire en .NET."
];

foreach (var doc in documents)
{
    var vector = await openAiClient.EmbedAsync(doc);
    await qdrantClient.UpsertAsync("docs", docId, vector, payload: new { texte = doc });
}

// 🌐 Étape 2 : Minimal API de requêtage en ASP.NET

var builder = WebApplication.CreateBuilder();
var app = builder.Build();

app.MapPost("/ask", async (AskRequest req) =>
{
    var questionVector = await openAiClient.EmbedAsync(req.Question);
    var matches = await qdrantClient.SearchAsync("docs", questionVector, top: 5);
    string context = string.Join("\n", matches.Select(m => m.Payload["texte"]));
    string prompt = $"Voici des extraits :\n{context}\n\nQuestion : {req.Question}\nRéponds de manière claire et concise.";

    var response = await openAiClient.ChatAsync(prompt);
    return Results.Ok(response);
});
app.Run();

🔧 Étape 3 : implémentation de OpenAI et QDrant clients simplifiés

Extrait simplifié de client d’embedding OpenAI :

public async Task<float[]> EmbedAsync(string input)
{
    var body = new { model = "text-embedding-3-small", input };
    var content = new StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json");
    var response = await httpClient.PostAsync("https://api.openai.com/v1/embeddings", content);
    var json = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
    return json.RootElement.GetProperty("data")[0].GetProperty("embedding")
               .EnumerateArray().Select(x => x.GetSingle()).ToArray();
}

📤 Exemple de requête

POST /ask
{
  "question": "Comment fonctionne Span<T> ?"
}

Réponse : texte généré par GPT-4 à partir des documents les plus proches.

📌 Résumé du flux

Embedding de la question → vecteur
Recherche dans QDrant → documents similaires
Construction d’un prompt contextuel
Appel à OpenAI pour compléter

🧪 Perspectives

Ajouter un cache de réponse locale
Ajouter de la pondération sur la similarité
Indexer automatiquement des fichiers Markdown, PDF, etc.
Proposer une UI WinUI ou Blazor locale

🔚 Conclusion

Avec quelques dizaines de lignes de C#, il est possible de construire un moteur RAG simple mais puissant, utilisable localement et sans infrastructure cloud externe. Cette base est idéale pour explorer des assistants spécialisés, des FAQ intelligentes, ou des moteurs documentaires embarqués.

C'est vraiment quelque chose d'important sur lequel il faut que vous vous penchiez, car c'est là que se joue l'avenir de l'informatique. Elle a commencé par envahir tous les objets du four micro-onde à la télé en passant par les bracelets montres, et maintenant qu'elle est partout elle va servir de voie royale à l'IA pour s'insinuer partout. Développer demain obligera à savoir intégrer l'IA dans ses Apps...

Stay Tuned !

Azure AI - Déployer une API d’IA personnalisée avec Azure Functions

odahan@e-naxos.com — ven., 20 févr. 2026 13:00:00 +0000

Une fois que vous avez un modèle Azure OpenAI opérationnel, il est souvent pratique de créer une API intermédiaire qui encapsule les appels à ce modèle. Cela facilite la maintenance, la sécurisation et la réutilisation du service dans vos applications clientes.

Cet article détaille comment créer et déployer une API serverless simple avec Azure Functions en C#, qui reçoit une requête, interroge Azure OpenAI, puis renvoie la réponse.

Prérequis

Un abonnement Azure actif
Une fonction Azure Functions configurée (runtime .NET 7 ou supérieur recommandé)
Une ressource Azure OpenAI opérationnelle avec clé d’API
Visual Studio 2022 ou Visual Studio Code avec les extensions Azure Functions

Création d’un projet Azure Functions HTTP Trigger

Dans Visual Studio :

Créer un nouveau projet → sélectionnez Azure Functions
Nommer le projet, choisir .NET 7 ou supérieur
Sélectionner le type Trigger HTTP
Autoriser Anonymous ou Function pour l’authentification selon besoin

Implémentation de la fonction C#

Voici un exemple simple d’une fonction qui reçoit un JSON contenant un prompt, appelle Azure OpenAI via HttpClient, et retourne la réponse :

using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;

public class OpenAIProxyFunction
{
    private readonly HttpClient _httpClient;
    private readonly string _azureOpenAiEndpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
    private readonly string _azureOpenAiApiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY");
    private readonly string _deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT");

    public OpenAIProxyFunction(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    [Function("OpenAIProxy")]
    public async Task<HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req)
    {
        var requestBody = await new StreamReader(req.Body).ReadToEndAsync();
        var jsonDoc = JsonDocument.Parse(requestBody);
        var userMessage = jsonDoc.RootElement.GetProperty("prompt").GetString();

        var apiUrl = $"{_azureOpenAiEndpoint}/openai/deployments/{_deploymentName}/chat/completions?api-version=2024-02-15-preview";

        var payload = new
        {
            messages = new[]
            {
                new { role = "system", content = "Vous êtes un assistant." },
                new { role = "user", content = userMessage }
            },
            temperature = 0.7
        };

        var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
        _httpClient.DefaultRequestHeaders.Clear();
        _httpClient.DefaultRequestHeaders.Add("api-key", _azureOpenAiApiKey);
        var response = await _httpClient.PostAsync(apiUrl, content);
        var responseContent = await response.Content.ReadAsStringAsync();
        var res = req.CreateResponse(response.StatusCode);
        res.Headers.Add("Content-Type", "application/json");
        await res.WriteStringAsync(responseContent);

        return res;
    }
}

Configuration des variables d’environnement

Pour sécuriser les informations sensibles, placez dans le fichier local.settings.json ou dans la configuration Azure :

{
  "IsEncrypted": false,
  "Values": {
    "AZURE_OPENAI_ENDPOINT": "https://votre-instance.openai.azure.com",
    "AZURE_OPENAI_API_KEY": "votre-cle-api",
    "AZURE_OPENAI_DEPLOYMENT": "chatbot-deploy",
    "AzureWebJobsStorage": "UseDevelopmentStorage=true"
  }
}

Déploiement sur Azure

Utilisez Visual Studio ou Azure CLI :

Visual Studio : clic droit sur le projet → Publier → sélectionner votre abonnement et créer une Function App
Azure CLI :

func azure functionapp publish <nom-de-votre-function-app>

Tester l’API

Après déploiement, votre API est accessible via une URL publique.

Exemple de requête HTTP POST :

POST https://<votre-function-app>.azurewebsites.net/api/OpenAIProxy
Content-Type: application/json
{
  "prompt": "Peux-tu expliquer Azure Functions ?"
}

Réponse JSON contenant la génération du modèle.

Avantages et bonnes pratiques

Centralisation : votre logique d’appel à Azure OpenAI est centralisée et contrôlée
Sécurité : clé API protégée côté serveur, pas exposée au client
Extensibilité : ajoutez la journalisation, limitation de débit, validation des requêtes
Interopérabilité : accessible depuis toute application (web, mobile, desktop)

Conclusion

Créer une API Azure Functions autour d’Azure OpenAI facilite l’intégration dans vos applications et améliore la sécurité et la maintenabilité.

Mais ce n'est qu'un simple scénario de démonstration pour vous aider à comprendre les principes présentés. Il peut même y avoir des cas où la centralisation de la clé API est un inconvénient.Supposons une App MAUI mise sur le Store (Android Play par exemple). Il est fort probable que la gestion des API va poser des problèmes très différents de ceux soulevés en entreprise. Cette dernière a intérêt à utiliser une centralisation des clés API, pour la sécurité notamment, côté coût c'est elle qui paye pour tout le monde donc cela ne pose aucun souci. Mais pour l'App à disposition sur un Store... Soit elle elle intègre un abonnement avec achat in-App ou autre afin de financer le coût de l'IA, soit elle doit offrir à l'utilisateur de saisir sa propre clé, charge à lui de prendre un abonnement Azure AI ou directement OpenAI mais cela lui complique la vie ce qui n'est jamais bon d'un point de vue marketting ...

Bref, Il existe de nombreuses situations différentes et je n'ai pas ici dans cette série de 12 articles sur Azure AI la naïveté de croire que je peux vous apprendre toutes les façons d'aborder cette complexe tâche qu'est l'intégration de l'IA dans vos Apps. Mais j'espère pouvoir participer à votre compréhension des principes essentiels, en misant sur votre intelligence, naturelle celle-là, pour le reste !

Dans le dernier volet de cette série de 12 articles sur Azure AI j'aborderai la question des Bonnes pratiques : sécurité, quotas, versionnement, suivi des coûts pour Azure AI

Stay Tuned !