Documentation de référence du fichier app.yaml dans App Engine

L'approche recommandée pour spécifier votre ID d'application consiste à supprimer l'élément application de votre fichier app.yaml et à le remplacer par un indicateur de ligne de commande :

• Pour utiliser la commande gcloud app deploy, vous devez spécifier l'indicateur --project comme suit :

  gcloud app deploy --project [YOUR_PROJECT_ID]

Pour plus d'informations sur l'utilisation de ces commandes, consultez la page Déployer votre application.

L'ID d'application est l'ID de projet de la console Google Cloud que vous avez spécifié lors de la création de l'application dans la console Google Cloud.

Obligatoire. La version de l'API dans l'environnement d'exécution donné utilisée par votre application.

Ce champ est obsolète dans les versions plus récentes d'App Engine.

Lorsque Google annonce la compatibilité avec une nouvelle version de l'API d'un environnement d'exécution, votre application déployée continue à utiliser celle pour laquelle elle a été écrite. Pour mettre à niveau votre application vers une nouvelle version de l'API, modifiez cette valeur, puis redéployez votre application sur App Engine. Lorsque vous définissez la valeur 1, le dernier environnement d'exécution compatible est utilisé dès que vous déployez cette application (actuellement, ).

Pour le moment, App Engine dispose d'une seule version de l'environnement d'exécution python27 : 1.

default

Valeur par défaut. Utilise des ID automatiques distribués qui sont de grands entiers bien répartis, suffisamment petits pour être représentés par des nombres à virgule flottante de 64 bits.

legacy

L'option "legacy" sera obsolète dans une version ultérieure, et sera à terme supprimée. Pour en savoir plus, consultez l'article de blog annonçant cette modification.

Facultatif. Le SDK Python 2 contient un certain nombre de gestionnaires intégrés pour les fonctions d'application courantes. L'instruction builtins permet d'inclure des gestionnaires spécifiques dans le fichier app.yaml.

Ce champ est obsolète dans l'environnement d'exécution Python 3.

Vous pouvez utiliser les gestionnaires intégrés suivants :

appstats

Active les statistiques d'application dans /_ah/stats/, que vous pouvez utiliser pour mesurer les performances de votre application. Pour utiliser les statistiques d'application, vous devez également installer l'enregistreur d'événements.

deferred

Active le gestionnaire différé dans /_ah/queue/deferred. Celui-ci permet aux développeurs d'utiliser deferred.defer() pour simplifier la création des tâches Task Queue.

remote_api

Active le gestionnaire intégré remote_api dans /_ah/remote_api/. Ce gestionnaire intégré (builtin) permet aux applications distantes ayant les identifiants appropriés d'accéder au datastore à distance.

builtins:
- deferred: on
- appstats: on

L'instruction builtins est une instance spéciale de l'instruction includes. En langage Python, chaque instruction builtin équivaut à une instruction includes avec un chemin d'accès développé. Exemple :

builtins:
- name: on

Est équivalent à :

includes:
- $PYTHON_LIB/google/appengine/ext/builtins/name/

Lorsque vous utilisez l'instruction builtins dans votre fichier app.yaml, tous les gestionnaires définis dans le fichier include.yaml intégré remplacent les gestionnaires que vous définissez dans le fichier app.yaml. Toutefois, si vous incluez un fichier qui utilise ensuite les instructions builtins ou includes, les gestionnaires sont ajoutés par ordre de la hiérarchie d'inclusions. Autrement dit, les gestionnaires de l'inclusion "parent" sont ajoutés avant l'intégration des inclusions "enfant", et ainsi de suite.

Prenons l'exemple du fichier app.yaml suivant, qui utilise les gestionnaires appstats intégrés :

handlers:
- url: /.*
  script: main.app
builtins:
- appstats: on

La liste de gestionnaires qui en résulte est la suivante :

[/_ah/stats, /.*]

Si app.yaml utilise une directive includes :

includes:
- included.yaml

Et que le fichier included.yaml utilise builtins :

handlers:
- url: /.*
  script: main.app
builtins:
- appstats: on

La liste de gestionnaires qui en résulte est alors :

[/.*, /_ah/stats]

La position de la clause builtins dans un fichier .yaml n'en modifie pas le comportement.

Facultatif. Définit une durée de mise en cache globale par défaut pour tous les gestionnaires de fichiers statiques d'une application. Vous pouvez également configurer une durée de mise en cache pour des gestionnaires de fichiers statiques spécifiques. La valeur est une chaîne de nombres et d'unités, séparés par des espaces. Les unités possibles sont "d" pour les jours, "h" pour les heures, "m" pour les minutes et "s" pour les secondes. Par exemple, "4d 5h" définit l'expiration du cache sur une durée de 4 jours et 5 heures après la première requête du fichier. Si cette valeur n'est pas définie, le serveur de production définit le délai d'expiration sur 10 minutes.

