Gerenciar a cota de Modelos Foundry do Microsoft Azure OpenAI (clássico)

Visualizando atualmente:versão do portal Foundry (clássico) - Alternar para a versão do novo portal Foundry

A cota fornece a flexibilidade para gerenciar ativamente a alocação de limites de taxa entre as implantações na sua assinatura. Este artigo explica o processo de gerenciamento de sua cota Azure OpenAI.

Pré-requisitos

Introdução à cota

O recurso de cota do Azure OpenAI permite a atribuição de limites de velocidade para suas implantações, até um limite global chamado quota. A cota é atribuída à sua assinatura por região, por modelo, por tipo de implantação em unidades de TPM (Tokens por Minuto). Ao integrar uma assinatura ao Azure OpenAI, você recebe a cota padrão para a maioria dos modelos disponíveis. Em seguida, você atribui o TPM a cada implantação conforme ela é criada e a cota disponível para esse modelo é reduzida por esse valor. Você pode continuar a criar implantações e atribuí-las ao TPM até atingir o limite de cota. Quando isso acontece, você só pode criar novas implantações desse modelo reduzindo o TPM atribuído a outras implantações do mesmo modelo (liberando assim o TPM para uso) ou solicitando e sendo aprovado para um aumento de cota de modelo na região desejada.

Quando uma implantação é criada, o TPM atribuído é mapeado diretamente para o limite de taxa de tokens por minuto imposto em suas solicitações de inferência. Um limite de taxa RPM (Requests-Per-Minute) também é aplicado, cujo valor é definido proporcionalmente à atribuição do TPM utilizando a seguinte proporção:

A flexibilidade para distribuir o TPM globalmente em uma assinatura e região permitiu que o Azure OpenAI afrouxasse outras restrições.

• Os recursos máximos por região são aumentados para 30.
• O limite para criar não mais do que uma implantação do mesmo modelo em um recurso foi removido.

Solicitar mais cota

Envie o formulário de solicitação de aumento de cota para solicitar aumentos de cota para Modelos do Foundry vendidos pelo Azure, modelos do Azure OpenAI e modelos da Anthropic. Com exceção de modelos da Anthropic, Modelos de parceiros e comunidade não dão suporte a aumentos de cota.

As solicitações de aumento de cota são processadas na ordem em que são recebidas e a prioridade vai para os clientes que usam ativamente sua alocação de cota existente. Solicitações que não atendem a essa condição podem ser negadas.

Configurações específicas do modelo

Diferentes implantações de modelo, também chamadas de classes de modelo, têm valores TPM máximos exclusivos que agora você pode controlar. Isso representa a quantidade máxima de TPM que pode ser alocada para esse tipo de implantação de modelo em uma determinada região.

Todas as outras classes de modelo têm um valor TPM máximo comum.

Atribuir cota

Ao criar uma implantação de modelo, você tem a opção de atribuir tokens por minuto (TPM) a essa implantação. O TPM pode ser modificado em incrementos de 1.000 e será mapeado para os limites de taxa de TPM e RPM impostos em sua implantação, conforme discutido acima.

Para criar uma nova implantação no portal Microsoft Foundry selecione Deployments>Deploy model>Deploy base model>Select Model>Confirm.

Após a implantação, você pode ajustar a alocação do TPM selecionando e editando seu modelo na página Implantações no portal do Foundry. Você também pode modificar essa configuração na página de Gerenciamento>de cotas do Modelo.

Exibir e solicitar cota

Para obter uma exibição completa de suas alocações de cota em implantações em uma determinada região, selecione Gerenciamento>Cota no portal do Foundry:

• Implantação: implantações de modelo divididas por classe de modelo.
• Tipo de cota: há um valor de cota por região para cada tipo de modelo. A cota abrange todas as versões desse modelo.
• Atribuição de cotas:para o nome da cota, é exibido o volume de cota utilizado pelas implantações e a cota total aprovada para esta assinatura e região. Essa quantidade de cota usada também é representada no grafo de barras.
• Cota de Solicitação: o ícone navega até esse formulário em que as solicitações para aumentar a cota podem ser enviadas.

Migrando implantações existentes

Como parte da transição para o novo sistema de cotas e a alocação baseada em TPM, todas as implantações de modelo openai Azure existentes foram migradas automaticamente para usar a cota. Nos casos em que a alocação de TPM/RPM existente excede os valores padrão devido a aumentos de limite de taxa personalizados anteriores, o TPM equivalente foi atribuído às implantações afetadas.

Noções básicas sobre limites de taxa

