Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Azure v produkci

Lekce 6 z 14 Aktualizováno 2. listopadu 2026 Pokročilý
Na této stránce
  1. Příprava robustního nasazení na Azure
  2. Produkční architektura
  3. Monitorování s Application Insights
  4. Škálovatelnost
  5. Zabezpečení sítě
  6. Kontrolní seznam připravenosti k produkci
  7. Klíčové poznatky

Příprava robustního nasazení na Azure

Fungující prototyp na tvém laptopu a produkční systém se neliší volacím kódem, který zůstává totožný. Liší se ve všem, co tento kód obklopuje: odkud pocházejí tajné údaje, jak sleduješ dění, co se stane při zdvojnásobení provozu a kudy putují data po síti. Tato lekce pokrývá tyto čtyři dimenze pro nasazení Mistral na Azure.

Produkční architektura

Typické nasazení spojuje pět stavebních kamenů. Koncový bod Azure AI hostuje model Mistral jako MaaS; Azure Key Vault ukládá klíče API; Azure Monitor a Application Insights zajišťují pozorovatelnost; Azure API Management funguje jako brána s omezováním rychlosti a ověřováním před tvou aplikací; nakonec Azure Virtual Network poskytuje izolaci sítě, což je volitelné, ale u citlivých dat často nezbytné.

Tvým prvním krokem by mělo být vytažení tajných údajů z kódu a proměnných prostředí tak, aby si je aplikace při startu četla přímo z Key Vault.

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

# Načtení klíče API z 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)

Přínos přesahuje prostou důvěrnost. Když rotuješ klíč, není potřeba žádné nové nasazení aplikace, protože hodnota se čte z trezoru, nikoliv není natvrdo zakódována v konfiguraci.

Monitorování s Application Insights

Bez instrumentace se o incidentu dozvíš jen to, že uživatel považuje aplikaci za „pomalou“. Trasování každého volání s jeho dobou trvání, počtem tokenů a použitým modelem ti dá vše potřebné k reakci během minut.

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"):
    """Volání Mistral s metrikami Azure Monitor."""
    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

Tyto metriky mají cenu pouze tehdy, pokud je někdo sleduje. Nakonfiguruj odpovídající alerty v Azure Monitor:

  • Latence P95 > 5 s – degradace výkonu
  • Chybovost 5xx > 1 % – problémy na straně serveru
  • Chyby 429 > 10/min – dosažen limit rychlosti
  • Spotřeba tokenů > 80 % kvóty – blížící se limit

Škálovatelnost

Když roste objem, první chybou je synchronní volání modelu z příchozího HTTP požadavku: jakékoli zpomalení se přímo přenese na uživatele. Oddělení pomocí Azure Service Bus ti umožní absorbovat špičky – požadavky se hromadí ve frontě a jsou zpracovávány tempem, které umožňuje tvoje kvóta.

from azure.servicebus import ServiceBusClient, ServiceBusMessage
import json

# Producent: odeslání požadavků do fronty
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)

# Konzument: zpracování požadavků z fronty
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"]}]
            )
            # Uložení výsledku...
            receiver.complete_message(msg)

Pokud úzkým hrdlem není okamžitá zátěž, ale samotná propustnost, nasaď více koncových bodů pro stejný model a rozlož mezi ně volání.

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():
    """Jednoduchý round-robin mezi koncovými body."""
    ep = random.choice(endpoints)
    return MistralAzure(server_url=ep["url"], api_key=ep["key"])

Zabezpečení sítě

U citlivých dat Azure Private Link zajišťuje, že provoz mezi tvou aplikací a koncovým bodem Mistral nikdy neopustí veřejný internet. Konfigurace probíhá ve čtyřech krocích:

  1. Vytvoř privátní koncový bod ve své VNet
  2. Propoj jej se svým zdrojem Azure AI
  3. Zakaž veřejný přístup na koncovém bodu
  4. Nakonfiguruj privátní DNS pro překlad názvů

Třetí krok je ten, na který lidé zapomínají, a bez něj zůstává veřejná cesta otevřená paralelně: Private Link existuje, ale nic nebrání jeho obejití.

Ve stejném duchu Managed Identity odstraní klíč API z rovnice: aplikace získává své tokeny od Microsoft Entra ID, takže není co ukládat ani rotovat. Platí však dvě podmínky. Klient MistralAzure dokumentovaný společností Mistral se ověřuje klíčem; ověření bez klíče, které popisuje Microsoft, probíhá přes model nasazený ve zdroji Microsoft Foundry, dotazovaný na jeho route kompatibilní s OpenAI /openai/v1/, s tokeny vydanými pro scope https://ai.azure.com/.default. Identita musí mít navíc předem udělenou roli pro inferenci na tomto zdroji. Poskytovatel tokenů, nikoliv token načtený jednou při startu, obnovuje přístup před vypršením:

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",  # název tvého nasazení
    messages=[{"role": "user", "content": "Shrň zásady uchovávání dat."}],
)
print(response.choices[0].message.content)

Zdroj: Endpoints for Microsoft Foundry Models — keyless authentication.

Kontrolní seznam připravenosti k produkci

Než prohlásíš své nasazení za hotové, projdi řetězec v pořadí, v jakém byl budován. Proměnné prostředí a tajné údaje se musí přesunout do Key Vault a tvůj volací kód musí být chráněn exponenciálním opakováním pokrývajícím chyby 429 i 5xx. Monitorování Application Insights musí hlásit latenci, chyby a tokeny, přičemž na kritické metriky musí být skutečně nakonfigurovány alerty – ne jen naplánovány. Nakonec se pusť do toho, co lidé mají tendenci odkládat: skutečně provedené zátěžové testy, přístup přes privátní síť, pokud jsou data citlivá, a rotace klíčů API naplánovaná na konkrétní datum, nikoliv ponechaná na obecném uvážení.

Klíčové poznatky

  • Používej Azure Key Vault k ukládání klíčů API, nikoliv prosté textové proměnné prostředí
  • Monitoruj každé volání pomocí Application Insights (latence, tokeny, chyby)
  • Pro vysoké objemy práce odděl komponenty pomocí Service Bus
  • V zabezpečených prostředích používej Private Link a Managed Identity
  • Před nasazením do produkce proveď zátěžové testy a nakonfiguruj alerty