Aide sur la limitation de requêtes Azure Key VaultAzure Key Vault throttling guidance

La limitation de requêtes est le processus permettant de réduire le nombre d’appels simultanés au service Azure afin d’empêcher toute surexploitation des ressources.Throttling is a process you initiate that limits the number of concurrent calls to the Azure service to prevent overuse of resources. Azure Key Vault (AKV) est conçu pour gérer un volume élevé de requêtes.Azure Key Vault (AKV) is designed to handle a high volume of requests. En cas d’affluence, la limitation des requêtes du client permet de maintenir des performances et une fiabilité optimales pour le service AKV.If an overwhelming number of requests occurs, throttling your client's requests helps maintain optimal performance and reliability of the AKV service.

Les limites varient selon les scénarios.Throttling limits vary based on the scenario. Par exemple, si vous réalisez un volume important d’écritures, la possibilité de limitation est plus élevée que si vous effectuez uniquement des lectures.For example, if you are performing a large volume of writes, the possibility for throttling is higher than if you are only performing reads.

Comment Key Vault gère-t-il ses limites ?How does Key Vault handle its limits?

Les limites de service de Key Vault sont là pour empêcher tout usage abusif des ressources et garantir la qualité du service pour tous les clients de 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. En cas de dépassement d’un seuil de service, Key Vault limite toutes les autres requêtes de ce client sur une période donnée.When a service threshold is exceeded, Key Vault limits any further requests from that client for a period of time. Dans ce cas, Key Vault retourne le code d’état HTTP 429 (Trop de requêtes), et les requêtes échouent.When this happens, Key Vault returns HTTP status code 429 (Too many requests), and the requests fail. Par ailleurs, les requêtes qui ont échoué et retournent une erreur 429 sont comptabilisées dans les limites suivies par Key Vault.Also, failed requests that return a 429 count towards the throttle limits tracked by Key Vault.

Si vous avez un scénario valide justifiant une limitation supérieure, contactez-nous.If you have a valid business case for higher throttle limits, please contact us.

Guide pratique pour limiter une application en réponse à des limites de serviceHow to throttle your app in response to service limits

Les éléments suivants sont meilleures pratiques vous devez implémenter lorsque votre service est limité :The following are best practices you should implement when your service is throttled:

  • Réduisez le nombre d’opérations par requête.Reduce the number of operations per request.
  • Réduisez la fréquence des requêtes.Reduce the frequency of requests.
  • Évitez les nouvelles tentatives immédiates.Avoid immediate retries.
    • Toutes les requêtes sont comptabilisées dans le cadre de vos limites d’utilisation.All requests accrue against your usage limits.

Lorsque vous implémentez la gestion des erreurs de votre application, utilisez le code d’erreur HTTP 429 pour détecter si une limitation côté client est nécessaire.When you implement your app's error handling, use the HTTP error code 429 to detect the need for client-side throttling. Si la requête échoue à nouveau avec un code d’erreur HTTP 429, cela signifie que vous rencontrez toujours une limite de service Azure.If the request fails again with an HTTP 429 error code, you are still encountering an Azure service limit. Continuez à utiliser la méthode de limitation côté client recommandée, en réessayant la requête jusqu’à ce qu’elle aboutisse.Continue to use the recommended client-side throttling method, retrying the request until it succeeds.

Le code qui implémente un backoff exponentiel est montré ci-dessous.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);
        }
    }

À l’aide de ce code dans un client C# application est simple.Using this code in a client C# application is straightforward. L’exemple suivant montre comment procéder en utilisant la 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);
}

N’oubliez pas que ce code ne convient que comme preuve de concept.Remember that this code is suitable only as a proof of concept.

En cas de code d’erreur HTTP 429, commencez à limiter votre client suivant une approche d’interruption exponentielle :On HTTP error code 429, begin throttling your client using an exponential backoff approach:

  1. Patientez une seconde, relancez la requête ;Wait 1 second, retry request
  2. Si la limitation persiste, patientez deux secondes, relancez la requête ;If still throttled wait 2 seconds, retry request
  3. Si la limitation persiste, patientez quatre secondes, relancez la requête ;If still throttled wait 4 seconds, retry request
  4. Si la limitation persiste, patientez huit secondes, relancez la requête ;If still throttled wait 8 seconds, retry request
  5. Si la limitation persiste, patientez seize secondes, relancez la requête.If still throttled wait 16 seconds, retry request

À ce stade, vous ne devriez pas recevoir de code de réponse HTTP 429.At this point, you should not be getting HTTP 429 response codes.

Voir aussiSee also

Pour orienter la limitation de façon plus approfondie sur Microsoft Cloud, consultez la page Modèle de limitation.For a deeper orientation of throttling on the Microsoft Cloud, see Throttling Pattern.