Mode de traitement des requêtes

ID de la région

Le REGION_ID est un code abrégé que Google attribue en fonction de la région que vous sélectionnez lors de la création de votre application. Le code ne correspond pas à un pays ou une province, même si certains ID de région peuvent ressembler aux codes de pays et de province couramment utilisés. Pour les applications créées après février 2020, REGION_ID.r est inclus dans les URL App Engine. Pour les applications existantes créées avant cette date, l'ID de région est facultatif dans l'URL.

En savoir plus sur les ID de région

OK

Ce document décrit comment votre application App Engine reçoit des requêtes et envoie des réponses.

Pour en savoir plus, consultez la documentation de référence sur les en-têtes de requêtes et les réponses.

Si votre application utilise des services, vous pouvez adresser des requêtes à un service spécifique ou à une version particulière de ce service. Pour en savoir plus sur l'adressage des services, consultez la page Mode de routage des requêtes.

Traiter des requêtes

Votre application est responsable du démarrage d'un serveur Web et du traitement des requêtes. Vous pouvez utiliser n'importe quel framework Web disponible pour votre langage de développement.

App Engine exécute plusieurs instances de votre application, chacune d'elles disposant de son propre serveur Web pour le traitement des requêtes. Étant donné que chaque requête peut être acheminée vers n'importe quelle instance, les requêtes consécutives provenant d'un même utilisateur ne sont pas nécessairement envoyées à la même instance. Une instance peut traiter plusieurs requêtes simultanément. Le nombre d'instances peut être ajusté automatiquement en fonction de l'évolution du trafic. Vous pouvez également modifier le nombre de requêtes simultanées qu'une instance peut traiter en définissant l'élément max_concurrent_requests dans votre fichier app.yaml.

L'environnement d'exécution Go pour App Engine utilise le package http standard en tant qu'interface entre le programme Go et les serveurs App Engine. Lorsqu'App Engine reçoit une requête Web pour votre application, il appelle le gestionnaire http.Handler associé à l'URL de la requête.

L'exemple ci-dessous correspond à une application Go complète qui renvoie à l'utilisateur une chaîne HTML codée en dur :

// Sample helloworld is an App Engine app.
package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)


func main() {
	http.HandleFunc("/", indexHandler)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
		log.Printf("Defaulting to port %s", port)
	}

	log.Printf("Listening on port %s", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}



// indexHandler responds to requests with our greeting.
func indexHandler(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/" {
		http.NotFound(w, r)
		return
	}
	fmt.Fprint(w, "Hello, World!")
}

Quotas et limites

App Engine alloue automatiquement des ressources à votre application lorsque le trafic augmente. Toutefois, les restrictions suivantes s'appliquent :

• App Engine réserve une capacité de scaling automatique pour les applications à faible latence, qui répondent aux requêtes en moins d'une seconde.

• En outre, le temps de latence des applications fortement dépendantes des processeurs peut augmenter de manière à permettre le partage efficace des ressources avec les autres applications hébergées sur les mêmes serveurs. Aucune limite de latence n'est appliquée aux requêtes de fichiers statiques.

Chaque requête entrante vers l'application est prise en compte dans la limite des requêtes. Les données envoyées en réponse à une requête sont comptabilisées dans la limite de bande passante sortante (facturable).

Les requêtes HTTP et HTTPS (sécurisées) sont comptabilisées dans les limites de requêtes, de bande passante entrante (facturable) et de bande passante sortante (facturable). Dans la console Google Cloud, la page Détails des quotas affiche également les valeurs de Requêtes sécurisées, la Bande passante entrante sécurisée et la Bande passante sortante sécurisée de manière distincte à titre informatif. Seules les requêtes HTTPS sont comptabilisées dans ces valeurs. Pour en savoir plus, consultez la page Quotas.

Les limites ci-dessous s'appliquent spécifiquement à l'utilisation de gestionnaires de requêtes :

