Przejdź do głównej treści
Polski— Wybierz język
Menu

Azure w środowisku produkcyjnym

Lekcja 6 z 14 Zaktualizowano 2 listopada 2026 Zaawansowany
Na tej stronie
  1. Przygotowanie solidnego wdrożenia na Azure
  2. Architektura produkcyjna
  3. Monitorowanie z Application Insights
  4. Skalowalność
  5. Bezpieczeństwo sieciowe
  6. Lista kontrolna gotowości produkcyjnej
  7. Kluczowe wnioski

Przygotowanie solidnego wdrożenia na Azure

Działający prototyp na Twoim laptopie i system produkcyjny nie różnią się kodem wywołującym, który pozostaje identyczny. Różnią się wszystkim, co otacza ten kod: skąd pochodzą sekrety, jak obserwujesz to, co się dzieje, co się stanie, gdy ruch się podwoi, i którą ścieżką sieciową podróżują dane. Ta lekcja omawia te cztery wymiary dla wdrożenia Mistral na platformie Azure.

Architektura produkcyjna

Typowe wdrożenie łączy pięć bloków konstrukcyjnych. Punkt końcowy Azure AI hostuje model Mistral jako MaaS; Azure Key Vault przechowuje klucze API; Azure Monitor i Application Insights zapewniają obserwowalność; Azure API Management działa jako brama z ograniczaniem przepustowości i uwierzytelnianiem przed Twoją aplikacją; wreszcie, Azure Virtual Network zapewnia izolację sieciową, co jest opcjonalne, ale często wymagane w przypadku danych wrażliwych.

Twoim pierwszym krokiem powinno być wyjęcie sekretów z kodu i zmiennych środowiskowych, sprawiając, że aplikacja odczytuje je podczas uruchamiania bezpośrednio z 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)

Korzyść wykracza poza zwykłą poufność. Gdy rotujesz klucz, nie potrzebujesz ponownego wdrażania aplikacji, ponieważ wartość jest odczytywana z sejfu, a nie zaszyta na sztywno w konfiguracji.

Monitorowanie z Application Insights

Bez instrumentacji jedyną rzeczą, o której dowiesz się w przypadku incydentu, będzie to, że użytkownik uznaje aplikację za „wolną“. Śledzenie każdego wywołania z jego czasem trwania, liczbą tokenów i użytym modelem daje Ci to, czego potrzebujesz, aby zareagować w ciągu kilku 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"):
    """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

Te metryki są wartościowe tylko wtedy, gdy ktoś je obserwuje. Skonfiguruj odpowiednie alerty w Azure Monitor:

  • Opóźnienie P95 > 5 s — degradacja wydajności
  • Wskaźnik błędów 5xx > 1% — problemy po stronie serwera
  • Błędy 429 > 10/min — osiągnięto limit przepustowości
  • Zużycie tokenów > 80% kwoty — zbliżanie się do limitu

Skalowalność

Gdy wolumen rośnie, pierwszym błędem jest synchroniczne wywoływanie modelu z przychodzącego żądania HTTP: każde spowolnienie przenosi się bezpośrednio na użytkownika. Rozsprzężenie za pomocą Azure Service Bus pozwala absorbować skoki obciążenia — żądania gromadzą się w kolejce i są konsumowane w tempie, na jakie pozwala Twój limit.

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)

Jeśli wąskim gardłem jest sama przepustowość, a nie chwilowe obciążenie, wdróż wiele punktów końcowych dla tego samego modelu i rozkładaj między nie wywołania.

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"])

Bezpieczeństwo sieciowe

W przypadku danych wrażliwych Azure Private Link zapewnia, że ruch między Twoją aplikacją a punktem końcowym Mistral nigdy nie przekracza publicznego internetu. Konfiguracja odbywa się w czterech krokach:

  1. Utwórz Private Endpoint w swojej sieci VNet
  2. Połącz go ze swoim zasobem Azure AI
  3. Wyłącz dostęp publiczny do punktu końcowego
  4. Skonfiguruj prywatny system DNS do rozwiązywania nazw

Krok trzeci to ten, o którym ludzie zapominają, a bez niego publiczna ścieżka pozostaje otwarta równolegle: Private Link istnieje, ale nic nie предотвраща jego obejścia.

W tym samym duchu Managed Identity usuwa klucz API z równania: aplikacja uzyskuje swoje tokeny z Microsoft Entra ID, więc nie ma żadnego sekretu do przechowywania ani rotowania. Istnieją jednak dwa warunki. Klient MistralAzure opisany przez Mistral uwierzytelnia się za pomocą klucza; uwierzytelnianie bezkluczowe opisane przez Microsoft odbywa się poprzez model wdrożony w zasobie Microsoft Foundry, odpytywany przez jego trasę kompatybilną z OpenAI /openai/v1/, z tokenami wydanymi dla zakresu https://ai.azure.com/.default. Tożsamość musi mieć wcześniej przydzieloną rolę wnioskowania (inference) na tym zasobie. Dostawca tokenów, zamiast tokena odczytanego raz przy starcie, odnawia dostęp przed wygaśnięciem:

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)

Źródło: Endpoints for Microsoft Foundry Models — keyless authentication.

Lista kontrolna gotowości produkcyjnej

Zanim ogłosisz swoje wdrożenie gotowym, przejdź przez cały łańcuch w kolejności, w jakiej został zbudowany. Zmienne środowiskowe i sekrety muszą zostać przeniesione do Key Vault, a Twój kod wywołujący musi być chroniony przez wykładnicze ponawianie prób, obejmujące zarówno błędy 429, jak i 5xx. Monitorowanie Application Insights musi raportować opóźnienia, błędy i tokeny, a odpowiednie alerty muszą być faktycznie skonfigurowane dla krytycznych metryk — a nie tylko zaplanowane. Na koniec zajmij się tym, co ludzie mają tendencję do odkładania: testy obciążeniowe faktycznie przeprowadzone, dostęp przez sieć prywatną, jeśli dane są wrażliwe, oraz harmonogram rotacji kluczy API z określoną datą, a nie pozostawiony do ogólnej decyzji.

Kluczowe wnioski

  • Używaj Azure Key Vault do przechowywania kluczy API, a nie zwykłych zmiennych środowiskowych
  • Monitoruj każde wywołanie za pomocą Application Insights (opóźnienia, tokeny, błędy)
  • Rozsprzęż system za pomocą Service Bus przy dużych obciążeniach
  • Używaj Private Link i Managed Identity w środowiskach wymagających wysokiego bezpieczeństwa
  • Przeprowadź testy obciążeniowe i skonfiguruj alerty przed przejściem na produkcję