Orientação de limitação do Azure Key VaultAzure Key Vault throttling guidance

A limitação é o processo que você iniciar para limitar o número de chamadas simultâneas para o serviço do Azure a fim de evitar o uso excessivo de recursos.Throttling is a process you initiate that limits the number of concurrent calls to the Azure service to prevent overuse of resources. O AKV (Azure Key Vault) foi projetado para lidar com um grande volume de solicitações.Azure Key Vault (AKV) is designed to handle a high volume of requests. No caso de ocorrer um grande número de solicitações, limitar as solicitações do seu cliente ajuda a manter o desempenho ideal e a confiabilidade do serviço AKV.If an overwhelming number of requests occurs, throttling your client's requests helps maintain optimal performance and reliability of the AKV service.

Limites de limitação variam de acordo com o cenário.Throttling limits vary based on the scenario. Por exemplo, se você estiver executando um grande volume de gravação, a possibilidade de limitação será maior do que se você estiver apenas executando leituras.For example, if you are performing a large volume of writes, the possibility for throttling is higher than if you are only performing reads.

Como o Key Vault trata os próprios limites?How does Key Vault handle its limits?

Os limites de serviço no Key Vault existem para impedir o uso incorreto de recursos e assegurar a qualidade de serviço para todos os clientes do Key Vault.Service limits in Key Vault are there to prevent misuse of resources and ensure quality of service for all of Key Vault’s clients. Quando um limite de serviço é excedido, o Key Vault limita quaisquer solicitações adicionais desse cliente por um período de tempo.When a service threshold is exceeded, Key Vault limits any further requests from that client for a period of time. Quando isso acontece, o Key Vault retorna o código de status HTTP 429 (Número excessivo de solicitações) e as solicitações falham.When this happens, Key Vault returns HTTP status code 429 (Too many requests), and the requests fail. Além disso, solicitações com falha que retornam um 429 contam para as restrições acompanhadas pelo Key Vault.Also, failed requests that return a 429 count towards the throttle limits tracked by Key Vault.

Se você tiver um caso comercial válido para restrições mais altas, entre em contato conosco.If you have a valid business case for higher throttle limits, please contact us.

Como restringir o seu aplicativo em resposta aos limites de serviçoHow to throttle your app in response to service limits

Veja a seguir as práticas recomendadas que você deve implementar quando o serviço for limitado:The following are best practices you should implement when your service is throttled:

  • Reduza o número de operações por solicitação.Reduce the number of operations per request.
  • Reduza a frequência de solicitações.Reduce the frequency of requests.
  • Evite tentativas imediatas.Avoid immediate retries.
    • Todas as solicitações se acumulam em relação a seus limites de uso.All requests accrue against your usage limits.

Quando você implementa o tratamento de erro do aplicativo, use o código de erro HTTP 429 para detectar a necessidade de limitação do lado do cliente.When you implement your app's error handling, use the HTTP error code 429 to detect the need for client-side throttling. Se a solicitação falha novamente com um código de erro HTTP 429, você ainda está encontrando um limite de serviço do Azure.If the request fails again with an HTTP 429 error code, you are still encountering an Azure service limit. Continue a usar o método de limitação do lado do cliente recomendado, tentando realizar a solicitação novamente até que ela tenha êxito.Continue to use the recommended client-side throttling method, retrying the request until it succeeds.

O código que implementa a retirada exponencial é mostrado abaixo.Code that implements exponential backoff is shown below.

    public sealed class RetryWithExponentialBackoff
    {
        private readonly int maxRetries, delayMilliseconds, maxDelayMilliseconds;

        public RetryWithExponentialBackoff(int maxRetries = 50,
            int delayMilliseconds = 200,
            int maxDelayMilliseconds = 2000)
        {
            this.maxRetries = maxRetries;
            this.delayMilliseconds = delayMilliseconds;
            this.maxDelayMilliseconds = maxDelayMilliseconds;
        }

        public async Task RunAsync(Func<Task> func)
        {
            ExponentialBackoff backoff = new ExponentialBackoff(this.maxRetries,
                this.delayMilliseconds,
                this.maxDelayMilliseconds);
            retry:
            try
            {
                await func();
            }
            catch (Exception ex) when (ex is TimeoutException ||
                ex is System.Net.Http.HttpRequestException)
            {
                Debug.WriteLine("Exception raised is: " +
                    ex.GetType().ToString() +
                    " –Message: " + ex.Message +
                    " -- Inner Message: " +
                    ex.InnerException.Message);
                await backoff.Delay();
                goto retry;
            }
        }
    }

    public struct ExponentialBackoff
    {
        private readonly int m_maxRetries, m_delayMilliseconds, m_maxDelayMilliseconds;
        private int m_retries, m_pow;

        public ExponentialBackoff(int maxRetries, int delayMilliseconds,
            int maxDelayMilliseconds)
        {
            m_maxRetries = maxRetries;
            m_delayMilliseconds = delayMilliseconds;
            m_maxDelayMilliseconds = maxDelayMilliseconds;
            m_retries = 0;
            m_pow = 1;
        }

        public Task Delay()
        {
            if (m_retries == m_maxRetries)
            {
                throw new TimeoutException("Max retry attempts exceeded.");
            }
            ++m_retries;
            if (m_retries < 31)
            {
                m_pow = m_pow << 1; // m_pow = Pow(2, m_retries - 1)
            }
            int delay = Math.Min(m_delayMilliseconds * (m_pow - 1) / 2,
                m_maxDelayMilliseconds);
            return Task.Delay(delay);
        }
    }

O uso desse código em um aplicativo# cliente C é simples.Using this code in a client C# application is straightforward. O exemplo a seguir mostra como fazer isso, usando a classe HttpClient.The following example shows how, using the HttpClient class.

public async Task<Cart> GetCartItems(int page)
{
    _apiClient = new HttpClient();
    //
    // Using HttpClient with Retry and Exponential Backoff
    //
    var retry = new RetryWithExponentialBackoff();
    await retry.RunAsync(async () =>
    {
        // work with HttpClient call
        dataString = await _apiClient.GetStringAsync(catalogUrl);
    });
    return JsonConvert.DeserializeObject<Cart>(dataString);
}

Lembre-se de que esse código é adequado apenas como uma prova de conceito.Remember that this code is suitable only as a proof of concept.

No código de erro HTTP 429, inicie a limitação do cliente usando uma abordagem de retirada exponencial:On HTTP error code 429, begin throttling your client using an exponential backoff approach:

  1. Aguarde 1 segundo, tente solicitar novamenteWait 1 second, retry request
  2. Se ainda estiver limitado, aguarde 2 segundos e tente a solicitação novamenteIf still throttled wait 2 seconds, retry request
  3. Se ainda estiver limitado, aguarde 4 segundos e tente a solicitação novamenteIf still throttled wait 4 seconds, retry request
  4. Se ainda estiver limitado, aguarde 8 segundos e tente a solicitação novamenteIf still throttled wait 8 seconds, retry request
  5. Se ainda estiver limitado, aguarde 16 segundos e tente a solicitação novamenteIf still throttled wait 16 seconds, retry request

Neste ponto, você não deve estar obtendo códigos de resposta HTTP 429.At this point, you should not be getting HTTP 429 response codes.

Consulte tambémSee also

Para obter uma orientação mais profunda de limitação no Microsoft Cloud, consulte Padrão de Limitação.For a deeper orientation of throttling on the Microsoft Cloud, see Throttling Pattern.