Limite	Montant
Taille d'une requête	32 Mo
Taille d'une réponse	32 Mo
Délai avant expiration de la requête	Dépend du type de scaling utilisé par votre application
Nombre total de fichiers, au maximum (fichiers d'application et fichiers statiques)	10 000 au total, 1 000 par répertoire
Taille maximale d'un fichier d'application	32 Mo
Taille maximale d'un fichier statique	32 Mo
Taille maximale du total des fichiers d'application et des fichiers statiques	Le premier gigaoctet est gratuit Le tarif est ensuite de 0,026 $ par gigaoctet et par mois
Délai avant expiration de la requête en attente	10 secondes
Taille maximale d'un seul champ d'en-tête de requête	8 kilo-octets pour les environnements d'exécution de deuxième génération dans l'environnement standard. Les requêtes adressées à ces environnements d'exécution avec des champs d'en-tête dépassant 8 kilo-octets renvoient des erreurs HTTP 400.

Limites de requêtes

Toutes les requêtes HTTP/2 sont converties en requêtes HTTP/1.1 lors de leur transmission au serveur d'applications.

Limites de réponse

• Les réponses dynamiques sont limitées à 32 Mo. Si un gestionnaire de scripts génère une réponse supérieure à cette limite, le serveur renvoie une réponse vide avec un code d'état 500 indiquant une erreur interne du serveur. Cette limite ne s'applique pas aux réponses qui diffusent des données provenant de l'ancien service Blobstore ou de Cloud Storage.

• La limite d'en-tête de réponse est de 8 ko pour les environnements d'exécution de deuxième génération. Les en-têtes de réponse qui dépassent cette limite renvoient des erreurs HTTP 502, avec des journaux affichant upstream sent too big header while reading response header from upstream.

En-têtes de requête

Une requête HTTP entrante inclut des en-têtes HTTP envoyés par le client. Pour des raisons de sécurité, certains en-têtes sont nettoyés ou modifiés par des serveurs proxy intermédiaires avant d'atteindre l'application.

Pour en savoir plus, consultez la documentation de référence sur les en-têtes de requête.

Gérer les délais d'expiration des requêtes

App Engine est optimisé pour les applications dont les requêtes sont de courte durée (quelques centaines de millisecondes en général). Pour être efficace, une application doit répondre rapidement à la majorité des requêtes. Si ce n'est pas le cas, elle n'est pas adaptée à l'infrastructure App Engine. Pour garantir ce niveau de performances, le système impose un délai d'expiration de la requête maximal pour chaque application.

Si votre application dépasse ce délai, App Engine interrompt le gestionnaire de requêtes. Pour les gestionnaires de requêtes Go, le processus est arrêté et l'environnement d'exécution renvoie au client un message d'erreur interne de serveur HTTP 500.

Réponses

App Engine appelle le gestionnaire avec les objets Request et ResponseWriter, puis attend que le gestionnaire écrive dans ResponseWriter et renvoie un résultat. Lorsque le gestionnaire répond, les données du tampon interne de ResponseWriter sont envoyées à l'utilisateur.

Ce processus est pratiquement identique à celui mis en œuvre lorsque vous écrivez des programmes Go normaux qui utilisent le package http.

Certaines limites de taille s'appliquent à la réponse que vous générez et celle-ci peut être modifiée avant d'être renvoyée au client.

Pour en savoir plus, consultez la documentation de référence sur les réponses aux requêtes.

Réponses en flux continu

App Engine n'accepte pas les réponses en flux continu dans lesquelles les données sont envoyées au client par blocs incrémentiels pendant le traitement d'une requête. Toutes les données de votre code sont collectées comme indiqué ci-dessus et envoyées sous la forme d'une réponse HTTP unique.

Compression de la réponse

Pour les réponses renvoyées par votre code, App Engine compresse les données dans la réponse si les deux conditions suivantes sont remplies :

• La requête contient l'en-tête Accept-Encoding qui inclut gzip comme valeur.
• La réponse contient des données textuelles telles que HTML, CSS ou JavaScript.

Pour les réponses renvoyées par un gestionnaire de répertoires ou de fichiers statiques App Engine, les données de réponse sont compressées si toutes les conditions suivantes sont remplies :

• La requête inclut l'en-tête Accept-Encoding, dont une des valeurs est gzip.
• Le client peut recevoir les données de réponse dans un format compressé. L'interface Google gère une liste de clients qui sont connus pour avoir des problèmes liés aux réponses compressées. Ces clients ne recevront pas les données compressées provenant de gestionnaires statiques de votre application, même si les en-têtes de requête contiennent Accept-Encoding: gzip.
• La réponse contient des données textuelles telles que HTML, CSS ou JavaScript.

Veuillez noter les points suivants :

• Un client peut forcer la compression des types de contenu textuel en définissant à la fois les en-têtes de requête Accept-Encoding et User-Agent sur gzip.

• Si une requête ne spécifie pas gzip dans l'en-tête Accept-Encoding, App Engine ne compresse pas les données de réponse.

• L'interface Google met en cache les réponses des gestionnaires de répertoires et de fichiers statiques App Engine. En fonction de divers facteurs, tels que le type des données de réponse mises en cache en premier, les en-têtes Vary que vous avez spécifiés dans la réponse ou les en-têtes inclus dans la requête, un client peut avoir demandé des données compressées, mais recevoir des données non compressées, et inversement. Pour en savoir plus, consultez la section Mettre en cache les réponses.

Mettre en cache les réponses

L'interface Google et éventuellement le navigateur de l'utilisateur ainsi que d'autres serveurs proxy de mise en cache intermédiaires mettent en cache les réponses de votre application, comme indiqué par les en-têtes de mise en cache standards que vous spécifiez dans la réponse. Vous pouvez spécifier ces en-têtes de réponse soit via votre framework, directement dans votre code, soit via les gestionnaires de répertoires et de fichiers statiques d'App Engine.

Dans l'interface Google, la clé du cache correspond à l'URL complète de la requête.

Mettre en cache du contenu statique

Pour vous assurer que les clients reçoivent toujours le contenu statique mis à jour dès sa publication, nous vous recommandons de diffuser le contenu statique à partir de répertoires avec versions gérées, tels que css/v1/styles.css. L'interface Google ne valide pas le cache (vous devez rechercher le contenu mis à jour) avant l'expiration du cache. Même après son expiration, le cache n'est pas mis à jour tant que le contenu de l'URL de la requête n'a pas été modifié.

Les en-têtes de réponse suivants, que vous pouvez définir dans app.yaml, modifient le moment et la méthode de mise en cache du contenu par l'interface Google :

• Cache-Control doit être défini sur public pour que l'interface Google mette en cache le contenu. Il peut également être mis en cache par l'interface Google, sauf si vous spécifiez une instruction Cache-Control private ou no-store. Si vous ne définissez pas cet en-tête dans app.yaml, App Engine l'ajoute automatiquement pour toutes les réponses traitées par un gestionnaire de répertoires ou de fichiers statiques. Pour en savoir plus, consultez la section En-têtes ajoutés ou remplacés.

• Vary : pour permettre au cache de renvoyer différentes réponses pour une URL en fonction des en-têtes envoyés dans la requête, définissez une ou plusieurs des valeurs suivantes dans l'en-tête de réponse Vary : Accept, Accept-Encoding, Origin, ou X-Origin.

  En raison du potentiel de cardinalité élevée, les données ne seront pas mises en cache pour d'autres valeurs Vary.

  Exemple :

  1. Vous spécifiez l'en-tête de réponse suivant :

     Vary: Accept-Encoding

  2. Votre application reçoit une requête contenant l'en-tête Accept-Encoding: gzip. App Engine renvoie une réponse compressée, et l'interface Google met en cache la version des données de réponse compressée avec gzip. Toutes les requêtes ultérieures pour cette URL contenant l'en-tête Accept-Encoding: gzip recevront les données du cache compressées avec gzip jusqu'à l'invalidation de celui-ci (en raison du changement de contenu après l'expiration du cache).

  3. Votre application reçoit une requête qui ne contient pas l'en-tête Accept-Encoding. App Engine renvoie une réponse non compressée, et l'interface Google met en cache la version non compressée des données de réponse. Toutes les requêtes ultérieures pour cette URL ne contenant pas l'en-tête Accept-Encoding recevront les données compressées du cache jusqu'à ce que le cache soit invalidé.

  Si vous ne spécifiez pas d'en-tête de réponse Vary, l'interface Google crée une seule entrée de cache pour l'URL et l'utilise pour toutes les requêtes, quels que soient les en-têtes de la requête. Exemple :

  1. Vous ne spécifiez pas l'en-tête de réponse Vary: Accept-Encoding.
  2. Une requête contient l'en-tête Accept-Encoding: gzip, et la version compressée avec gzip des données de réponse est mise en cache.
  3. Une deuxième requête ne contient pas l'en-tête Accept-Encoding: gzip. Toutefois, comme le cache contient une version compressée avec gzip des données de réponse, la réponse sera compressée avec gzip même si le client a demandé des données non compressées.