runtime: python27
api_version: 1
threadsafe: true

default_expiration: "4d 5h"

handlers:
# ...

Pour en savoir plus, consultez Expiration du cache.

Facultatif. Vous pouvez définir des variables d'environnement dans le fichier app.yaml pour les rendre disponibles pour votre application. Vérifiez que la clé de la ou des variables d'environnement correspond à l'expression "[a-zA-Z_][a-zA-Z0-9_]*" (commence par une lettre de l'alphabet ou par le caractère "_", suivi de n'importe quel caractère alphanumérique ou de "_").

L'utilisation des variables d'environnement dont le préfixe est GAE est réservée au système. Ces variables ne sont pas autorisées dans le fichier app.yaml.

env_variables:
  DJANGO_SETTINGS_MODULE: "myapp.settings"

Facultatif. Permet de configurer les pages d'erreur personnalisées qui s'affichent pour différents types d'erreurs.

Cet élément peut contenir les éléments suivants :

error_code

Facultatif. L'élément error_code peut avoir l'une des valeurs suivantes :

over_quota

Indique que l'application a dépassé le quota d'une ressource.

timeout

Élément diffusé si un délai arrive à expiration avant que votre application ne réponde.

L'attribut error_code est facultatif. S'il n'est pas spécifié, le fichier fourni constitue le message d'erreur par défaut affiché par votre application.

file

Chaque entrée

indique un fichier statique qui doit être diffusé à la place du message d'erreur générique. Si vous spécifiez un élément file sans élément error_code correspondant, le fichier statique constitue la page d'erreur par défaut de l'application. Les données d'erreur personnalisées doivent être inférieures à 10 kilo-octets.

error_handlers:
  - file: default_error.html

  - error_code: over_quota
    file: over_quota.html

Obligatoire. Liste de formats d'URL, avec la description de leurs modes de gestion. Pour gérer les URL, App Engine peut exécuter le code de l'application ou diffuser des fichiers statiques importés avec le code, tels que des images, des fichiers CSS ou des fichiers JavaScript.

Voir la syntaxe de l'élément "handlers" et des sous-éléments

Facultatif. L'instruction includes permet d'inclure le fichier de configuration d'une bibliothèque ou d'un service de votre application. Par exemple, vous pouvez inclure une bibliothèque d'administration des utilisateurs comme suit :

includes:
- lib/user_admin.yaml

App Engine résout le chemin d'accès inclus dans l'ordre suivant :

• Chemin d'accès absolu ou relatif au répertoire de travail. Le chemin d'accès indiqué pointe vers un fichier.
• Chemin d'accès relatif au répertoire de l'application, également appelé basepath. Le chemin de base et le chemin d'accès aboutissent à un fichier.
• En fonction du fichier qui comprenait le fichier actuel. L'emplacement du fichier de référence et le chemin d'inclusion pointent vers le fichier inclus.

Si l'instruction include spécifie un répertoire, App Engine recherche un fichier appelé include.yaml dans ce répertoire. Si elle correspond à un fichier, ce fichier spécifique est inclus. L'instruction includes permet de ne récupérer que les types d'instructions suivants à partir du fichier de destination (le cas échéant) :

• builtins
• includes
• handlers
• skip_files

Les formats skip_files inclus sont ajoutés à ceux du fichier app.yaml, ou à la liste par défaut si app.yaml ne contient pas de liste explicite. Notez que skip_files comparent les chemins absolus.

Facultatif. Les applications doivent activer ces services pour pouvoir recevoir des requêtes entrantes. Si vous souhaitez activer le service pour une application Python 2, incluez une section inbound_services dans le fichier app.yaml.

Les services entrants suivants sont disponibles :

mail

Permet à votre application de recevoir des e-mails.

warmup

Active les requêtes de préchauffage. Consultez la page Configurer des requêtes de préchauffage.

inbound_services:
  - mail
  - warmup

Facultatif. Classe d'instance de ce service.

Les valeurs suivantes sont disponibles en fonction du scaling de votre service :

Scaling automatique

F1, F2, F4, F4_1G

Par défaut : F1

Vous pouvez éventuellement utiliser l'élément automatic_scaling pour modifier les paramètres par défaut du scaling automatique, tels que le nombre minimal et maximal d'instances, la latence et les connexions simultanées.

