Gérer les ressources des applications

App Engine génère des rapports d'utilisation sur les performances et l'utilisation des ressources de l'application. Vous trouverez ci-dessous une liste de stratégies potentielles pour une gestion plus efficace des ressources. Pour en savoir plus, consultez la page des tarifs.

Afficher les rapports d'utilisation

Lors de l'évaluation des performances de l'application, vous devez vérifier le nombre d'instances exécutées par l'application, ainsi que son utilisation des ressources.

Afficher les rapports d'utilisation du tableau de bord

Afficher la page "Instances"

Les sections suivantes proposent des stratégies de gestion des ressources.

Gérer le scaling dynamique d'instances

Réduire la latence

La latence des applications affecte le nombre d'instances requises pour gérer le trafic. En général, vous pouvez réduire le nombre d'instances utilisées pour diffuser l'application. Stackdriver Trace s'avère un outil efficace pour afficher des données sur la latence et comprendre les changements potentiels afin de la réduire.

Après avoir utilisé Stackdriver Trace pour afficher la latence, essayez l'une des stratégies suivantes pour réduire cette latence :

  • Augmentez la mise en cache des données partagées fréquemment utilisées - En d'autres termes, utilisez App Engine Memcache. La définition des en-têtes de contrôle du cache de l'application peut également avoir un impact significatif sur l'efficacité de la mise en cache des données par les serveurs et les navigateurs. Même une mise en cache de quelques secondes peut avoir un impact sur l'efficacité de la diffusion de trafic par l'application. Les applications Python doivent également utiliser la mise en cache au moment de l'exécution.
  • Utilisez App Engine Memcache plus efficacement - Utilisez des appels par lot pour effectuer des opérations d'obtention, de définition, de suppression, etc. au lieu d'une série d'appels individuels. Envisagez d'utiliser l'API Memcache asynchrone.
  • Utilisez des tâches pour une fonctionnalité non liée à une requête - Si l'application effectue une opération qui peut aller au-delà du champ d'application d'une requête d'utilisateur, envoyez l'opération à une tâche. L'envoi de l'opération à la file d'attente de tâches, au lieu d'attendre la fin de l'opération avant de renvoyer une réponse, permet de réduire considérablement la latence des utilisateurs. La file d'attente de tâches permet de mieux contrôler les taux d'exécution et d'alléger la charge.
  • Utilisez Cloud Datastore plus efficacement - Consultez les sections ci-dessous pour plus d'informations.
  • Exécutez plusieurs appels d'API URL Fetch en parallèle :
    • Combinez plusieurs appels d'API URL Fetch, au lieu de les traiter dans des requêtes d'utilisateurs individuelles, et gérez-les en parallèle dans une tâche hors connexion via l'API URL Fetch asynchrone.
    • Utilisez l'API URL Fetch asynchrone.
  • Pour les sessions HTTP, écrivez les requêtes de manière asynchrone.

Modifier les paramètres des performances d'autoscaling

Le fichier de configuration app.yaml contient plusieurs paramètres que vous pouvez utiliser afin d'ajuster le compromis entre performances et charge des ressources pour une version spécifique de l'application. Pour obtenir la liste des paramètres d'autoscaling disponibles, consultez la section Éléments de scaling. Regardez la vidéo sur les nouveaux paramètres du programmeur App Engine pour découvrir leurs effets.

Activer les requêtes simultanées dans Python

Les instances de l'application peuvent diffuser plusieurs requêtes simultanément dans Python. L'activation de ce paramètre permet de réduire le nombre d'instances nécessaires pour diffuser le trafic de l'application. Toutefois, celle-ci doit être "threadsafe" pour que cela fonctionne correctement. Découvrez comment utiliser les requêtes simultanées en activant le paramètre "threadsafe" dans le fichier app.yaml.

Configurer les paramètres de la file d'attente de tâches

Les paramètres par défaut de la file d'attente de tâches sont optimisés pour les performances. Lorsque les valeurs par défaut sont utilisées, l'envoi simultané de plusieurs tâches dans une file d'attente est susceptible d'entraîner le démarrage de nouvelles instances "frontend". Vous trouverez ci-dessous quelques suggestions sur la manière d'ajuster le réglage de la file d'attente de tâches pour préserver les heures d'utilisation de l'instance :

  • Définissez l'en-tête "X-AppEngine-FailFast" sur les tâches non sensibles à la latence. Cet en-tête indique au programmeur de faire échouer la requête immédiatement si une instance existante n'est pas disponible. La file d'attente de tâches relance et met en attente la requête jusqu'à ce qu'une instance existante devienne disponible pour la traiter. Toutefois, il est important de noter que, lorsque les requêtes définies avec l'ensemble "X-AppEngine-FailFast" occupent des instances existantes, les requêtes sans cet en-tête peuvent toujours provoquer le démarrage de nouvelles instances.
  • Configurez les paramètres de la file d'attente de tâches.
    • Si vous définissez le paramètre "rate" sur une valeur inférieure, la file d'attente de tâches exécutera les tâches plus lentement.
    • Si vous définissez le paramètre "max_concurrent_requests" sur une valeur inférieure, moins de tâches seront exécutées simultanément.
  • Utilisez des backends afin de contrôler totalement le nombre d'instances utilisées pour l'exécution de tâches. Vous pouvez utiliser des files d'attente d'envoi avec des backends dynamiques ou des files d'attente de retrait avec des backends résidents.

