Pular para o conteúdo principal

Desafio 16: Azure OpenAI: Provisionamento e Configuração

Tempo Estimado

45-60 min | Custo: ~$1.00 (estimado) | Domínio: Generative AI Solutions (15-20%)

Habilidades do exame cobertas​

  • Provisionar um recurso Azure OpenAI
  • Selecionar e implantar um modelo Azure OpenAI
  • Configurar limites de taxa e gerenciar tipos de implantação

Visão Geral​

O Azure OpenAI Service fornece acesso via REST API aos poderosos modelos de linguagem da OpenAI, incluindo GPT-4o, GPT-4o-mini e modelos de embedding. O provisionamento requer a seleção do SKU apropriado (S0 para consumo padrão) e o entendimento das opções de implantação disponíveis: Standard (infraestrutura compartilhada, pagamento por token), Global Standard (roteamento otimizado entre regiões) e Provisioned Throughput Units (PTU) para capacidade garantida.

Cada implantação está sujeita a limites de taxa medidos em Tokens Per Minute (TPM) e Requests Per Minute (RPM). Quando os limites são excedidos, o serviço retorna respostas HTTP 429 com headers Retry-After. Aplicações em produção devem implementar estratégias de retry com exponential backoff para lidar com o throttling de forma elegante.

As versões da API seguem o formato YYYY-MM-DD com sufixos preview para recursos pré-GA. As aplicações devem usar versões estáveis da API (ex.: 2024-10-21) e planejar a aposentadoria de versões, que é anunciada com pelo menos 90 dias de antecedência.

Arquitetura​

Este desafio provisiona um recurso Azure OpenAI, implanta modelos com configurações específicas de capacidade e testa o comportamento de rate-limiting e estratégias de retry.

Challenge 16 topology

Pré-requisitos​

  • Assinatura Azure com acesso ao Azure OpenAI aprovado
  • Azure CLI 2.60+ instalado
  • Python 3.9+ com pacotes openai e azure-identity
  • .NET 8 SDK com pacote NuGet Azure.AI.OpenAI

Implementação​

Tarefa 1: Provisionar Recurso Azure OpenAI​

Crie um recurso Azure OpenAI com o SKU S0 em uma região suportada.

# Provisioning is done via Azure CLI or ARM—use the resource with Python SDK
import os
from openai import AzureOpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

# Option 1: API Key authentication
client = AzureOpenAI(
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_key=os.environ["AZURE_OPENAI_KEY"],
    api_version="2024-10-21"
)

# Option 2: Microsoft Entra ID authentication (recommended)
token_provider = get_bearer_token_provider(
    DefaultAzureCredential(),
    "https://cognitiveservices.azure.com/.default"
)

client = AzureOpenAI(
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    azure_ad_token_provider=token_provider,
    api_version="2024-10-21"
)

# Verify connectivity
response = client.chat.completions.create(
    model="gpt-4o",  # This is the deployment name
    messages=[{"role": "user", "content": "Hello, confirm connection."}],
    max_tokens=10
)
print(f"Connected successfully: {response.choices[0].message.content}")

Tarefa 2: Implantar GPT-4o com Capacidade Específica​

Implante um modelo GPT-4o com tipo de implantação Standard e configure a capacidade de TPM.

# Model deployment is managed via Azure CLI or REST management API
# After deployment, test with the Python SDK
import os
from openai import AzureOpenAI

client = AzureOpenAI(
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_key=os.environ["AZURE_OPENAI_KEY"],
    api_version="2024-10-21"
)

# Test the deployed model
response = client.chat.completions.create(
    model="gpt-4o",  # deployment name
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain Azure OpenAI deployment types in one sentence."}
    ],
    max_tokens=100
)

print(f"Response: {response.choices[0].message.content}")
print(f"Tokens used - Prompt: {response.usage.prompt_tokens}, "
      f"Completion: {response.usage.completion_tokens}")

Tarefa 3: Testar Limites de Taxa e Implementar Exponential Backoff​

Envie requisições para observar o comportamento de rate limiting e implemente a lógica de retry adequada.

import os
import time
from openai import AzureOpenAI, RateLimitError

client = AzureOpenAI(
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_key=os.environ["AZURE_OPENAI_KEY"],
    api_version="2024-10-21"
)

