Limites de la mise à l'échelle

Vous pouvez configurer les limites de mise à l'échelle en définissant une plage de valeurs pour le nombre minimum et maximum d'instances, à l'intérieur de laquelle Code Engine ajuste automatiquement le nombre d'instances de votre application en cours d'exécution. Configurez cette plage lorsque vous créez ou mettez à jour des applications.

• Nombre minimal d'instances-Nombre minimal d'instances de l'application qui sont toujours en cours d'exécution, même si aucune demande n'est traitée. Si la valeur est 0 (par défaut), Code Engine supprime toutes les instances quand aucun trafic n'atteint l'application. Pour toujours conserver une instance en cours d'exécution de votre application, définissez cette valeur sur une valeur supérieure à 0. Lorsque vous créez ou mettez à jour une application avec Code Engine à partir de la console, définissez la valeur minimale du nombre d'instances dans la section Mise à l'échelle automatique de l'onglet Ressources et mise à l'échelle. Dans l'interface de ligne de commande (CLI), spécifiez l'option « --min-scale » sur la commande app create et app update.

• Nombre maximal d'instances-Nombre maximal d'instances pouvant être exécutées pour l'application. La mise à l'échelle automatique s'effectue jusqu'à cette limite. Si vous définissez cette valeur sur « 0 », l'application s'adapte automatiquement aux besoins, et la mise à l'échelle de l'application n'est limitée que par le nombre d'instances autorisé par le quota de ressources attribué au projet de votre application. Voir Limites et quotas pour Code Engine. Lorsque vous créez ou mettez à jour une application avec Code Engine à partir de la console, définissez la valeur du nombre maximal d'instances dans la section Mise à l'échelle automatique de l'onglet Ressources et mise à l'échelle. Dans l'interface de ligne de commande (CLI), spécifiez l'option « --max-scale » sur la commande app create et app update. La valeur par défaut de cette option est « 10 ».

Lorsque vous connectez vos applications à des producteurs d'événements, pensez à tenir compte de la fréquence et du volume des événements de ces producteurs lorsque vous définissez vos limites d'échelle. Par exemple, si vous prévoyez de recevoir de nombreux événements simultanément et que le traitement de chaque événement peut prendre plusieurs minutes, vous aurez peut-être besoin d'une valeur maximale d'évolutivité plus élevée que si chaque événement pouvait être traité rapidement. Une valeur trop basse peut retarder la réception des événements ou même entraîner leur suppression en raison des délais d'attente de libération des ressources de traitement.

Paramètres de mise à l'échelle automatique pour la simultanéité et la temporisation

Utilisez les paramètres de configuration suivants pour contrôler la mise à l'échelle de l'application.