Atribuir o TPM a uma implantação define os limites de taxa de TPM (Tokens por Minuto) e RPM (Solicitações por Minuto) para a implantação, conforme descrito acima. Os limites de taxa do TPM são baseados no número máximo de tokens que são estimados para serem processados por uma solicitação no momento em que a solicitação é recebida. Não é o mesmo que a contagem de tokens usada para cobrança, que é computada depois que todo o processamento é concluído.

À medida que cada solicitação é recebida, Azure OpenAI calcula uma contagem máxima estimada de token processado que inclui o seguinte:

• Texto e contagem de prompts
• A configuração do parâmetro 'max_tokens'
• A configuração do parâmetro best_of

À medida que as solicitações entram no ponto de extremidade de implantação, a contagem estimada de tokens processados máximos é adicionada a uma contagem de tokens em execução de todas as solicitações que são redefinidas a cada minuto. Se, a qualquer momento durante esse minuto, o valor do limite de taxa do TPM for atingido, outras solicitações receberão um código de resposta 429 até que o contador seja redefinido.

Os limites de taxa rpm são baseados no número de solicitações recebidas ao longo do tempo. O limite de taxa espera que as solicitações sejam distribuídas uniformemente durante um período de um minuto. Se esse fluxo médio não for mantido, as solicitações poderão receber uma resposta de 429, mesmo que o limite não seja atendido quando medido ao longo de um minuto. Para implementar esse comportamento, Azure OpenAI avalia a taxa de solicitações de entrada em um pequeno período de tempo, normalmente de 1 ou 10 segundos. Se o número de solicitações recebidas durante esse tempo exceder o esperado no limite de RPM definido, as novas solicitações receberão um código de resposta 429 até o próximo período de avaliação. Por exemplo, se Azure OpenAI estiver monitorando a taxa de solicitação em intervalos de 1 segundo, a limitação de taxa ocorrerá para uma implantação de 600 RPM se mais de 10 solicitações forem recebidas durante cada período de 1 segundo (600 solicitações por minuto = 10 solicitações por segundo).

Cabeçalhos de resposta de limite de taxa

Azure OpenAI inclui informações de limite de taxa nos cabeçalhos de resposta HTTP de cada chamada à API. Use esses cabeçalhos para monitorar programaticamente seu uso e evitar proativamente 429 erros.

Práticas recomendadas de limitação de taxa

Para minimizar problemas relacionados aos limites de taxa, use as seguintes técnicas:

Otimizar suas solicitações

• Defina max_tokens como o valor mínimo que atende ao seu cenário. A estimativa do token de limite de taxa inclui max_tokens, mesmo que a sua resposta real seja muito mais curta. Por exemplo, se você espera respostas de cerca de 200 tokens, não defina max_tokens como 4.000.
• Defina best_of como 1, a menos que você precise especificamente de várias conclusões. Cada incremento de best_of multiplica a contagem de tokens em relação a seu limite de taxa.
• Reduza o tamanho do prompt sempre que possível. Prompts mais curtos consomem menos tokens do seu limite de taxa.

Implementar a lógica de repetição com a retirada exponencial

Tente novamente solicitações automaticamente quando receber uma resposta 429. Use o valor do cabeçalho retry-after-ms, se houver; caso contrário, use a retirada exponencial com jitter aleatório:

1. Aguarde um atraso curto e aleatório após a primeira falha.
2. Se a repetição falhar, dobre a espera (backoff exponencial).
3. Adicione tremulação aleatória para impedir que todos os clientes tentem novamente no mesmo instante.
4. Defina um número máximo de repetições (por exemplo, 5 a 10) para evitar loops infinitos.

Opção 1: usar a repetição interna do SDK (mais simples – recomendado)

O SDK do Azure OpenAI para Python (openai v1.0+) possui uma funcionalidade integrada de repetição automática com retirada exponencial para erros 429 e erros transitórios. O padrão é duas novas tentativas. Você pode aumentá-lo:

from openai import AzureOpenAI

# Set max_retries globally on the client (default is 2)
client = AzureOpenAI(
    azure_endpoint="https://<your-resource>.openai.azure.com/",
    api_key="<your-api-key>",
    api_version="2024-10-21",
    max_retries=5  # up to 5 retries with automatic exponential backoff
)

# All calls through this client automatically retry on 429
response = client.chat.completions.create(
    model="gpt-4o",  # deployment name
    messages=[{"role": "user", "content": "Hello"}]
)

# Or override per-request:
response = client.with_options(max_retries=8).chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}]
)

Opção 2: repetição personalizada com a tenacity biblioteca (avançada)