Les en-têtes de la requête influent également sur la mise en cache :

• Si la requête contient un en-tête Authorization, le contenu ne sera pas mis en cache par l'interface Google.

Expiration du cache

Par défaut, les en-têtes de mise en cache que les gestionnaires de répertoires et de fichiers statiques App Engine ajoutent aux réponses indiquent aux clients et aux proxys Web, tels que l'interface Google, que le cache doit expirer au bout de 10 minutes.

Une fois un fichier transmis avec un délai d'expiration donné, il n'existe généralement aucun moyen de le supprimer des caches intermédiaires, même si l'utilisateur efface le cache de son propre navigateur. Le fait de déployer une nouvelle version de l'application ne permet pas de réinitialiser les caches. Par conséquent, si vous avez l'intention de modifier un fichier statique, il doit posséder un délai d'expiration court (moins d'une heure). Le délai d'expiration par défaut de 10 minutes convient dans la plupart des cas.

Vous pouvez modifier le délai d'expiration par défaut pour tous les gestionnaires de répertoires et de fichiers statiques en spécifiant l'élément default_expiration dans votre fichier app.yaml. Pour définir des délais d'expiration spécifiques pour des gestionnaires particuliers, spécifiez l'élément expiration dans l'élément de gestionnaire de votre fichier app.yaml.

La valeur spécifiée dans le délai d'expiration des éléments sera utilisée pour définir les en-têtes de réponse HTTP Cache-Control et Expires.

Forcer les connexions HTTPS

Pour des raisons de sécurité, toutes les applications doivent encourager les clients à se connecter via le protocole https. Pour indiquer au navigateur de privilégier https à http pour une page ou un domaine donné, définissez l'en-tête Strict-Transport-Security dans vos réponses. Exemple :

Strict-Transport-Security: max-age=31536000; includeSubDomains

Pour définir cet en-tête pour tout contenu statique diffusé par votre application, ajoutez-le aux gestionnaires de répertoires et de fichiers statiques de votre application.

Pour définir cet en-tête pour les réponses générées à partir de votre code, utilisez le package secureheader.

Attention : Les clients ayant reçu cet en-tête dans le passé refusent de se connecter si https n'est plus fonctionnel ou est désactivé pour une raison quelconque. Pour en savoir plus, consultez cet aide-mémoire sur le mécanisme HTTP Strict Transport Security.

Gérer les tâches asynchrones en arrière-plan

Une tâche en arrière-plan désigne toute tâche effectuée par votre application pour une requête après la transmission d'une réponse HTTP. Évitez d'effectuer des tâches en arrière-plan dans votre application et examinez votre code pour vous assurer que toutes les opérations asynchrones sont terminées avant de transmettre votre réponse.

Pour les tâches de longue durée, nous vous recommandons d'utiliser Cloud Tasks. Avec Cloud Tasks, les requêtes HTTP ont une longue durée de vie et ne renvoient une réponse qu'une fois les tâches asynchrones terminées.

Avertissement : L'exécution de tâches asynchrones en arrière-plan peut entraîner une facturation plus élevée. App Engine peut effectuer un scaling à la hausse des instances en raison d'une charge de processeur élevée, même en l'absence de requêtes actives. Les utilisateurs peuvent également rencontrer une latence accrue en raison des requêtes présentes dans la file d'attente pour les instances disponibles.