Salt la conținutul principal
Română— Alege o limbă
Meniu

Azure în producție

Lecția 6 din 14 Actualizată 2 noiembrie 2026 Avansat
Pe această pagină
  1. Pregătirea unei implementări Azure robuste
  2. Arhitectura de producție
  3. Monitorizare cu Application Insights
  4. Scalabilitate
  5. Securitatea rețelei
  6. Lista de verificare pentru pregătirea în producție
  7. Puncte cheie

Pregătirea unei implementări Azure robuste

Un prototip funcțional pe laptopul dumneavoastră și un sistem de producție nu diferă prin codul de apel, care rămâne identic. Diferența constă în tot ceea ce înconjoară acel cod: originea secretelor, modul de observare a evenimentelor, reacția la dublarea traficului și ruta de rețea parcursă de date. Această lecție acoperă aceste patru dimensiuni pentru o implementare Mistral pe Azure.

Arhitectura de producție

O implementare tipică reunește cinci blocuri de construcție. Punctul final Azure AI găzduiește modelul Mistral sub formă de MaaS; Azure Key Vault stochează cheile API; Azure Monitor și Application Insights asigură observabilitatea; Azure API Management acționează ca o poartă de acces cu limitare de速率 și autentificare în fața aplicației dumneavoastră; în final, o Rețea Virtuală Azure oferă izolarea rețelei, opțională dar adesea necesară pentru datele sensibile.

Prima dumneavoastră mișcare ar trebui să fie extragerea secretelor din cod și din variabilele de mediu, făcând aplicația să le citească la pornire direct din Key Vault.

from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient
from mistralai.azure.client import MistralAzure

# Retrieve the API key from Key Vault
credential = DefaultAzureCredential()
vault_url = "https://mon-keyvault.vault.azure.net"
secret_client = SecretClient(vault_url=vault_url, credential=credential)

endpoint = secret_client.get_secret("mistral-endpoint").value
api_key = secret_client.get_secret("mistral-api-key").value

client = MistralAzure(server_url=endpoint, api_key=api_key)

Beneficiul depășește simpla confidențialitate. Atunci când rotiți o cheie, nu este necesară nicio reimplantare a aplicației, deoarece valoarea este citită din seif, nu hardcoded în configurație.

Monitorizare cu Application Insights

Fără instrumentare, singurul lucru pe care îl veți ști despre un incident este că un utilizator consideră aplicația „lentă“. Urmărirea fiecărui apel cu durata sa, numărul de tokeni și modelul utilizat vă oferă ceea ce aveți nevoie pentru a reacționa în câteva minute.

import time
import logging
from opencensus.ext.azure.log_exporter import AzureLogHandler

logger = logging.getLogger(__name__)
logger.addHandler(AzureLogHandler(
    connection_string="InstrumentationKey=your-key"
))

def monitored_call(client, messages, model="azureai"):
    """Mistral call with Azure Monitor metrics."""
    start = time.time()
    try:
        response = client.chat.complete(model=model, messages=messages)
        duration = time.time() - start
        logger.info(
            "MistralCall",
            extra={
                "custom_dimensions": {
                    "duration_ms": int(duration * 1000),
                    "prompt_tokens": response.usage.prompt_tokens,
                    "completion_tokens": response.usage.completion_tokens,
                    "model": model
                }
            }
        )
        return response
    except Exception as e:
        duration = time.time() - start
        logger.error(
            f"MistralError: {e}",
            extra={
                "custom_dimensions": {
                    "duration_ms": int(duration * 1000),
                    "error_type": type(e).__name__
                }
            }
        )
        raise

Aceste metrici sunt valoroase doar dacă cineva le monitorizează. Configurați alertele corespunzătoare în Azure Monitor:

  • Latentă P95 > 5s — degradarea performanței
  • Rata de eroare 5xx > 1% — probleme la nivel de server
  • Erori 429 > 10/min — limita de速率 atinsă
  • Consum de tokeni > 80% din cotă — apropiere de limită

Scalabilitate

Când volumul crește, prima greșeală este apelarea modelului sincron din cererea HTTP incoming: orice încetinire se propagă direct către utilizator. Decuplarea prin Azure Service Bus vă permite să absorbiți vârfurile de trafic — cererile se acumulează într-o coadă și sunt consumate în ritmul permis de cota dumneavoastră.

from azure.servicebus import ServiceBusClient, ServiceBusMessage
import json