Diffuser des contenus statiques dans la mesure du possible

La diffusion des contenus statiques dans Python est gérée par une infrastructure App Engine spécialisée qui ne consomme aucune heure d'utilisation de l'instance. Si vous devez définir des en-têtes personnalisés, utilisez l'API Blobstore. La diffusion réelle de la réponse Blob ne consomme aucune heure d'utilisation de l'instance.

Gérer le stockage de l'application

App Engine calcule les coûts de stockage en fonction de la taille des entités dans Cloud Datastore, la taille des index Cloud Datastore, la taille des tâches de la file d'attente et la quantité de données stockées dans Blobstore. Vous trouverez ci-dessous certaines mesures que vous pouvez prendre pour vous assurer de ne pas stocker plus de données que nécessaire :

  • Supprimez toutes les entités ou les blobs dont l'application n'a plus besoin.
  • Supprimez tous les index inutiles, comme indiqué dans la section Gérer l'utilisation de Cloud Datastore ci-dessous, afin de réduire les coûts de stockage des index.

Gérer l'utilisation de Cloud Datastore

App Engine prend en compte le nombre d'opérations effectuées dans Cloud Datastore. Vous trouverez ci-dessous quelques stratégies permettant de réduire l'utilisation des ressources Cloud Datastore, ainsi que de réduire le temps de latence des requêtes adressées à Cloud Datastore :

  • La visionneuse de données de la console GCP affiche le nombre d'opérations d'écriture requises pour créer chaque entité dans l'instance Cloud Datastore locale. Ces informations peuvent vous servir à comprendre le coût de l'écriture de chaque entité. Consultez la section Comprendre les coûts liés à l'écriture pour savoir comment interpréter ces données.
  • Supprimez tous les index inutiles, ce qui réduira les coûts liés au stockage et à l'écriture des entités. Utilisez la fonctionnalité "Obtenir des index" pour voir les index définis dans l'application. Vous pouvez voir les index actuellement actifs dans l'application sur la page de recherche de la console GCP.
  • Lors de la conception du modèle de données, vous pouvez éventuellement écrire les requêtes de manière à éviter complètement les index personnalisés. Consultez la documentation sur les requêtes et les index pour en savoir plus sur la manière dont App Engine génère des index.
  • Dans la mesure du possible, remplacez les propriétés indexées (qui sont les propriétés par défaut) par des propriétés non indexées (Python). Cela permet de réduire le nombre d'opérations d'écriture Cloud Datastore lorsque vous envoyez une entité. Attention : Si, par la suite, vous souhaitez pouvoir interroger la propriété non indexée, vous devrez non seulement modifier le code pour utiliser à nouveau les propriétés indexées, mais également exécuter une tâche de mappage/réduction sur toutes les entités pour les renvoyer.
  • En raison des améliorations apportées au planificateur de requêtes Cloud Datastore dans les versions 1.5.2 et 1.5.3 d'App Engine, les requêtes peuvent désormais nécessiter moins d'index. Même si vous pouvez toujours choisir de conserver certains index personnalisés pour des raisons de performances, vous pouvez peut-être en supprimer d'autres pour réduire les coûts de stockage, ainsi que ceux liés à l'écriture des entités.
  • Reconfigurez le modèle de données de sorte que vous puissiez remplacer les requêtes par une récupération par clé, ce qui est plus économique et plus efficace.
  • Utilisez des requêtes ne contenant que des clés plutôt que des requêtes d'entité dans la mesure du possible.
  • Pour diminuer la latence, remplacez plusieurs entités get() par un traitement par lot get().
  • Utilisez les curseurs Cloud Datastore pour la pagination plutôt que le décalage.
  • Mettez en parallèle plusieurs RPC Cloud Datastore via l'API Async Datastore.

Remarque : Les opérations mineures dans Cloud Datastore incluent les appels relatifs à l'attribution d'ID Cloud Datastore ou les requêtes qui ne contiennent que des clés. Consultez la page des tarifs pour en savoir plus.

Gérer la bande passante

Dans la mesure du possible, définissez l'en-tête Cache-Control approprié pour les réponses et définissez des délais d'expiration raisonnables pour les fichiers statiques, afin de réduire l'utilisation de la bande passante sortante. Cette utilisation des en-têtes Cache-Control publics permet aux serveurs proxy et au navigateur des clients de mettre en cache les réponses pour la période spécifiée.

La bande passante entrante est plus difficile à contrôler, car il s'agit de la quantité de données envoyées par les utilisateurs à l'application. Cependant, c'est une bonne occasion de mentionner le service de protection DoS, qui permet de bloquer le trafic des adresses IP que vous considérez comme abusives.

Gérer d'autres ressources

L'une des meilleures stratégies pour vérifier l'utilisation de l'API de messagerie consiste à utiliser Appstats pour vous assurer que vous ne passez pas plus d'appels que nécessaire. Nous vous recommandons de vérifier les taux d'erreur et de rechercher les éventuels appels non valides. Dans certains cas, il peut être possible d'identifier ces appels de manière anticipée.

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Environnement standard App Engine pour Python