Remarque : Si instance_class est défini sur au moins F2, vous pouvez optimiser vos instances en définissant max_concurrent_requests sur une valeur supérieure à la valeur par défaut de dix. Pour déterminer la valeur optimale, augmentez-la progressivement et surveillez les performances de votre application.

Scaling de base et scaling manuel

B1, B2, B4, B4_1G, B8

Par défaut : B2

Les classes d'instances de base et manuelle nécessitent de spécifier l'élément basic_scaling ou manual_scaling.

Facultatif. Le moteur d'exécution Python 2.7 utilise des bibliothèques tierces. Certaines d'entre elles sont disponibles par défaut, tandis que d'autres ne sont disponibles que si elles sont configurées. Vous pouvez spécifier la version que vous souhaitez utiliser en spécifiant les valeurs name et version.

Ce champ est obsolète dans l'environnement d'exécution Python 3.

libraries:
- name: PIL
  version: "1.1.7"
- name: webob
  version: "latest"
        

Pour obtenir une liste des bibliothèques tierces incluses, consultez la section Bibliothèques tierces. Si vous souhaitez utiliser des bibliothèques tierces supplémentaires en Python pur, installez-les dans un répertoire local.

Si vous utilisez l'environnement flexible, consultez la section Utiliser des bibliothèques Python dans l'environnement flexible.

Remarque : Les modules sont maintenant appelés "services".

Pour gérer votre application avec gcloud CLI, utilisez plutôt l'élément service.

Obligatoire. Nom de l'environnement d'exécution utilisé par votre application. Par exemple, pour spécifier Python 2.7, utilisez :

runtime: python27

Les services étaient anciennement appelés "modules".

Compatible seulement avec gcloud CLI ou les plug-ins basés sur gcloud CLI, par exemple : gcloud app deploy.

Obligatoire si vous créez un service. Facultatif pour le service default. Un nom doit avoir été attribué à chaque service et à chaque version. Il peut contenir des chiffres, des lettres et des traits d'union. La longueur combinée de VERSION-dot-SERVICE-dot-PROJECT_ID (où VERSION est le nom de votre version, SERVICE est le nom de votre service et PROJECT_ID est l'ID de votre projet) ne peut pas comporter plus de 63 caractères et ne peut pas commencer ni se terminer par un trait d'union. Choisissez un nom unique pour chaque service et chaque version. N'utilisez pas le même nom pour plusieurs services ou versions.

service: service-name

module: service-name

Facultatif. L'élément service_account vous permet de spécifier un compte de service géré par l'utilisateur en tant qu'identité de la version. Le compte de service spécifié est utilisé pour accéder à d'autres services Google Cloud et pour exécuter des tâches.

service_account: [SERVICE_ACCOUNT_NAME]@[PROJECT_ID].iam.gserviceaccount.com

Facultatif. L'élément skip_files indique les fichiers du répertoire de l'application qui ne doivent pas être importés dans App Engine. Sa valeur correspond soit à une expression régulière, soit à une liste d'expressions régulières. Tout nom de fichier correspondant à l'une des expressions régulières est omis de la liste des fichiers à importer lors du transfert de l'application. Les noms de fichiers sont relatifs au répertoire du projet.

L'élément skip_files dispose des expressions régulières suivantes par défaut :

skip_files:
- ^(.*/)?#.*#$
- ^(.*/)?.*~$
- ^(.*/)?.*\.py[co]$
- ^(.*/)?.*/RCS/.*$
- ^(.*/)?\..*$

Le format par défaut exclut les fichiers de sauvegarde Emacs ayant des noms sous la forme #...# et ...~, les fichiers .pyc et .pyo, les fichiers se trouvant dans un répertoire de contrôle des révisions RCS, ainsi que les fichiers cachés Unix dont le nom commence par un point (.).

Pour ajouter des entrées à la liste des expressions régulières ci-dessus, faites-en un copier-coller dans votre fichier app.yaml, puis ajoutez vos propres expressions régulières. Par exemple, pour ignorer les fichiers dont le nom se termine par .bak en plus des formats par défaut, ajoutez une entrée de ce type pour skip_files :

skip_files:
- ^(.*/)?#.*#$
- ^(.*/)?.*~$
- ^(.*/)?.*\.py[co]$
- ^(.*/)?.*/RCS/.*$
- ^(.*/)?\..*$
- ^(.*/)?.*\.bak$

Pour ignorer un répertoire complet, ajoutez son nom à la liste. Par exemple, pour ignorer un répertoire nommé logs, ajoutez la ligne suivante à celles décrites précédemment :

skip_files:
- logs/

