Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Azure tootmises

Õppetund 6 / 14 Värskendatud 2. november 2026 Edasijõudnutele
Sellel lehel
  1. Valmistu robustseks Azure’i kasutuselevõtuks
  2. Tootmisarhitektuur
  3. Jälgimine Application Insightsiga
  4. Skaleeritavus
  5. Võrguturvalisus
  6. Tootmisvalmiduse kontrollnimekiri
  7. Peamised punktid

Valmistu robustseks Azure’i kasutuselevõtuks

Töötav prototüüp sülearvutil ja tootmissüsteem ei erine oma väljakutsekoodi poolest, mis jääb identseks. Need erinevad kõiges, mis seda koodi ümbritseb: kust pärinevad saladused, kuidas jälgitakse toimuvat, mis juhtub liikluse kahekordistumisel ja millist võrguteed pidi andmed liiguvad. See tund käsitleb neid nelja mõõdet Mistrali kasutuselevõtul Azure’is.

Tootmisarhitektuur

Tüüpiline kasutuselevõtt ühendab viis ehitusplokki. Azure AI lõpp-punkt majutab Mistrali mudelit teenusena (MaaS); Azure Key Vault hoiab API-võtmeid; Azure Monitor ja Application Insights tagavad jälgitavuse; Azure API Management toimib väravana, pakkudes enne sinu rakendust kiiruse piiramist ja autentimist; lõpuks pakub Azure Virtual Network võrgu isolatsiooni, mis on vabatahtlik, kuid tundlike andmete puhul sageli nõutav.

Sinu esimene samm peaks olema saladuste eemaldamine koodist ja keskkonnamuutujatest, lastes rakendusel need käivitamisel lugeda otse Key Vaultist.

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

# Hangi API-võti Key Vaultist
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)

Kasu ei seisne ainult konfidentsiaalsuses. Kui vahetad võtit, pole rakenduse uut kasutuselevõttu vaja, kuna väärtus loetakse võtmehoidlast, mitte pole konfigureerimisse kodeeritud.

Jälgimine Application Insightsiga

Ilma instrumendita on intsidentist ainus teadaolev fakt see, et kasutaja leiab rakenduse “aeglaseks”. Iga väljakutse jälgimine koos selle kestuse, tokenite arvu ja mudeli nimega annab sulle vajaliku, et reageerida mõne minutiga.

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"):
    """Mistrali väljakutse Azure Monitori meetrikatega."""
    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

Need meetrikad on väärtuslikud vaid siis, kui keegi neid jälgib. Seadista Azure Monitoris vastavad hoiatused:

  • P95 latentsus > 5 s – jõudluse halvenemine
  • 5xx veamäär > 1% – serveripoolsed probleemid
  • 429 vead > 10/min – kiiruse piirang saavutatud
  • Tokenite tarbimine > 80% kvoodist – läheneb piirangule

Skaleeritavus

Kui maht kasvab, on esimene viga mudeli sünkroonne kutsumine sissetulevast HTTP-päringust: iga aeglustumine kandub otse kasutajale. Azure Service Busiga lahtiühendamine võimaldab tippe neelata – päringud kuhjuvad järjekorda ja tarbitakse tempos, mida sinu kvoot lubab.

from azure.servicebus import ServiceBusClient, ServiceBusMessage
import json

# Tootja: saada päringud järjekorda
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)

# Tarbija: töötle päringuid järjekorrast
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"]}]
            )
            # Salvesta tulemus...
            receiver.complete_message(msg)

Kui kitsaskoht ei tulene hetkekoormusest, vaid läbilaskevõimest endast, võta kasutusele sama mudeli jaoks mitu lõpp-punkti ja jaota väljakutsed nende vahel.

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():
    """Lihtne ümberlülitumine lõpp-punktide vahel."""
    ep = random.choice(endpoints)
    return MistralAzure(server_url=ep["url"], api_key=ep["key"])

Võrguturvalisus

Tundlike andmete puhul tagab Azure Private Link, et liiklus sinu rakenduse ja Mistrali lõpp-punkti vahel ei läbi kunagi avalikku internetti. Konfigureerimine toimub neljas sammus:

  1. Loo oma virtuaalvõrku (VNet) privaatne lõpp-punkt
  2. Ühenda see oma Azure AI ressursiga
  3. Keela lõpp-punktil avalik juurdepääs
  4. Seadista privaatne DNS lahendamiseks

Kolmas samm on see, mida inimesed unustavad, ja ilma selleta jääb avalik tee paralleelselt avatuks: Private Link on olemas, kuid miski ei takista selle möödaminemist.

Samas vaimus eemaldab hallatav identiteet API-võtmi võrrandist: rakendus hankib oma tokenid Microsoft Entra ID-lt, nii et pole saladust, mida hoida või vahetada. Siiski kehtivad kaks tingimust. Mistrali dokumenteeritud MistralAzure klient autentib võtmega; Microsofti kirjeldatud võtmeta autentimine toimub läbi Microsoft Foundry ressursi paigutatud mudeli, mida päritakse selle OpenAI-ga ühilduval teel /openai/v1/, kasutades tokeneid, mis on väljastatud ulatusele https://ai.azure.com/.default. Lisaks peab identiteedile olema eelnevalt antud järeldusroll (inference role) ressursil. Tokenite pakkuja uuendab juurdepääsu enne aegumist, selle asemel et lugeda tokenit käivitamisel vaid üks kord:

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",  # sinu kasutuselevõtu nimi
    messages=[{"role": "user", "content": "Summarize the data retention policy."}],
)
print(response.choices[0].message.content)

Allikas: Endpoints for Microsoft Foundry Models — keyless authentication.

Tootmisvalmiduse kontrollnimekiri

Enne kui kuulutad oma kasutuselevõtu valmis, käi ahel läbi järjekorras, milles see loodi. Keskkonnamuutujad ja saladused peavad olema viidud Key Vaulti ning sinu väljakutsekood peab olema kaitstud eksponentsiaalse uuestiproovimisega, mis hõlmab nii 429 kui ka 5xx vigu. Application Insightsi jälgimine peab raportima latentsust, vigu ja tokeneid, kusjuures kriitiliste meetrikate jaoks peavad olema tegelikult seadistatud vastavad hoiatused – mitte ainult planeeritud. Lõpuks tegele sellega, mida inimesed kipuvad edasi lükkama: tegelikult läbi viidud koormustestid, privaatne võrgujuurdepääs, kui andmed on tundlikud, ja API-võtme vahetuse ajakava kindla kuupäevaga, mitte üldise äranägemise järgi.

Peamised punktid

  • Kasuta API-võtmete hoidmiseks Azure Key Vaulti, mitte lihttekstina keskkonnamuutujaid
  • Jälgi iga väljakutset Application Insightsiga (latentsus, tokenid, vead)
  • Kasuta suure mahuga töökoormuste puhul lahtiühendamist Service Busega
  • Kasuta turvalistes keskkondades Private Linki ja hallatavat identiteeti
  • Viige enne tootmisse minekut läbi koormustestid ja seadista hoiatused