Use isso quando precisar de mais controle sobre o comportamento de repetição de tentativas (por exemplo, registro personalizado de logs, tratamento seletivo de exceções, disjuntores de circuito):

import openai
from openai import AzureOpenAI
from tenacity import (
    retry,
    retry_if_exception_type,
    stop_after_attempt,
    wait_random_exponential,
)

client = AzureOpenAI(
    azure_endpoint="https://<your-resource>.openai.azure.com/",
    api_key="<your-api-key>",
    api_version="2024-10-21",
    max_retries=0  # disable SDK built-in retry to avoid double-retrying
)

@retry(
    wait=wait_random_exponential(min=1, max=60),
    stop=stop_after_attempt(6),
    retry=retry_if_exception_type(openai.RateLimitError),  # only retry on 429
    reraise=True
)
def chat_completion_with_backoff(**kwargs):
    return client.chat.completions.create(**kwargs)

response = chat_completion_with_backoff(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}]
)

Opção 3: implementação manual (sem biblioteca de terceiros)

import time
import random
import openai
from openai import AzureOpenAI

client = AzureOpenAI(
    azure_endpoint="https://<your-resource>.openai.azure.com/",
    api_key="<your-api-key>",
    api_version="2024-10-21",
    max_retries=0  # disable SDK built-in retry
)

def retry_with_exponential_backoff(
    func,
    initial_delay: float = 1,
    exponential_base: float = 2,
    jitter: bool = True,
    max_retries: int = 10,
    errors: tuple = (openai.RateLimitError,),
):
    """Retry a function with exponential backoff."""
    def wrapper(*args, **kwargs):
        num_retries = 0
        delay = initial_delay
        while True:
            try:
                return func(*args, **kwargs)
            except errors as e:
                num_retries += 1
                if num_retries > max_retries:
                    raise Exception(
                        f"Maximum number of retries ({max_retries}) exceeded."
                    ) from e
                delay *= exponential_base * (1 + jitter * random.random())
                time.sleep(delay)
            except Exception as e:
                raise e
    return wrapper

@retry_with_exponential_backoff
def chat_completion_with_backoff(**kwargs):
    return client.chat.completions.create(**kwargs)

Exemplo de C# usando Polly (v7):

using Azure;
using Azure.AI.OpenAI;
using Polly;

var retryPolicy = Policy
    .Handle<RequestFailedException>(ex => ex.Status == 429)
    .WaitAndRetryAsync(
        retryCount: 6,
        sleepDurationProvider: (retryAttempt, exception, context) =>
        {
            // Use retry-after-ms header if available
            if (exception is RequestFailedException rfEx)
            {
                var raw = rfEx.GetRawResponse();
                if (raw != null && raw.Headers.TryGetValue("retry-after-ms", out string value)
                    && int.TryParse(value, out int ms))
                {
                    return TimeSpan.FromMilliseconds(ms);
                }
            }
            // Otherwise, exponential backoff with jitter
            return TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))
                + TimeSpan.FromMilliseconds(Random.Shared.Next(0, 1000));
        },
        onRetry: (exception, timespan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} after {timespan.TotalSeconds:F1}s due to: {exception.Message}");
        }
    );

// Usage
var endpoint = new Uri("https://<your-resource>.openai.azure.com/");
var credential = new AzureKeyCredential("<your-api-key>");
var client = new AzureOpenAIClient(endpoint, credential);

await retryPolicy.ExecuteAsync(async () =>
{
    var response = await client.GetChatClient("gpt-4o")
        .CompleteChatAsync([new UserChatMessage("Hello")]);
    Console.WriteLine(response.Value.Content[0].Text);
});

Monitorar e gerenciar o uso em nível de implantação

• Verifique a alocação de TPM para cada implantação, não apenas a cota no nível da assinatura. É possível que você tenha uma cota aprovada no nível da assinatura, mas esteja recebendo erros 429 porque a cota não foi alocada à implantação específica que está recebendo o tráfego.
• Reequilibrar a cota entre implantações com base no uso observado. Utilize métricas do Azure Monitor para examinar tendências de uso em 24 horas e em sete dias e detectar padrões de uso intermitente.
• Use o gerenciamento de cotas no portal do Foundry para aumentar o TPM em implantações de alto tráfego e reduzir o TPM em implantações subutilizadas.

Distribuir o tráfego uniformemente