Obligatoire. Configure votre application pour utiliser des requêtes simultanées. Si vous utilisez la bibliothèque threading de Python, les données thread locales telles qu'affichées par threading.local() sont effacées après chaque requête.

Ce champ est obsolète dans l'environnement d'exécution Python 3.

threadsafe: [true | false]

Remarque : L'instruction threadsafe est requise pour les applications Python 2.7. threadsafe: true exige que tous les gestionnaires de scripts soient de type WSGI. Autrement dit, chaque script doit être spécifié dans une instruction script: avec le chemin du module Python, en séparant les noms de packages par un point. Le dernier composant d'une instruction script: utilisant un chemin de module Python est le nom d'une variable globale de l'élément service:. Cette variable doit être une application WSGI et est généralement appelée app par convention.

L'approche recommandée pour spécifier votre ID de version consiste à supprimer l'élément version de votre fichier app.yaml et à le remplacer par un indicateur de ligne de commande :

• Pour exécuter la commande gcloud app deploy, spécifiez l'indicateur -v :

  gcloud app deploy -v [YOUR_VERSION_ID]

Pour plus d'informations sur l'utilisation de ces commandes, consultez la page Déployer votre application.

Identifiant de la version du code d'application que vous déployez sur App Engine.

L'ID de version peut contenir des lettres minuscules, des chiffres et des traits d'union. Il ne peut pas commencer par le préfixe ah-. Les noms default et latest sont réservés et ne peuvent pas être utilisés.

Remarque : Les noms des versions doivent commencer par une lettre pour les distinguer des instances numériques qui sont toujours spécifiées par un nombre. Cela évite l'ambiguïté avec des URL telles que 123-dot-my-service.uc.r.appspot.com, qui peuvent être interprétées de deux manières. Si la version "123" "existe, la cible sera la version "123" du service donné. Si cette version n'existe pas, la cible est le numéro d'instance 123 de la version par défaut du service.

Chaque version d'une application conserve sa propre copie du fichier app.yaml. Lorsqu'une application est importée, la version mentionnée dans le fichier app.yaml importé correspond à la version créée ou remplacée par cette opération. Un administrateur peut modifier la version de l'application diffusant du trafic via Google Cloud Console. Il peut également tester d'autres versions avant de les configurer pour recevoir le trafic.

Facultatif. Configure votre application pour utiliser un connecteur d'accès au VPC sans serveur afin d'envoyer des requêtes à des ressources internes du réseau VPC. Pour en savoir plus, consultez Se connecter à un réseau VPC.

name

Littéral de chaîne Spécifiez le nom complet de votre connecteur d'accès au VPC sans serveur entre guillemets :

"projects/PROJECT_ID/locations/REGION/connectors/CONNECTOR_NAME"

egress_setting

Facultatif. La valeur par défaut est private-ranges-only. L'élément egress_setting peut avoir l'une des valeurs suivantes :

private-ranges-only

Valeur par défaut. Les requêtes adressées aux adresses IP internes sont envoyées via le connecteur d'accès au VPC sans serveur vers le réseau VPC connecté. Les requêtes adressées à des adresses IP externes sont envoyées à l'Internet public.

all-traffic

Toutes les requêtes sont envoyées via le connecteur d'accès au VPC sans serveur vers le réseau VPC connecté.

vpc_access_connector:
  name: "projects/PROJECT_ID/locations/REGION/connectors/CONNECTOR_NAME"
  egress_setting: all-traffic

Ce champ est obsolète dans les versions plus récentes d'App Engine.

Facultatif. Vous pouvez définir des en-têtes HTTP pour les réponses de vos gestionnaires de fichiers statiques ou de répertoires. Si vous devez définir des en-têtes HTTP dans vos gestionnaires script, indiquez-les plutôt dans le code de votre application. Pour en savoir plus sur les en-têtes de réponse qui affectent la mise en cache, consultez Mettre en cache du contenu statique.

handlers:
- url: /images
  static_dir: static/images
  http_headers:
    X-Foo-Header: foo
    X-Bar-Header: bar value
    vary: Accept-Encoding
  # ...

Compatibilité avec le CORS

Une des principales applications de cette fonctionnalité consiste à accepter le partage de ressources multi-origines (CORS), tel que l'accès aux fichiers hébergés par une autre application App Engine.

Par exemple, vous pouvez avoir une application de jeu mygame.uc.r.appspot.com qui accède aux éléments hébergés par myassets.uc.r.appspot.com. Cependant, si mygame tente d'envoyer une requête XMLHttpRequest JavaScript à myassets, elle n'aboutit pas à moins que le gestionnaire de myassets affiche un en-tête de réponse Access-Control-Allow-Origin: contenant la valeur http://mygame.uc.r.appspot.com.