def call_with_exponential_backoff(messages, max_retries=5, base_delay=1.0):
    """Implement exponential backoff for rate-limited requests."""
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-4o",
                messages=messages,
                max_tokens=50
            )
            return response
        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            # Use Retry-After header if available, otherwise exponential backoff
            retry_after = getattr(e, "retry_after", None)
            delay = retry_after if retry_after else base_delay * (2 ** attempt)
            print(f"Rate limited. Retrying in {delay:.1f}s (attempt {attempt + 1})")
            time.sleep(delay)

# Simulate high-volume requests to trigger rate limiting
results = []
for i in range(20):
    try:
        response = call_with_exponential_backoff(
            [{"role": "user", "content": f"Say the number {i}"}]
        )
        results.append(response.choices[0].message.content)
        print(f"Request {i}: Success")
    except RateLimitError:
        print(f"Request {i}: Exhausted retries")

print(f"\nCompleted {len(results)}/20 requests")

Tarefa 4: Comparar Implantações Standard vs Global Standard​

import os
import time
from openai import AzureOpenAI

client = AzureOpenAI(
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_key=os.environ["AZURE_OPENAI_KEY"],
    api_version="2024-10-21"
)

def measure_latency(deployment_name, num_requests=5):
    """Measure average latency for a deployment."""
    latencies = []
    for _ in range(num_requests):
        start = time.time()
        response = client.chat.completions.create(
            model=deployment_name,
            messages=[{"role": "user", "content": "Respond with OK."}],
            max_tokens=5
        )
        latencies.append(time.time() - start)
    return {
        "deployment": deployment_name,
        "avg_latency_ms": sum(latencies) / len(latencies) * 1000,
        "min_latency_ms": min(latencies) * 1000,
        "max_latency_ms": max(latencies) * 1000
    }

# Compare Standard vs Global Standard deployments
standard_results = measure_latency("gpt-4o")          # Standard deployment
global_results = measure_latency("gpt-4o-mini")       # Global Standard deployment

print("Standard Deployment:")
print(f"  Avg: {standard_results['avg_latency_ms']:.0f}ms | "
      f"Min: {standard_results['min_latency_ms']:.0f}ms | "
      f"Max: {standard_results['max_latency_ms']:.0f}ms")

print("\nGlobal Standard Deployment:")
print(f"  Avg: {global_results['avg_latency_ms']:.0f}ms | "
      f"Min: {global_results['min_latency_ms']:.0f}ms | "
      f"Max: {global_results['max_latency_ms']:.0f}ms")

Saída Esperada​

Connected successfully: Hello! Connection confirmed.
Response: Standard uses shared compute with pay-per-token, Global Standard optimizes
routing across regions, and Provisioned (PTU) guarantees dedicated throughput capacity.
Tokens used - Prompt: 22, Completion: 31

Rate limited. Retrying in 1.0s (attempt 1)
Request 0: Success
...
Completed 18/20 requests

Standard Deployment:
  Avg: 450ms | Min: 320ms | Max: 680ms
Global Standard Deployment:
  Avg: 380ms | Min: 280ms | Max: 520ms

Quebra & conserta​

CenárioSintomaCausa RaizCorreção
Criação do recurso falhaErro InvalidApiPropertiesRegião não suporta Azure OpenAIUse uma região suportada (eastus, eastus2, westus, etc.)
Implantação falhaModelNotAvailableModelo não disponível na região selecionadaVerifique a matriz de disponibilidade de modelos ou mude a região
API retorna 401Access denied due to invalid subscription keyChave incorreta ou endpoint incompatívelVerifique se a chave corresponde ao recurso; confira a URL do endpoint
API retorna 429Rate limit is exceededLimite de TPM ou RPM excedidoImplemente exponential backoff; aumente a capacidade
API retorna 404Resource not foundNome da implantação errado na requisiçãoVerifique se o nome da implantação está exatamente correto

Verificação de Conhecimento​

1. Qual SKU é necessário ao criar um recurso Azure OpenAI via Azure CLI?

2. Qual tipo de implantação oferece capacidade de throughput garantida com custo mensal fixo?

3. Quando o Azure OpenAI retorna HTTP 429, qual header indica quanto tempo esperar antes de tentar novamente?

4. Qual é a unidade de capacidade para implantações Standard ao configurar limites de taxa?

5. Qual formato de versão da API o Azure OpenAI usa, e o que acontece quando uma versão é aposentada?

Limpeza​

az group delete --name rg-ai102-challenge16 --yes --no-wait

Saiba Mais​