Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Azure éles környezetben

6. lecke 14 közül Frissítve 2026. november 2. Haladó
Ezen az oldalon
  1. Felkészülés egy robosztus Azure-telepítésre
  2. Éles architektúra
  3. Monitorozás az Application Insights segítségével
  4. Skálázhatóság
  5. Hálózati biztonság
  6. Éles környezeti készenléti ellenőrzőlista
  7. Főbb megállapítások

Felkészülés egy robosztus Azure-telepítésre

Egy működő prototípus a laptopodon és egy éles rendszer hívó kódja nem különbözik; az identikus marad. A különbség minden másban rejlik: honnan származnak a titkos adatok, hogyan figyeled a történéseket, mi történik, ha megduplázódik a forgalom, és milyen hálózati útvonalon halad az adat. Ez a lecke a Mistral Azure-ra történő telepítésének ezen négy dimenzióját tárgyalja.

Éles architektúra

Egy tipikus telepítés öt építőkövet egyesít. Az Azure AI végpont hostolja a Mistral modellt MaaS-ként; az Azure Key Vault tárolja az API-kulcsokat; az Azure Monitor és az Application Insights biztosítja a megfigyelhetőséget; az Azure API Management átjáróként funkcionál, korlátozással és hitelesítéssel az alkalmazásod előtt; végül egy Azure Virtuális Hálózat biztosítja a hálózati izolációt, ami opcionális, de érzékeny adatok esetén gyakran kötelező.

Az első lépésed az legyen, hogy kivonod a titkos adatokat a kódból és a környezeti változókból, és helyettük az alkalmazást a Key Vaultból olvastatod be őket indításkor.

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

# API-kulcs lekérése a Key Vaultból
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)

Az előny túlmutat az egyszerű bizalmaságon. Kulcscsere esetén nincs szükség az alkalmazás újratelepítésére, mivel az értéket a trezorból olvassa be, nem pedig a konfigurációba van keménykódolva.

Monitorozás az Application Insights segítségével

Instrumentálás nélkül egy incidensről csak annyit tudsz meg, hogy a felhasználó szerint az alkalmazás „lassú“. Ha minden hívást nyomon követsz az időtartamával, a tokenek számával és a használt modellel, meglesz a szükséges információ, hogy percek alatt reagálj.

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 hívás Azure Monitor metrikákkal."""
    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

Ezek a metrikák csak akkor értékesek, ha valaki figyeli őket. Konfiguráld a megfelelő riasztásokat az Azure Monitorban:

  • P95 késleltetés > 5 mp — teljesítményromlás
  • 5xx hibaráta > 1% — szerveroldali problémák
  • 429 hibák > 10/perc — elérte a sebességkorlátot
  • Tokenfogyasztás > a kvóta 80%-a — közeledik a limithez

Skálázhatóság

Ha nő a volumen, az első hiba, ha szinkron módon hívod meg a modellt a bejövő HTTP-kérésből: bármilyen lassulás egyenesen a felhasználóhoz gyűrűzik. Az Azure Service Bus segítségével történő leválasztással elnyelheted a csúcsokat – a kérések sorba állnak, és a kvótád által engedélyezett ütemben kerülnek feldolgozásra.

from azure.servicebus import ServiceBusClient, ServiceBusMessage
import json

# Producer: kérések küldése a sorba
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: kérések feldolgozása a sorból
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"]}]
            )
            # Eredmény tárolása...
            receiver.complete_message(msg)

Ha a szűk keresztmetszet nem a pillanatnyi terhelésből, hanem magából az átviteli sebességből adódik, telepíts több végpontot ugyanahhoz a modellhez, és oszd el közöttük a hívásokat.

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():
    """Egyszerű round-robin a végpontok között."""
    ep = random.choice(endpoints)
    return MistralAzure(server_url=ep["url"], api_key=ep["key"])

Hálózati biztonság

Érzékeny adatok esetén az Azure Private Link biztosítja, hogy az alkalmazásod és a Mistral végpont közötti forgalom soha ne keresztezze a nyilvános internetet. A konfiguráció négy lépésből áll:

  1. Hozz létre egy Privát Végpontot a VNetedben
  2. Kösd össze az Azure AI erőforrásoddal
  3. Tiltsd le a nyilvános hozzáférést a végponton
  4. Konfiguráld a privát DNS-t a feloldáshoz

A harmadik lépés az, amit az emberek gyakran elfelejtenek, és enélkül a nyilvános út párhuzamosan nyitva marad: a Private Link létezik, de semmi sem akadályozza meg, hogy megkerüljék.

Ugyanebben a szellemben a Felügyelt Identitás (Managed Identity) kivonja az API-kulcsot az egyenletből: az alkalmazás a Microsoft Entra ID-től kapja meg a tokenjeit, így nincs mit tárolni vagy cserélni. Két feltétel azonban vonatkozik erre. A Mistral által dokumentált MistralAzure kliens kulccsal hitelesít; a Microsoft által leírt kulcs nélküli hitelesítés egy Microsoft Foundry erőforrásban telepített modellen keresztül zajlik, amelyet az OpenAI-kompatibilis /openai/v1/ útvonalon kérdeznek le, a https://ai.azure.com/.default hatókörre kiállított tokenekkel. Az identitásnak pedig előzetesen meg kell kapnia a következtetési (inference) szerepkört az erőforráson. Egy token-szolgáltató, nem pedig egy indításkor egyszer beolvasott token, újítja meg a hozzáférést a lejárat előtt:

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",  # a telepítésed neve
    messages=[{"role": "user", "content": "Summarize the data retention policy."}],
)
print(response.choices[0].message.content)

Forrás: Végpontok a Microsoft Foundry modellekhez – kulcs nélküli hitelesítés.

Éles környezeti készenléti ellenőrzőlista

Mielőtt késznek nyilvánítod a telepítést, járd végig a láncot abban a sorrendben, ahogy felépült. A környezeti változóknak és titkos adatoknak át kellett költözniük a Key Vaultba, és a hívó kódodat exponenciális újrapróbálkozásnak kell védenie, amely lefedi mind a 429-es, mind az 5xx-es hibákat. Az Application Insights monitorozásnak jelentenie kell a késleltetést, a hibákat és a tokeneket, a kritikus metrikákon pedig ténylegesen konfigurált riasztásoknak kell lenniük – nem csak tervezettek. Végül foglalkozz azzal, amit az emberek hajlamosak elhalasztani: a ténylegesen lefuttatott terheléses tesztek, a privát hálózati hozzáférés, ha az adatok érzékenyek, valamint az API-kulcs cseréjének ütemezése egy konkrét dátummal, nem pedig általános belátásra bízva.

Főbb megállapítások

  • Használd az Azure Key Vaultot az API-kulcsok tárolására, ne sima szöveges környezeti változókat
  • Figyeld meg minden hívást az Application Insights segítségével (késleltetés, tokenek, hibák)
  • Válaszd le a komponenseket a Service Bus segítségével nagy volumenű munkaterhelések esetén
  • Használj Private Linket és Felügyelt Identitást a biztonságos környezetekhez
  • Futtass terheléses teszteket és konfiguráld a riasztásokat, mielőtt éles környezetbe kerülnél