Voici comment faire en sorte que votre gestionnaire de fichiers statiques affiche la valeur d'en-tête de réponse requise :

handlers:
- url: /images
  static_dir: static/images
  http_headers:
    Access-Control-Allow-Origin: https://mygame.uc.r.appspot.com
  # ...

Remarque : Si vous souhaitez autoriser tous les utilisateurs à accéder à vos éléments, vous pouvez utiliser le caractère générique '*' au lieu de https://mygame.uc.r.appspot.com.

Facultatif. Si vous précisez le type MIME, ce gestionnaire l'utilise pour diffuser tous les fichiers. Dans le cas contraire, le type MIME d'un fichier est dérivé de l'extension du nom de fichier. Si le même fichier est importé avec plusieurs extensions, l'extension obtenue peut dépendre de l'ordre dans lequel les importations ont eu lieu.

Pour en savoir plus sur les types de médias MIME disponibles, consultez le site Web de l'IANA sur les types de médias MIME.

Facultatif. L'élément redirect_http_response_code est utilisé avec le paramètre secure pour définir le code de réponse HTTP affiché lors de l'exécution d'une redirection requise par le mode de configuration du paramètre secure. L'élément redirect_http_response_code peut avoir les valeurs suivantes :

301

Code de réponse "Moved Permanently" (Déplacé définitivement)

302

Code de réponse "Found" (Trouvé)

303

Code de réponse "See Other" (Voir ailleurs)

307

Code de réponse "Temporary Redirect" (Redirection temporaire)

handlers:
- url: /youraccount/.*
  script: accounts.app
  login: required
  secure: always
  redirect_http_response_code: 301

Lorsque la requête d'un utilisateur est redirigée, le code d'état HTTP est défini sur la valeur du paramètre redirect_http_response_code. Le code d'état 302 s'affiche si le paramètre n'est pas spécifié.

Facultatif. Indique le chemin d'accès au script à partir du répertoire racine de l'application :

handlers:
# The root URL (/) is handled by the WSGI application named
# "app" in home.py. No other URLs match this pattern.
- url: /
  script: home.app

# The URL /index.html is also handled by the home.py script.
- url: /index\.html
  script: home.app

# A regular expression can map parts of the URL to the
# path of the script.
- url: /browse/(books|videos|tools)
  script: \1.catalog.app

# All other URLs use the WSGI application named in "app"
# in not_found.py.
- url: /.*
  script: not_found.app

Une instruction script: doit correspondre à un chemin d'importation Python, tel que package.module.app qui pointe vers une application WSGI. Le dernier composant d'une instruction script: utilisant un chemin de module Python est le nom d'une variable globale du module. Cette variable doit être une application WSGI et est généralement appelée app par convention.

Remarque : Comme pour une instruction import Python, chaque sous-répertoire constituant un package doit contenir un fichier nommé __init__.py.

Dans les environnements d'exécution App Engine plus récents, le comportement de ce champ a changé.

optional

Les requêtes HTTP et HTTPS dont les URL correspondent au gestionnaire aboutissent sans redirection. L'application peut examiner la requête pour déterminer le protocole utilisé et répondre en conséquence. Il s'agit de la valeur par défaut lorsque secure n'est pas fourni pour un gestionnaire.

never

Les requêtes d'accès à une URL, qui correspondent à ce gestionnaire et qui utilisent le protocole HTTPS, sont automatiquement redirigées vers l'URL HTTP équivalente. Lorsque la requête HTTPS d'un utilisateur est redirigée pour être convertie en requête HTTP, les paramètres sont supprimés de la requête. Cela empêche un utilisateur d'envoyer accidentellement des données de requête destinées à une connexion sécurisée, via une connexion non sécurisée.

always

Les requêtes d'accès à une URL, qui correspondent à ce gestionnaire et qui n'utilisent pas le protocole HTTPS, sont automatiquement redirigées vers l'URL HTTPS contenant le même chemin d'accès. Les paramètres de requête sont conservés pour la redirection.

handlers:
- url: /youraccount/.*
  script: accounts.app
  login: required
  secure: always

Le serveur Web de développement n'accepte pas les connexions HTTPS. Il ignore le paramètre secure. Par conséquent, les chemins accessibles via HTTPS peuvent être testés par le biais de connexions HTTP standards au serveur Web de développement.

Pour cibler une version spécifique de votre application à l'aide du domaine REGION_ID.r.appspot.com, vous devez remplacer les points qui séparent généralement les composants du sous-domaine de l'URL par la chaîne -dot-. Exemple :
https://VERSION_ID-dot-default-dot-PROJECT_ID.REGION_ID.r.appspot.com