• Evite picos acentuados na carga de trabalho. Os limites de taxa de RPM esperam que as solicitações sejam distribuídas uniformemente a cada minuto. Mesmo que o total de solicitações esteja abaixo do limite por minuto, um pico de tráfego dentro de uma janela de 1 segundo ou 10 segundos pode acionar um erro 429.
• Aumente o tráfego gradualmente ao integrar novas cargas de trabalho ou aumentar a carga.
• Espalhe solicitações em várias implantações ou regiões se sua carga de trabalho exigir uma taxa de transferência maior do que uma única implantação dá suporte.

Use o processamento assíncrono/em lote sempre que possível

Se o caso de uso não exigir respostas imediatas, considere o uso de padrões assíncronos:

• Enfileirar solicitações e processá-las a uma taxa controlada.
• Use várias implantações para paralelizar o processamento sem exceder o limite de taxa de implantação única.

Noções básicas sobre erros de limitação 429 e o que fazer

Um erro 429 ("Muitas Solicitações") significa que o sistema rejeitou sua solicitação porque um limite de taxa foi excedido ou o sistema não pode processar sua solicitação no momento. Nem todos os 429 erros têm a mesma causa raiz e a ação correta depende do motivo pelo qual o 429 ocorreu.

Tipos de 429 erros

Por que você pode ver 429s mesmo quando as métricas de uso de token estão abaixo da cota

A limitação de taxa e as métricas de uso do Azure OpenAI não são a mesma coisa:

• Métricas de uso de tokens no Azure Monitor mostram tokens faturados de solicitações processadas com êxito.
• A limitação de taxa se aplica às solicitações de API no momento em que são recebidas, incluindo solicitações que posteriormente são rejeitadas ou nunca cobradas.

Devido a essa diferença, você pode obter 429 respostas mesmo quando as métricas de uso do token parecem bem abaixo da cota. Os motivos comuns incluem:

• max_tokens superestimação: os limites de taxa são calculados usando a contagem máxima estimada de tokens (prompt + max_tokens), não os tokens reais gerados.
• Solicitações rejeitadas: as solicitações rejeitadas devido aos limites de comprimento de entrada (HTTP 400) ainda podem contar para a limitação de taxa, mas não aparecerão em métricas de token cobradas.
• Padrões de pico: a imposição de RPM avalia solicitações em janelas de tempo pequenas (1 a 10 segundos). Uma onda de solicitações em um curto intervalo de tempo aciona a limitação, mesmo que o total por minuto esteja dentro dos limites.
• Ajuste temporário de limite de taxa para confiabilidade do serviço: implantações padrão (pagas conforme o uso) compartilham um pool de recursos comum entre os clientes. Para manter o serviço confiável e justo, o sistema monitora continuamente a demanda nesse pool compartilhado. Quando a demanda de uma implantação se aproxima ou excede os limites de capacidade, o sistema pode reduzir temporariamente o limite de taxa efetivo para essa implantação. Durante esse período de ajuste, as solicitações que teriam sido aceitas em condições normais retornam 429 respostas, mesmo que sua cota configurada não tenha sido alterada. Essa medida de proteção impede a degradação do serviço para todos os clientes que compartilham o pool de recursos. O ajuste é temporário e normalmente é resolvido em poucas horas depois que o tráfego se estabiliza. Você pode monitorar essa condição verificando se o seu limite de taxa efetivo (visível nos cabeçalhos da resposta x-ratelimit-limit-tokens ) é inferior à sua alocação de TPM configurada.
• Imposição distribuída: a imposição de limite de taxa em toda a infraestrutura distribuída pode não ser perfeitamente precisa ou imediatamente refletida em métricas agregadas.

No que confiar:

• Use métricas de uso de token para entender o consumo cobrado.
• Use códigos de resposta HTTP (429) e cabeçalhos de resposta (x-ratelimit-remaining-*, x-ratelimit-limit-*) para detectar e responder à imposição de limite de taxa em tempo real.
• Compare os cabeçalhos de resposta x-ratelimit-limit-tokens com o seu TPM configurado para detectar se um ajuste temporário está ativo.

Quando tentar novamente versus quando escalonar

Verificar programaticamente a cota e a capacidade

Além do portal Foundry, você pode usar duas APIs REST Azure Resource Manager para verificar programaticamente o consumo de cotas da sua assinatura e a capacidade do modelo disponível.

Escolher a API certa

Use a API de usos quando precisar de uma exibição do razão daquilo que você consumiu e do que resta. Use a API de Capacidades de Modelo quando quiser saber onde você pode implantar um modelo e quanta capacidade está disponível em cada local.

API de usos

A API de Usos retorna todas as linhas de cota para uma determinada região, incluindo o consumo atual (currentValue) e o limite atribuído.

