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
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. Cloud Trace s'avère un outil efficace pour afficher des données sur la latence et comprendre les modifications qui permettraient de la réduire.
Après avoir affiché la latence à l'aide de Cloud Trace, essayez certaines des stratégies suivantes afin de la réduire :
- 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 Firestore en mode Datastore (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 de 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 Task Queue
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.
- 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.
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 instance-heure.
Gérer le stockage de l'application
App Engine calcule les coûts de stockage en fonction de la taille des entités dans Datastore, de la taille des index Datastore, de la taille des tâches dans la file d'attente et de la quantité de données stockées dans le 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 Datastore
App Engine tient compte du nombre d'opérations effectuées dans Datastore. Voici quelques stratégies pouvant contribuer à réduire la consommation de ressources Datastore, ainsi que la latence pour les requêtes envoyées à Datastore :
- La visionneuse de données de la console Google Cloud affiche le nombre d'opérations d'écriture nécessaires pour créer chaque entité dans votre datastore local. 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 quels index sont actuellement diffusés pour votre application sur la page de recherche de la console Google Cloud.
- 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 (ce qui est le cas par défaut) par des propriétés non indexées (Python), ce qui réduit le nombre d'opérations d'écriture Datastore lorsque vous placez 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 Datastore dans App Engine 1.5.2 et 1.5.3, vos requêtes peuvent désormais nécessiter moins d'index qu'auparavant. 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 votre 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 lotget(). - Utilisez les curseurs Datastore pour la pagination plutôt que le décalage.
- Mettez en parallèle plusieurs RPC Datastore via l'API Async Datastore.
Remarque : Les opérations Datastore mineures incluent les appels attribuant des ID 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
Pour réduire la bande passante sortante, vous pouvez définir l'en-tête Cache-Control approprié pour vos réponses et définir des délais d'expiration raisonnables pour les fichiers statiques. 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, vous pouvez utiliser les règles de pare-feu App Engine pour autoriser ou limiter les plages d'adresses IP et de sous-réseaux.