Pour utiliser des domaines personnalisés avec HTTPS, vous devez d'abord activer et configurer les certificats SSL pour ce domaine.

Pour les comptes Google, la connexion et la déconnexion s'effectuent toujours via une connexion sécurisée, quelle que soit la manière dont les URL sont configurées.

Facultatif. Chemin d'accès au répertoire contenant les fichiers statiques, à partir du répertoire racine de l'application. Tous les éléments situés après la fin du format url correspondant sont ajoutés à static_dir pour former le chemin d'accès complet au fichier demandé.

Chaque fichier du répertoire statique est diffusé en utilisant le type MIME correspondant à son extension de nom de fichier, sauf s'il a été remplacé par le paramètre mime_type du répertoire. Tous les fichiers du répertoire donné sont importés en tant que fichiers statiques et aucun d’entre eux ne peut être exécuté en tant que script.

Tous les fichiers de ce répertoire sont transférés avec votre application en tant que fichiers statiques. App Engine stocke et diffuse des fichiers statiques indépendamment des fichiers de votre application. Les fichiers statiques ne sont pas disponibles par défaut dans le système de fichiers de l'application. Pour modifier ce comportement, définissez l'option application_readable sur "true".

handlers:
# All URLs beginning with /stylesheets are treated as paths to
# static files in the stylesheets/ directory.
- url: /stylesheets
  static_dir: stylesheets
  # ...

Facultatif. Un gestionnaire de modèles de fichiers statiques associe un modèle d'URL à des chemins d'accès aux fichiers statiques importés avec l'application. L'expression régulière du format d'URL peut définir des regroupements d'expressions régulières à utiliser pour la construction du chemin d'accès au fichier. Vous pouvez employer cette méthode à la place de static_dir pour réaliser un mappage vers des fichiers spécifiques d'une structure de répertoires, sans mapper l'intégralité du répertoire.

handlers:
# All URLs ending in .gif .png or .jpg are treated as paths to
# static files in the static/ directory. The URL pattern is a
# regular expression, with a grouping that is inserted into the
# path to the file.
- url: /(.*\.(gif|png|jpg))$
  static_files: static/\1
  upload: static/.*\.(gif|png|jpg)$
  # ...

App Engine stocke et diffuse des fichiers statiques indépendamment des fichiers d'application. Les fichiers statiques ne sont pas disponibles par défaut dans le système de fichiers de l'application. Pour modifier ce comportement, définissez l'option application_readable sur "true".

Les fichiers statiques doivent être différents des fichiers de code d'application. Si un chemin d'accès à un fichier statique correspond à un chemin d'accès à un script utilisé dans un gestionnaire dynamique, le gestionnaire dynamique ne peut pas accéder au script.

Facultatif. Expression régulière qui correspond aux chemins d'accès de tous les fichiers référencés par ce gestionnaire. Elle est nécessaire, car le gestionnaire ne peut pas déterminer quels fichiers de votre répertoire d'application correspondent aux formats url et static_files en question. Les fichiers statiques sont transférés et gérés indépendamment des fichiers d'application. Dans l'exemple ci-dessus, le format upload suivant peut être utilisé : archives/(.*)/items/(.*)

Élément requis sous handlers. Format d'URL sous la forme d'une expression régulière. L'expression peut contenir des regroupements qu'il est possible de désigner dans le chemin d'accès au script à l'aide de références arrières à des expressions régulières. Par exemple, /profile/(.*)/(.*) correspond à l'URL /profile/edit/manager, et utilise edit et manager comme premier et second regroupements.

Le format d'URL présente des différences de comportement lorsqu'il est utilisé avec les éléments suivants :

static_dir

Utilise le préfixe d'une URL. Le modèle d'expression régulière ne doit pas contenir de regroupements lorsqu'il est utilisé avec l'élément static_dir. Toutes les URL commençant par ce préfixe sont gérées par ce gestionnaire, en utilisant la partie d'URL située après le préfixe comme une partie du chemin d'accès au fichier.

static_files

Un gestionnaire de modèles de fichiers statiques associe un format d'URL à des chemins d'accès aux fichiers statiques importés avec l'application. L'expression régulière du format d'URL peut définir des regroupements d'expressions régulières à utiliser pour la construction du chemin d'accès au fichier. Vous pouvez employer cette méthode à la place de static_dir pour réaliser un mappage vers des fichiers spécifiques d'une structure de répertoires, sans mapper l'intégralité du répertoire.

Facultatif. Applicable seulement aux applications qui utilisent une classe d'instance F1 ou supérieure.