Solicitação:

GET https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.CognitiveServices/locations/{location}/usages?api-version=2024-10-01

Exemplo : verifique o uso da cota no Leste dos EUA:

import requests
import json
from azure.identity import DefaultAzureCredential

subscription_id = "<your-subscription-id>"
location = "eastus"

credential = DefaultAzureCredential()
token = credential.get_token("https://management.azure.com/.default")
headers = {"Authorization": f"Bearer {token.token}"}

url = (
    f"https://management.azure.com/subscriptions/{subscription_id}"
    f"/providers/Microsoft.CognitiveServices/locations/{location}/usages"
    f"?api-version=2024-10-01"
)

response = requests.get(url, headers=headers)
usages = response.json()

# Show quota lines that have a non-zero limit
for item in usages["value"]:
    if item["limit"] > 0:
        print(f"{item['name']['localizedValue']}: {item['currentValue']}/{item['limit']}")

SUBSCRIPTION_ID="<your-subscription-id>"
LOCATION="eastus"

az rest --method get \
  --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.CognitiveServices/locations/$LOCATION/usages?api-version=2024-10-01"

{
  "value": [
    {
      "name": {
        "value": "OpenAI.Standard.gpt-4o",
        "localizedValue": "Tokens Per Minute (thousands) - gpt-4o"
      },
      "currentValue": 0,
      "limit": 150,
      "unit": "Count"
    }
  ]
}

Campos-chave:

API de Capacidades dos Modelos

A API de Capacidades de Modelo retorna a capacidade de implantação disponível para um modelo específico em todos os locais e tipos de implantação em sua assinatura.

Solicitação:

GET https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.CognitiveServices/modelCapacities?api-version=2024-10-01&modelFormat={format}&modelName={name}&modelVersion={version}

Exemplo : verifique onde a capacidade do gpt-4o está disponível:

import requests
import json
from azure.identity import DefaultAzureCredential

subscription_id = "<your-subscription-id>"
model_name = "gpt-4o"
model_version = "2024-08-06"

credential = DefaultAzureCredential()
token = credential.get_token("https://management.azure.com/.default")
headers = {"Authorization": f"Bearer {token.token}"}

url = (
    f"https://management.azure.com/subscriptions/{subscription_id}"
    f"/providers/Microsoft.CognitiveServices/modelCapacities"
    f"?api-version=2024-10-01"
    f"&modelFormat=OpenAI&modelName={model_name}&modelVersion={model_version}"
)

response = requests.get(url, headers=headers)
capacities = response.json()

# Show locations with available capacity for Standard deployments
for item in capacities["value"]:
    props = item["properties"]
    if props["availableCapacity"] > 0 and "Standard" in props["skuName"]:
        print(f"{item['location']} ({props['skuName']}): {props['availableCapacity']} available")

SUBSCRIPTION_ID="<your-subscription-id>"

az rest --method get \
  --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.CognitiveServices/modelCapacities?api-version=2024-10-01&modelFormat=OpenAI&modelName=gpt-4o&modelVersion=2024-08-06"

{
  "value": [
    {
      "location": "eastus",
      "properties": {
        "model": {
          "name": "gpt-4o",
          "format": "OpenAI",
          "version": "2024-08-06"
        },
        "skuName": "Standard",
        "availableCapacity": 150,
        "availableFinetuneCapacity": 0
      }
    }
  ]
}

Campos-chave:

Automatizar a implantação

Para criar de forma programática implantações do Azure OpenAI e atribuir cota de tokens por minuto (TPM) usando REST, CLI do Azure, Azure PowerShell, ARM, Bicep ou Terraform, consulte Automatizar implantações do Azure OpenAI com cota do Microsoft Foundry.

Exclusão de recursos

Quando uma tentativa de excluir um recurso Azure OpenAI é feita no portal Azure se alguma implantação ainda estiver presente, a exclusão será bloqueada até que as implantações associadas sejam excluídas. Excluir as implantações primeiro permite que as alocações de cota sejam liberadas corretamente para que possam ser usadas em novas implantações.

No entanto, se você excluir um recurso usando a API REST ou algum outro método programático, isso ignorará a necessidade de excluir as implantações primeiro. Quando isso ocorrer, a alocação de cota associada permanecerá indisponível para atribuir a uma nova implantação por 48 horas até que o recurso seja limpo. Para disparar uma limpeza imediata de um recurso excluído para liberar a cota, siga as instruções de limpar um recurso excluído.

Próximas etapas

• Para examinar os padrões de cota para o Azure OpenAI, consulte o artigo quotas e limites