Azure ražošanas vidē
Šajā lapā
Sagatavo stabilu Azure izvietošanu
Darbojošs prototips tavā klēpjdatorā un ražošanas sistēma neatšķiras ar izsaukuma kodu, kas paliek identisks. Tās atšķiras visā, kas šo kodu ieskauj: no kurienes nāk noslēpumi, kā tu novēro notiekošo, kas notiek, kad satiksme dubultojas, un pa kuru tīkla ceļu dati ceļo. Šī nodarbība aptver šīs četras dimensijas Mistral izvietošanai Azure vidē.
Ražošanas arhitektūra
Tipisks izvietojums apvieno piecus būvblokus. Azure AI galapunkts mitina Mistral modeli kā MaaS; Azure Key Vault glabā API atslēgas; Azure Monitor un Application Insights nodrošina novērojamību; Azure API Management darbojas kā vārteja ar ierobežošanu un autentifikāciju tavas lietotnes priekšā; visbeidzot, Azure Virtual Network nodrošina tīkla izolāciju, kas ir opcionāla, bet bieži nepieciešama sensitīviem datiem.
Tavam pirmajam solim jābūt noslēpumu izņemšanai no koda un vides mainīgajiem, liekot lietotnei tos nolasīt palaišanas brīdī tieši no 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)
Ieguvums sniedzas tālāk par vienkāršu konfidencialitāti. Rotējot atslēgu, nav nepieciešama lietotnes atkārtota izvietošana, jo vērtība tiek nolasīta no seifa, nevis iekodēta konfigurācijā.
Uzraudzība ar Application Insights
Bez instrumentēšanas vienīgais, ko uzzināsi par incidentu, ir tas, ka lietotājs uzskata lietotni par “lēnu”. Katra izsaukuma izsekošana ar tā ilgumu, tokena skaitu un modeli dod tev nepieciešamo, lai reaģētu minūšu laikā.
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
Šie rādītāji ir vērtīgi tikai tad, ja kāds tos uzrauga. Konfigurē atbilstošos brīdinājumus Azure Monitor:
- P95 latentums > 5 s — veiktspējas pasliktināšanās
- 5xx kļūdu līmenis > 1% — servera puses problēmas
- 429 kļūdas > 10/min — sasniegts ātruma ierobežojums
- Tokena patēriņš > 80% no kvotas — tuvojas limits
Mērogojamība
Pieaugot apjomam, pirmā kļūda ir modeļa sinhrona izsaukšana no ienākošā HTTP pieprasījuma: jebkura palēnināšanās tieši pāriet lietotājam. Atsaistīšana ar Azure Service Bus ļauj absorbēt pieaugumus — pieprasījumi sakrājas rindā un tiek apstrādāti tādā tempā, kādu pieļauj tava kvota.
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)
Ja pudeles kakls rodas nevis no momentānās slodzes, bet gan no pašas caurlaidspējas, izvieto vairākus galapunktus vienam un tam pašam modelim un sadali izsaukumus starp tiem.
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"])
Tīkla drošība
Sensitīviem datiem Azure Private Link nodrošina, ka satiksme starp tavu lietotni un Mistral galapunktu nekad nešķērso publisko internetu. Konfigurācija notiek četros soļos:
- Izveido privātu galapunktu savā VNet
- Sasaisti to ar savu Azure AI resursu
- Atspējo publisko piekļuvi galapunktam
- Konfigurē privātu DNS atrisināšanai
Trešais solis ir tas, ko cilvēki aizmirst, un bez tā publiskais ceļš paliek atvērts paralēli: Private Link pastāv, taču nekas neliedz to apiet.
Tādā pašā garā Pārvaldītā identitāte (Managed Identity) izslēdz API atslēgu no vienādojuma: lietotne iegūst savus tokenus no Microsoft Entra ID, tāpēc nav jāglabā vai jārotē nekādi noslēpumi. Tomēr ir spēkā divi nosacījumi. Mistral dokumentētais MistralAzure klients autentificējas ar atslēgu; autentifikācija bez atslēgas, ko apraksta Microsoft, notiek caur modelim, kas izvietots Microsoft Foundry resursā, kuram tiek jautāts pa tā OpenAI saderīgo maršrutu /openai/v1/, ar tokeniem, kas izdoti scope https://ai.azure.com/.default. Turklāt identitātei iepriekš jābūt piešķirtai secināšanas (inference) lomai šajā resursā. Tokena nodrošinātājs, nevis vienreiz palaišanas brīdī nolasīts tokens, atjauno piekļuvi pirms tās beigā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", # name of your deployment
messages=[{"role": "user", "content": "Summarize the data retention policy."}],
)
print(response.choices[0].message.content)
Avots: Endpoints for Microsoft Foundry Models — keyless authentication.
Gatavības pārbaudes saraksts ražošanai
Pirms paziņo, ka tavs izvietojums ir gatavs, izie cauri ķēdei tādā secībā, kādā tā tika veidota. Vides mainīgajiem un noslēpumiem jābūt pārceltiem uz Key Vault, un tavam izsaukuma kodam jābūt aizsargātam ar eksponenciālu atkārtošanu, kas aptver gan 429, gan 5xx kļūdas. Application Insights uzraudzībai jāziņo par latentumu, kļūdām un tokeniem, un kritiskajiem rādītājiem ir jābūt faktiski konfigurētiem atbilstoši brīdinājumiem, ne tikai plānotiem. Visbeidzot, ķeries klāt tam, ko cilvēki mēdz atlikt: faktiski veiktas slodzes pārbaudes, privāta tīkla piekļuve, ja dati ir sensitīvi, un API atslēgu rotācija ieplānota ar konkrētu datumu, nevis atstāta vispārējai izvēlei.
Galvenās atziņas
- Izmanto Azure Key Vault API atslēgu glabāšanai, nevis tīra teksta vides mainīgos
- Uzraugi katru izsaukumu ar Application Insights (latentums, tokeni, kļūdas)
- Atsaisti procesus ar Service Bus liela apjoma darba slodzēm
- Izmanto Private Link un Managed Identity drošām vidēm
- Veic slodzes pārbaudes un konfigurē brīdinājumus pirms pāriešanas uz ražošanu