Spécifiez cet élément pour modifier les paramètres par défaut du scaling automatique, tels que la définition de niveaux minimal et maximal pour le nombre d'instances, la latence et les connexions simultanées d'un service.

Cet élément peut contenir les éléments suivants :

max_instances

Facultatif. Indiquez une valeur comprise entre 0 et 2 147 483 647, où zéro désactive le paramètre.

Ce paramètre spécifie le nombre maximal d'instances que App Engine peut créer pour cette version de module. Cela permet de limiter les coûts d'un module.

min_instances

Facultatif. Nombre minimal d'instances que App Engine doit créer pour cette version de module. Ces instances diffusent le trafic lorsque des requêtes arrivent, et continuent à le diffuser même lorsque des instances supplémentaires sont lancées pour gérer le trafic.

Spécifiez une valeur comprise entre 0 et 1 000. Vous pouvez définir le paramètre sur la valeur 0 pour permettre la mise à l'échelle de 0 instances afin de réduire les coûts lorsqu'aucune requête n'est diffusée. Notez que le nombre d'instances spécifié vous est facturé, qu'elles reçoivent ou non du trafic.

max_idle_instances

Facultatif. Nombre maximal d'instances inactives qu'App Engine doit gérer pour cette version. Définissez une valeur comprise entre 1 et 1 000. Si aucune valeur n'est spécifiée, la valeur par défaut est automatic, ce qui signifie qu'App Engine gère le nombre d'instances inactives. Tenez bien compte des éléments suivants :

