Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Azure em Produção

Aula 6 de 14 Atualizada a 2 de novembro de 2026 Avancado
Nesta página
  1. Preparar uma Implementação Robusta no Azure
  2. Arquitetura de Produção
  3. Monitorização com o Application Insights
  4. Escalabilidade
  5. Segurança de Rede
  6. Lista de Verificação de Prontidão para Produção
  7. Pontos-chave

Preparar uma Implementação Robusta no Azure

Um protótipo funcional no seu portátil e um sistema de produção não diferem no código de chamada, que permanece idêntico. Diferem em tudo o que envolve esse código: a origem dos segredos, a forma como observa o que está a acontecer, o que ocorre quando o tráfego duplica e qual o caminho de rede percorrido pelos dados. Esta lição aborda estas quatro dimensões para uma implementação do Mistral no Azure.

Arquitetura de Produção

Uma implementação típica reúne cinco blocos de construção. O ponto final (endpoint) do Azure AI aloja o modelo Mistral como MaaS; o Azure Key Vault armazena as chaves de API; o Azure Monitor e o Application Insights fornecem observabilidade; o Azure API Management atua como gateway com limitação de taxa e autenticação à frente da sua aplicação; finalmente, uma Rede Virtual do Azure fornece isolamento de rede, o que é opcional, mas frequentemente necessário para dados sensíveis.

O seu primeiro passo deve ser retirar os segredos do seu código e das variáveis de ambiente, fazendo com que a aplicação os leia no arranque diretamente do 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)

A vantagem vai além da simples confidencialidade. Quando roda uma chave, não é necessário redistribuir a aplicação, pois o valor é lido no cofre em vez de estar codificado na configuração.

Monitorização com o Application Insights

Sem instrumentação, a única coisa que saberá sobre um incidente é que um utilizador considera a aplicação “lenta”. Rastrear cada chamada com a sua duração, contagem de tokens e modelo fornece-lhe o necessário para responder em minutos.

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

Estas métricas só são valiosas se alguém as monitorizar. Configure os alertas correspondentes no Azure Monitor:

  • Latência P95 > 5s — degradação do desempenho
  • Taxa de erro 5xx > 1% — problemas do lado do servidor
  • Erros 429 > 10/min — limite de taxa atingido
  • Consumo de tokens > 80% da quota — aproximação do limite

Escalabilidade

Quando o volume cresce, o primeiro erro é chamar o modelo de forma síncrona a partir do pedido HTTP recebido: qualquer desaceleração propaga-se diretamente ao utilizador. O desacoplamento com o Azure Service Bus permite absorver picos — os pedidos acumulam-se numa fila e são consumidos ao ritmo que a sua quota permite.

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)

Se o gargalo provier do próprio throughput e não da carga instantânea, implemente múltiplos pontos finais para o mesmo modelo e distribua as chamadas entre eles.

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

Segurança de Rede

Para dados sensíveis, o Azure Private Link garante que o tráfego entre a sua aplicação e o ponto final do Mistral nunca atravessa a internet pública. A configuração ocorre em quatro passos:

  1. Criar um Ponto Final Privado na sua VNet
  2. Ligá-lo ao seu recurso Azure AI
  3. Desativar o acesso público no ponto final
  4. Configurar o DNS privado para resolução

O terceiro passo é aquele que as pessoas esquecem e, sem ele, o caminho público permanece aberto em paralelo: o Private Link existe, mas nada impede que seja contornado.

No mesmo espírito, uma Identidade Gerida remove a chave de API da equação: a aplicação obtém os seus tokens do Microsoft Entra ID, pelo que não há segredo para armazenar ou rodar. Aplicam-se, contudo, duas condições. O cliente MistralAzure documentado pela Mistral autentica-se por chave; a autenticação sem chave descrita pela Microsoft passa por um modelo implementado num recurso Microsoft Foundry, consultado na sua rota compatível com OpenAI /openai/v1/, com tokens emitidos para o âmbito https://ai.azure.com/.default. Além disso, a identidade deve ter recebido previamente a função de inferência no recurso. Um fornecedor de tokens, em vez de um token lido uma vez no arranque, renova o acesso antes da expiração:

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)

Fonte: Endpoints for Microsoft Foundry Models — keyless authentication.

Lista de Verificação de Prontidão para Produção

Antes de declarar a sua implementação pronta, percorra a cadeia pela ordem em que foi construída. As variáveis de ambiente e os segredos devem ter migrado para o Key Vault, e o seu código de chamada deve estar protegido por nova tentativa exponencial que cubra tanto os erros 429 como os 5xx. A monitorização do Application Insights deve reportar latência, erros e tokens, com os alertas correspondentes realmente configurados para métricas críticas — não apenas planeados. Finalmente, aborde o que as pessoas tendem a adiar: testes de carga realmente executados, acesso à rede privada se os dados forem sensíveis e rotação de chaves de API agendada com uma data, não deixada ao critério geral.

Pontos-chave

  • Utilize o Azure Key Vault para armazenar chaves de API, não variáveis de ambiente em texto simples
  • Monitore cada chamada com o Application Insights (latência, tokens, erros)
  • Desacople com o Service Bus para cargas de trabalho de alto volume
  • Utilize o Private Link e a Identidade Gerida para ambientes seguros
  • Execute testes de carga e configure alertas antes de passar para produção