# Producer: send requests to the queue
def enqueue_request(prompt: str, request_id: str):
    with ServiceBusClient.from_connection_string(conn_str) as sb_client:
        sender = sb_client.get_queue_sender(queue_name="mistral-requests")
        message = ServiceBusMessage(
            json.dumps({"prompt": prompt, "request_id": request_id})
        )
        sender.send_messages(message)

# Consumer: process requests from the queue
def process_queue():
    with ServiceBusClient.from_connection_string(conn_str) as sb_client:
        receiver = sb_client.get_queue_receiver(queue_name="mistral-requests")
        for msg in receiver:
            data = json.loads(str(msg))
            response = client.chat.complete(
                model="azureai",
                messages=[{"role": "user", "content": data["prompt"]}]
            )
            # Store the result...
            receiver.complete_message(msg)

Dacă gâtul de sticlă provine din throughput însuși, mai degrabă decât din sarcina instantanee, implementați multiple puncte finale pentru același model și distribuiți apelurile între ele.

import random

endpoints = [
    {"url": os.environ["AZUREAI_ENDPOINT_1"], "key": os.environ["AZUREAI_KEY_1"]},
    {"url": os.environ["AZUREAI_ENDPOINT_2"], "key": os.environ["AZUREAI_KEY_2"]},
]

def get_client():
    """Simple round-robin across endpoints."""
    ep = random.choice(endpoints)
    return MistralAzure(server_url=ep["url"], api_key=ep["key"])

Securitatea rețelei

Pentru datele sensibile, Azure Private Link asigură că traficul dintre aplicația dumneavoastră și punctul final Mistral nu traversează niciodată internetul public. Configurarea se face în patru pași:

  1. Creați un Private Endpoint în VNet-ul dumneavoastră
  2. Conectați-l la resursa Azure AI
  3. Dezactivați accesul public pe punctul final
  4. Configurați DNS privat pentru rezoluție

Pasul trei este cel pe care oamenii îl uită, iar fără el, calea publică rămâne deschisă în paralel: Private Link există, dar nimic nu împiedică ocolirea acestuia.

În același spirit, o Identitate Gestionată elimină cheia API din ecuație: aplicația obține tokenurile de la Microsoft Entra ID, astfel încât nu există niciun secret de stocat sau de rotit. Totuși, se aplică două condiții. Clientul MistralAzure documentat de Mistral se autentifică prin cheie; autentificarea fără cheie descrisă de Microsoft trece printr-un model implementat într-o resursă Microsoft Foundry, interogat pe ruta sa compatibilă OpenAI /openai/v1/, cu tokenuri emise pentru domeniul https://ai.azure.com/.default. De asemenea, identității trebuie să i se fi acordat anterior rolul de inferență pe resursă. Un furnizor de tokenuri, mai degrabă decât un token citit o singură dată la pornire, reînnoiește accesul înainte de expirare:

from azure.identity import ManagedIdentityCredential, get_bearer_token_provider
from openai import OpenAI

token_provider = get_bearer_token_provider(
    ManagedIdentityCredential(),
    "https://ai.azure.com/.default",
)

client = OpenAI(
    base_url="https://<resource>.openai.azure.com/openai/v1/",
    api_key=token_provider,
)

response = client.chat.completions.create(
    model="my-mistral-deployment",  # name of your deployment
    messages=[{"role": "user", "content": "Summarize the data retention policy."}],
)
print(response.choices[0].message.content)

Sursă: Endpoints for Microsoft Foundry Models — keyless authentication.

Lista de verificare pentru pregătirea în producție

Înainte de a declara implementarea gata, parcurgeți lanțul în ordinea în care a fost construit. Variabilele de mediu și secretele trebuie să fi migrat în Key Vault, iar codul de apel trebuie să fie protejat de o retry exponențială care acoperă atât erorile 429, cât și pe cele 5xx. Monitorizarea Application Insights trebuie să raporteze latența, erorile și tokenii, cu alerte corespunzătoare configurate efectiv pentru metricile critice — nu doar planificate. În final, abordați ceea ce oamenii tind să amâne: testele de sarcină rulate efectiv, accesul la rețeaua privată dacă datele sunt sensibile și rotația cheilor API programată cu o dată precisă, nu lăsată la discreția generală.

Puncte cheie

  • Utilizați Azure Key Vault pentru a stoca cheile API, nu variabile de mediu în text clar
  • Monitorizați fiecare apel cu Application Insights (latență, tokeni, erori)
  • Decuplați cu Service Bus pentru sarcini de lucru cu volum mare
  • Utilizați Private Link și Identitate Gestionată pentru medii securizate
  • Rulați teste de sarcină și configurați alerte înainte de a trece în producție