• Une valeur maximale élevée réduit le nombre d'instances inactives de manière plus progressive lorsque les niveaux de charge reviennent à la normale après un pic. Votre application peut ainsi maintenir des performances constantes grâce aux fluctuations de la charge des requêtes. En revanche, cela augmente également le nombre d'instances inactives (et les coûts d'exploitation qui en découlent) pendant les périodes de charges importantes.
• Une valeur maximale faible réduit les coûts d'exploitation, mais peut dégrader les performances en présence de niveaux de charge instables.

Remarque : Lorsque vous revenez à des niveaux normaux après un pic de charge, le nombre d'instances inactives peut temporairement dépasser la valeur maximale spécifiée. Cependant, le nombre d'instances qui vous sera facturé ne pourra pas dépasser le nombre maximal spécifié.

min_idle_instances

Facultatif. Nombre d'instances supplémentaires qui doivent rester en cours d'exécution et prêtes à diffuser le trafic pour cette version.

App Engine calcule le nombre d'instances nécessaires pour diffuser le trafic actuel de votre application en fonction de paramètres de scaling tels que target_cpu_utilization et target_throughput_utilization. En définissant min_idle_instances, vous spécifiez le nombre d'instances à exécuter en plus de ce nombre calculé. Par exemple, si App Engine calcule que cinq instances sont nécessaires pour diffuser le trafic et que min_idle_instances est défini sur deux, App Engine exécutera sept instances (cinq instances, soit le nombre calculé en fonction du trafic, plus deux instances supplémentaires selon min_idle_instances).

Sachez que vous êtes facturé à hauteur du nombre d'instances spécifiées, que celles-ci reçoivent ou non du trafic. Tenez bien compte des éléments suivants :

• Une valeur minimale faible permet de limiter vos coûts d'exploitation pendant les périodes d'inactivité, mais signifie que le nombre d'instances immédiatement disponible en cas de pic de charge soudain risque d'être réduit.

• Une valeur minimale élevée vous permet de préparer l'application aux pics de charge rapides des requêtes. App Engine conserve le nombre minimal d'instances en cours d'exécution pour diffuser les requêtes entrantes. Vous êtes facturé à hauteur du nombre d'instances spécifiées, que celles-ci traitent ou non des requêtes.

  Si vous définissez un nombre minimal d'instances inactives, le temps de latence a moins d'impact sur les performances de votre application.

target_cpu_utilization

Facultatif. Définissez une valeur comprise entre 0,5 et 0,95. La valeur par défaut est 0.6.

Ce paramètre spécifie le seuil d'utilisation du processeur à partir duquel de nouvelles instances sont démarrées pour gérer le trafic. Vous pouvez ainsi trouver un bon équilibre entre les performances et les coûts. Les valeurs inférieures augmentent les performances et les coûts, et les valeurs supérieures diminuent les performances, mais également les coûts. Par exemple, une valeur de 0,7 signifie que de nouvelles instances sont démarrées lorsque l'utilisation du processeur atteint 70 %.

target_throughput_utilization

Facultatif. Définissez une valeur comprise entre 0,5 et 0,95. La valeur par défaut est 0.6.

Élément utilisé avec max_concurrent_requests pour spécifier le moment où une nouvelle instance est démarrée en raison de requêtes simultanées. Lorsque le nombre de requêtes simultanées atteint une valeur égale à max_concurrent_requests multiplié par target_throughput_utilization, le programmeur tente de démarrer une nouvelle instance.

max_concurrent_requests

Facultatif. Nombre de requêtes simultanées qu'une instance de scaling automatique peut accepter avant que le programmeur génère une nouvelle instance (par défaut : 10, maximum : 1 000).

Élément utilisé avec target_throughput_utilization pour spécifier le moment où une nouvelle instance est démarrée en raison de requêtes simultanées. Lorsque le nombre de requêtes simultanées atteint une valeur égale à max_concurrent_requests multiplié par target_throughput_utilization, le programmeur tente de démarrer une nouvelle instance.

Nous vous recommandons de ne pas définir max_concurrent_requests sur moins de 10, sauf si vous avez besoin d'un seul thread. Une valeur inférieure à 10 est susceptible de générer la création de plus d'instances que nécessaire pour une application threadsafe, ce qui peut entraîner des coûts inutiles.

Si ce paramètre est trop élevé, la latence de l'API peut augmenter. Notez que le programmeur peut créer une instance avant que le nombre maximal de requêtes effectif soit atteint.

max_pending_latency

Durée maximale pendant laquelle App Engine doit autoriser une requête à rester dans la file d'attente avant de démarrer des instances supplémentaires pour gérer les requêtes, et ainsi réduire le temps de latence. Une fois le seuil atteint, le scaling débute et provoque une augmentation du nombre d'instances. Si aucune valeur n'est spécifiée, la valeur par défaut est automatic. Cela signifie que les requêtes peuvent rester dans la file d'attente pendant 10 secondes au maximum, ce qui correspond au délai maximal de mise en file d'attente des requêtes avant le déclenchement d'une nouvelle instance.

Une valeur maximale faible signifie que App Engine démarre plus rapidement de nouvelles instances pour les requêtes en attente. Cela améliore les performances, mais augmente les coûts d'exploitation.

Une valeur maximale élevée signifie que les utilisateurs peuvent attendre plus longtemps pour que l'application diffuse leur requête (s'il y a des requêtes en attente et qu'aucune instance inactive ne les diffuse), mais aussi que l'exécution de votre application est moins coûteuse.

min_pending_latency

Élément facultatif que vous pouvez définir pour spécifier la durée minimale pendant laquelle App Engine doit autoriser une requête à rester en file d'attente avant de démarrer une nouvelle instance pour la gérer. La spécification d'une valeur peut réduire les coûts d'exécution, mais augmenter le délai de diffusion des requêtes et donc le temps d'attente des utilisateurs.

Pour les applications gratuites, la valeur par défaut est 500ms. Pour les applications payantes, la valeur par défaut est 0.

Cet élément fonctionne avec l'élément max_pending_latency pour déterminer à quel moment App Engine crée des instances. Si des requêtes en attente se trouvent dans la file d'attente :

• Inférieure à la valeur pour min_pending_latency que vous spécifiez, App Engine ne crée pas d'instances.
• Supérieure à la valeur pour max_pending_latency, App Engine tente de créer une instance.
• entre le moment spécifié par min_pending_latency et max_pending_latency, App Engine tente de réutiliser une instance existante. Si aucune instance n'est en mesure de traiter la requête avant max_pending_latency, App Engine crée une instance.

automatic_scaling:
  target_cpu_utilization: 0.65
  min_instances: 5
  max_instances: 100
  min_pending_latency: 30ms
  max_pending_latency: automatic
  max_concurrent_requests: 50

Les applications qui utilisent une classe d'instance B1 ou ultérieure doivent spécifier cet élément ou manual_scaling.

Cet élément permet le scaling de base des classes d'instances B1 et supérieures. Il peut contenir les éléments suivants :

max_instances

Obligatoire. Nombre maximal d'instances qu'App Engine peut créer pour cette version du service. Cette solution permet de limiter les coûts d'un service.

idle_timeout

Facultatif. L'instance est arrêtée pendant cette période après réception de sa dernière requête. La valeur par défaut est de cinq minutes (5m).

basic_scaling:
  max_instances: 11
  idle_timeout: 10m

Les applications qui utilisent une classe d'instance B1 ou ultérieure doivent spécifier cet élément ou basic_scaling.

Cet élément active le scaling manuel des classes d'instances B1 et supérieures, et peut contenir l'élément suivant :

instances

Nombre d'instances à attribuer au service au démarrage.

manual_scaling:
  instances: 5