• Concurrence - Cette valeur indique le nombre de requêtes que chaque instance de votre application peut traiter simultanément. Par exemple, une valeur de 100 signifie que votre code peut traiter 100 requêtes simultanées. Cette valeur est une "limite absolue", ce qui signifie que Code Engine ne permet pas que des demandes dépassant ce nombre (spécifié avec le paramètre d'accès concurrents) atteignent une instance de votre application. Par conséquent, si votre code est mono-thread et ne peut traiter qu'une seule requête à la fois, pensez à définir le paramètre de concurrence sur « 1 ». Lorsque le nombre spécifié de requêtes est envoyé à toutes les instances en cours d'exécution de votre application, Code Engine augmente alors le nombre d'instances afin de se préparer à un afflux de requêtes. Lorsque vous créez ou mettez à jour une application avec Code Engine à partir de la console, définissez la valeur d'accès concurrent maximale dans la section Mise à l'échelle automatique de l'onglet Ressources & mise à l'échelle. Avec l'interface de ligne de commande, spécifiez l'option --concurrency dans les commandes app create et app update.

• Concurrence cible - Cette valeur fait office de « limite souple » ou de nombre de requêtes par instance que vous souhaitez voir traitées dans un système en charge. Par exemple, si vous définissez concurrency comme 100 et target concurrency comme 70, alors Code Engine tente de limiter le nombre de requêtes par instance à 70.Le fait de définir cette option ne garantit pas que le nombre de requêtes par instance ne dépassera pas 70, car cela risque fort de se produire en cas d'augmentation du trafic. Cependant, la marge située entre 70 et 100 permet au système de créer de nouvelles instances pour ramener la charge par instance à 70 (ou au-dessous). Si target concurrency n'est pas spécifié, la valeur par défaut est celle de concurrency. Lorsque vous créez ou mettez à jour une application à l'aide de l' Code Engine depuis la console, définissez la valeur cible de concurrence dans la section « Autoscaling » de l'onglet « Resources & scaling ». Dans l'interface de ligne de commande (CLI), spécifiez l'option « --concurrency-target » sur la commande app create et app update.

• Délai d'attente de la demande-Délai, en secondes, pendant lequel l'application doit répondre aux demandes, faute de quoi elles échouent. Lorsque vous créez ou mettez à jour une application avec Code Engine à partir de la console, définissez la valeur de délai d'attente de la demande dans la section Mise à l'échelle automatique de l'onglet Ressources et mise à l'échelle. Dans l'interface de ligne de commande (CLI), spécifiez l'option « --request-timeout » sur la commande app create et app update.

• Délai de réduction d'échelle - Durée, exprimée en secondes, qui doit s'écouler à un niveau de concurrence réduit avant que l'application ne passe à une échelle inférieure. Si vous connaissez le modèle des demandes entrantes dans votre application, vous pouvez choisir de spécifier une valeur supérieure à la valeur par défaut de 0 pour retarder la réduction de votre application. Si vous utilisez une valeur élevée pour cette option, le nombre moyen d'instances d'application s'exécutant simultanément peut augmenter, ce qui entraîne des coûts supplémentaires. Même avec le paramètre de délai de mise à l'échelle par réduction de la valeur 0, le système attend un court laps de temps avant que l'application ne réduise le nombre d'instances pour s'assurer qu'une baisse de l'accès concurrent aux demandes est suffisamment stable pour justifier une mise à l'échelle par réduction. Lorsque vous créez ou mettez à jour une application avec Code Engine à partir de la console, définissez la valeur de délai de mise à l'échelle dans la section Mise à l'échelle automatique de l'onglet Ressources et mise à l'échelle. Dans l'interface de ligne de commande (CLI), spécifiez l'option « --scale-down-delay » sur la commande app create et app update.

Par exemple, si la valeur du nombre maximal d'instances est définie sur 10 et que l'accès concurrent est défini sur 100, une application peut traiter 1000 demandes simultanées avant que la mise en file d'attente potentielle des demandes ne se produise. Si vous prévoyez plus de 1000 demandes simultanément, vous pouvez envisager d'augmenter la valeur du nombre maximal d'instances pour votre application.

Pour plus d'informations sur le fonctionnement de Code Engine, consultez Réglage du délai de réduction IBM Cloud Code Engine pour réduire les temps de réponse des applications.

Si vous définissez le nombre minimal d'instances égal au nombre maximal d'instances, la mise à l'échelle n'a pas lieu et les valeurs de délai de mise à l'échelle par réduction et de devise cible ne s'appliquent pas. Cependant, la valeur d'accès concurrent est toujours en vigueur.

Exemple de scénario de mise à l'échelle automatique

Supposons que vous disposiez d'une application configurée avec les paramètres de mise à l'échelle automatique suivants.

• Nombre minimal d'instances = 4
• Nombre maximal d'instances = 20
• Accès concurrent = 2

Avec ces paramètres, votre application peut traiter 2 demandes simultanées en même temps. Lorsqu'il n'y a pas de trafic, votre application est automatiquement mise à l'échelle jusqu'à 4 instances. Les 4 instances ne peuvent traiter que 4 * 2 (devise) = 8 demandes. L'application peut évoluer jusqu'à un maximum de 20 instances, de sorte que les 20 instances puissent traiter 20 * 2 (devise) = 40 demandes, en supposant des paramètres d'UC et de mémoire suffisants pour l'application.

Supposons que votre application soit une application Web statique qui nécessite 6 appels à votre application pour charger une page de connexion. Supposons que 10 personnes se connectent à votre page de connexion d'application en même temps (10 * 6 = 60 appels). Etant donné que 60 appels sont supérieurs à 40 demandes pouvant être traitées par votre application, les utilisateurs de l'application sont susceptibles d'observer une lenteur lors de la mise en file d'attente des appels.

Après une minute d'absence de trafic sur votre application, Code Engine commence à diminuer automatiquement. Lorsque votre application est mise à l'échelle vers le bas, certaines instances sont définies avec le statut Terminating. Code Engine envoie un signal SIGTERM à votre application et votre code doit traiter ce signal et s'arrêter. Si votre application ne gère pas ce signal, vos instances d'application restent à l'état Terminating pendant la durée configurée par la valeur de délai d'attente de la demande (la valeur par défaut est de 300 secondes). Après le délai d'attente de la demande, Code Engine envoie un signal SIGKILL pour forcer l'arrêt des instances d'application à l'état Terminating.

Si vous disposez de 8 instances actives et que 12 instances restent à l'état Terminating pendant 300 secondes (5 minutes). Ces 12 instances ne reçoivent aucune demande. Si plus de 8 * 2 (devise) = 16 demandes arrivent, Code Engine augmente les nouvelles instances.

Dans cet exemple, la valeur d'accès concurrent de 2 est faible pour ce contenu statique. Vous devez déterminer les valeurs de mise à l'échelle automatique à définir pour votre application, qui dépendent de ce que l'implémentation de votre application peut gérer avec les ressources d'UC et de mémoire qui lui sont affectées.

Détermination des accès concurrents de votre conteneur d'applications

La valeur optimale des accès concurrents de conteneur est déterminée par le nombre maximal de demandes simultanées que l'application peut traiter avec un temps d'attente de demande acceptable.

Les accès concurrents de conteneur ont un impact direct sur le taux de réussite, le temps d'attente et le débit de l'application. Lorsque la valeur de concurrence du conteneur est trop élevée pour que l'application puisse la gérer, la latence et le débit s'en trouvent affectés négativement, et vous pouvez observer des réponses d'erreur de type « 502 » et « 503 ».

Lorsque la valeur des accès concurrents de conteneur est trop faible pour l'application, le système met à l'échelle l'application plus rapidement et répartit la demande sur de nombreuses instances d'application, ce qui entraîne des coûts et un temps d'attente supplémentaires. Lors d'une rafale de charge, une faible valeur d'accès concurrents peut également conduire à des réponses 502 temporaires lorsque les mémoires tampon internes du système s'exécutent.

Pour déterminer la configuration des accès concurrents de conteneur pour votre application, examinez les demandes et le temps d'attente.

1. Créez une application et définissez son accès concurrent à 1000 (maximum) et aussi bien min-scale etmax-scale jusqu'à1.

   ibmcloud ce application create --name APPNAME --image APPIMAGE --min-scale=1 --max-scale=1 --concurrency=1000
   

2. Commencez par envoyer un taux élevé de demandes. Si des erreurs 502 se produisent, diminuez le taux jusqu'à ce que le résultat affiche 100 % de réussite.

3. Recherchez le temps d'attente de la demande de la sortie de l'étape 2. Si le temps d'attente de la demande n'est pas acceptable, réduisez encore le taux de demande jusqu'à ce que le temps d'attente de la demande soit acceptable. Notez que la durée de la demande est également importante car elle fait une différence si le calcul de la demande prend 2 secondes ou 100 millisecondes.

   Le taux de demande et le temps d'attente acceptables varient en fonction des caractéristiques de votre application et de votre configuration de mise à l'échelle. Par exemple, si le calcul dans votre application prend environ 100 ms et que votre paramètre d'accès concurrents est défini sur 10, une instance d'application peut traiter environ 100 demandes par seconde avec un temps d'attente d'environ 100 ms (en ignorant le temps d'attente du réseau).

4. Pour calculer la valeur d'accès concurrents de conteneur de votre application, prenez le taux de l'étape 2 (en req/s) et divisez-le par le temps d'attente de l'étape 3 (en secondes) : CC = RATE/LATENCY. Par exemple, si le taux est de 80 demandes par seconde, et que le temps d'attente est de 2 secondes, le résultat d'accès concurrents obtenu est = 80 req/s / 2 s = 40.

5. Mettez à jour l'application pour définir les accès concurrents de conteneur sur la valeur trouvée à l'étape précédente et réexécutez la charge de travail pour vérifier si le taux de réussite et le temps d'attente sont acceptables.

6. Expérimentez avec l'application en augmentant la valeur des accès concurrents de conteneur et en observant le taux de réussite et le temps d'attente.

7. Mettez à jour votre application avec la valeur d'accès concurrent du conteneur optimal et supprimez les limites min-Scale et max-scale pour permettre à l'application de se mettre à l'échelle automatiquement.

Modification de la plage de mise à l'échelle automatique à partir de la console

Pour modifier la plage dans laquelle Code Engine effectue la mise à l'échelle automatique du nombre d'instances en cours d'exécution pour une application à partir de la console, procédez comme suit.

1. Accédez à votre application.
2. Sélectionnez l'onglet « Configuration ».
3. Sélectionnez l'onglet « Ressources et évolutivité ».
4. Définissez le nombre d'instances minimum et maximum pour votre application.
5. (Facultatif) Passez en revue et définissez les paramètres de simultanéité et de simultanéité des demandes pour la mise à l'échelle automatique de votre application.
6. Cliquez sur « Déployer » pour enregistrer vos modifications et déployer la nouvelle version de l'application.

Lorsque vous mettez à jour votre application, celle-ci crée une nouvelle révision et achemine le trafic vers cette instance.

Modification de la plage de mise à l'échelle automatique avec l'interface de ligne de commande

Pour modifier la plage dans laquelle Code Engine valide automatiquement le nombre d'instances en cours d'exécution pour une application à l'aide de l'interface de ligne de commande, exécutez la commande application update avec les options --min-scale et --max-scale définies sur le nombre d'instances souhaité pour votre application. Vous pouvez éventuellement définir des paramètres de simultanéité et de simultanéité des demandes pour votre application. Ces options incluent --concurrency, --concurrency-target, --request-timeout et --scale-down-delay. Pour plus d'informations sur la définition de ces valeurs de mise à l'échelle automatique, voir Mise à l'échelle des limites et Paramètres de mise à l'échelle automatique pour les accès simultanés et la temporisation.

Lorsque vous mettez à jour votre application, celle-ci crée une nouvelle révision et achemine le trafic vers cette instance.