Documents et index

L'API Search fournit un modèle d'indexation de documents contenant des données structurées. Vous pouvez effectuer une recherche dans un index, et organiser et présenter les résultats obtenus. L'API est compatible avec la correspondance de texte intégral sur les champs de type chaîne. Les documents et les index sont enregistrés dans des espaces de stockage persistants distincts optimisés pour les opérations de recherche. L'API Search peut indexer un nombre illimité de documents. App Engine Datastore peut être plus approprié pour les applications qui ont besoin de récupérer de gros volumes de résultats.

Aperçu

L'API Search repose sur quatre concepts principaux : les documents, les index, les requêtes et les résultats.

Documents

Un document est un objet doté d'un identifiant unique et d'une liste de champs contenant des données utilisateur. Chaque champ possède un nom et un type. Il existe plusieurs types de champs, identifiés par les types de valeurs qu'ils contiennent :

  • Champ Atom : chaîne de caractères indivisible
  • Champ texte : chaîne de texte brut dans laquelle une recherche mot à mot peut être effectuée
  • Champ HTML : chaîne contenant des balises de mise en forme HTML, avec le texte à l'extérieur. Les balises de mise en forme peuvent être recherchées
  • Champ numérique : nombre à virgule flottante
  • Champ de date : objet de date avec année/mois/jour et heure facultative
  • Champ de point géographique : objet de données contenant des coordonnées de latitude et de longitude

La taille maximale d'un document est de 1 Mo.

Index

Un index stocke les documents pour pouvoir les récupérer. Un seul document peut être récupéré par son ID, un ensemble de documents par les ID consécutifs ou la totalité des documents par leur index. Vous pouvez également rechercher dans un index des documents répondant à des critères donnés de champs et de valeurs, spécifiés en tant que chaîne de requête. Vous pouvez gérer des groupes de documents en les plaçant dans des index distincts.

Il n'y a pas de limite au nombre de documents dans un index, ni au nombre d'index que vous pouvez utiliser. La taille totale de tous les documents d'un index est limitée à 10 Go par défaut, mais elle peut être augmentée jusqu'à 200 Go en soumettant une demande à partir de la page App Engine Search de la console Google Cloud Platform.

Requêtes

Pour rechercher dans un index, construisez une requête comportant une chaîne de requête et éventuellement des options supplémentaires. Une chaîne de requête spécifie des conditions pour les valeurs d'un ou de plusieurs champs de document. Lorsque vous recherchez dans un index, vous ne récupérez que les documents de l'index dont les champs correspondent à la requête.

La requête la plus simple, parfois appelée "recherche globale", est une chaîne contenant uniquement des valeurs de champ. La recherche suivante utilise une chaîne de caractères pour rechercher les documents contenant les mots "rose" et "water" :

def simple_search(index):
    index.search('rose water')

Celle-ci recherche les documents contenant des champs de type date correspondant au 4 juillet 1776 ou des champs texte contenant la chaîne "1776-07-04" :

def search_date(index):
    index.search('1776-07-04')

Une chaîne de requête peut également être plus spécifique. Elle peut contenir un ou plusieurs termes, chacun nommant un champ et une contrainte sur la valeur du champ. La forme exacte d'un terme dépend du type du champ. Par exemple, en supposant qu'il existe un champ texte appelé "Product" et un champ numérique appelé "Price", voici une chaîne de requête comportant deux termes :

def search_terms(index):
    # search for documents with pianos that cost less than $5000
    index.search("product = piano AND price < 5000")

Les options de requête, comme leur nom l'indique, ne sont pas obligatoires. Elles offrent un certain nombre de fonctionnalités :

  • Contrôler le nombre de documents affichés dans les résultats de la recherche
  • Spécifier les champs de document à inclure dans les résultats. La valeur par défaut consiste à inclure tous les champs du document d'origine. Vous pouvez spécifier de n'inclure dans les résultats qu'un sous-ensemble de champs, le document d'origine n'étant pas affecté
  • Trier les résultats
  • Créer des "champs calculés" pour les documents utilisant FieldExpressions et des champs de texte abrégés à l'aide d'extraits
  • Permettre la pagination des résultats de la recherche en n'affichant qu'une partie des documents correspondant à chaque requête (à l'aide de décalages et de curseurs)

Résultats de recherche

Un appel à la fonction search() ne peut afficher qu'un nombre limité de documents correspondants. La recherche peut trouver plus de documents que ce qui peut être affiché lors d'un seul appel. Chaque appel de recherche affiche une instance de la classe SearchResults, qui contient des informations sur le nombre de documents trouvés et sur le nombre de documents affichés, ainsi que la liste des documents affichés. Relancez la même recherche en utilisant des curseurs ou des décalages pour récupérer l'ensemble complet des documents correspondants.

Supports de formation supplémentaires

En plus de cette documentation, vous pouvez consulter le cours en deux parties concernant l'API Search de Google Developer's Academy. Le cours comprend un exemple d'application Python.

Documents et champs

La classe Document représente des documents. Chaque document possède un identifiant de document et une liste de champs.

Identifiant du document

Chaque document présent dans un index doit posséder un identifiant de document unique, ou doc_id. Ce dernier peut être utilisé pour extraire un document d'un index sans effectuer de recherche. Par défaut, l'API Search génère automatiquement un doc_id lors de la création d'un document. Vous pouvez également spécifier vous-même le doc_id lorsque vous créez un document. Un doc_id ne doit contenir que des caractères ASCII visibles et imprimables (codes ASCII 33 à 126 inclus) et ne doit pas dépasser 500 caractères. Un identifiant de document ne peut pas commencer par un point d'exclamation ("!"), et ne peut pas commencer, ni se terminer par un double trait de soulignement ("__").

Bien qu'il soit pratique de créer des identifiants de documents uniques lisibles et significatifs, vous ne pouvez pas inclure le doc_id dans une recherche. Considérons le scénario suivant : vous disposez d'un index avec des documents qui représentent des pièces, le numéro de série de la pièce étant utilisé comme doc_id. Il sera très facile de récupérer le document correspondant à une seule pièce, mais il sera impossible de rechercher une plage de numéros de série avec d'autres valeurs de champ, telles que la date d'achat. Le problème est résolu avec l'enregistrement du numéro de série dans un champ Atom.

Champs du document

Un document contient des champs qui ont un nom, un type et une valeur unique de ce type. Deux champs ou plus peuvent avoir le même nom, mais des types différents. Par exemple, vous pouvez définir deux champs avec le nom "âge" : l'un de type texte (avec la valeur "vingt-deux"), l'autre de type numérique (avec la valeur "22").

Noms des champs

Les noms de champ sont sensibles à la casse et ne peuvent contenir que des caractères ASCII. Ils doivent commencer par une lettre et peuvent contenir des lettres, des chiffres ou des traits de soulignement. Un nom de champ ne peut pas dépasser 500 caractères.

Champs à valeurs multiples

Un champ ne peut contenir qu'une seule valeur, qui doit correspondre au type du champ. Les noms de champs ne doivent pas nécessairement être uniques. Un document peut avoir plusieurs champs portant le même nom et le même type, ce qui permet de représenter un champ avec plusieurs valeurs. Cependant, les champs de date et de numéro portant le même nom ne peuvent pas être répétés. Un document peut également contenir plusieurs champs portant le même nom mais avec des types différents.

Types de champ

Trois types de champs permettent de stocker des chaînes de caractères. Ils sont collectivement appelés champs de type chaîne :

  • Champ texte : chaîne d'une longueur maximale de 1024**2 caractères.
  • Champ HTML : chaîne au format HTML d'une longueur maximale de 1 024**2 caractères
  • Champ Atom : chaîne d'une longueur maximale de 500 caractères

Il existe également trois types de champs qui stockent des données non textuelles :

  • Champ numérique : valeur à virgule flottante avec deux décimales, comprise entre -2 147 483 647 et 2 147 483 647
  • Champ de date : datetime.date ou datetime.datetime
  • Champ de point géographique : point sur Terre décrit par ses coordonnées de latitude et de longitude.

Les types de champs sont spécifiés à l'aide des classes TextField, HtmlField, AtomField, NumberField, DateField et GeoField.

Traitement spécial des champs de chaîne et de date

Lorsqu'un document comportant des champs de types date, texte ou HTML est ajouté à un index, il est soumis à un traitement spécial. Il est utile de comprendre ce qui se passe "sous le capot" afin d'utiliser efficacement l'API Search.

Tokenisation des champs de chaîne

Lorsqu'un champ HTML ou texte est indexé, son contenu est tokenisé. La chaîne est divisée en jetons à chaque espace ou caractère spécial (signe de ponctuation, signe de hachage, barre oblique inverse, etc.). L'index inclut une entrée pour chaque jeton. Cela vous permet de rechercher des mots-clés et des expressions ne représentant qu'une partie de la valeur d'un champ. Par exemple, une recherche sur "dark" correspondra à un document dont un champ de texte contient la chaîne "it was a dark and stormy night", et une recherche sur "time" correspondra à un document dont un champ texte contient la chaîne "this is a real-time system".

Dans les champs HTML, le texte à l'intérieur des balises n'est pas tokenisé. Par conséquent, un document contenant un champ HTML avec la valeur it was a <strong>dark</strong> night correspond à une recherche sur le mot "night", mais pas sur le mot "strong". Si vous voulez pouvoir rechercher du texte de balisage, stockez-le dans un champ de texte.

Les champs Atom ne sont pas tokenisés. Un document avec un champ Atom ayant la valeur "mauvais temps" correspond uniquement à une recherche sur l'intégralité de la chaîne "mauvais temps". Il ne correspondra pas à une recherche sur les termes "mauvais" ou "temps" utilisés seuls.

Règles de tokenisation
  • Le trait de soulignement (_) et l'esperluette (&) ne divisent pas les mots en jetons.

  • Les caractères d'espacement suivants divisent toujours les mots en jetons : espace, retour chariot, saut de ligne, tabulation horizontale, tabulation verticale, saut de page et valeur nulle.

  • Les caractères suivants sont considérés comme signes de ponctuation et divisent les mots en jetons :

!)%()
*,-|/
[]]^`
:=>?@
{}~$

  • Les caractères du tableau suivant divisent généralement les mots en jetons, mais ils peuvent être gérés différemment selon le contexte dans lequel ils apparaissent :
Caractère Règle
< Dans un champ HTML, le signe "inférieur à" indique le début d'une balise HTML qui est ignorée.
+ Une chaîne d'un ou de plusieurs signes "plus" est traitée comme une partie du mot si elle apparaît à la fin de celui-ci (C++).
# Le signe dièse est considéré comme une partie du mot s'il est précédé de a, b, c, d, e, f, g, j ou x (a# et g# sont des notes de musique, j# et x# sont des langages de programmation, c# correspond aux deux). Si un terme est précédé de "#" (#google), il est traité comme un hashtag et le signe dièse devient une partie du mot.
' L'apostrophe est une lettre si elle précède la lettre "s" suivie d'une coupure entre deux mots, comme dans l'anglais "John's hat".
. Si un point apparaît entre des chiffres, il fait partie d'un nombre (séparateur décimal). Ce point peut également faire partie d'un mot s'il est utilisé dans un acronyme (A.B.C).
- Le tiret fait partie d'un mot s'il est utilisé dans un acronyme (I-B-M).
  • Tous les autres caractères 7 bits autres que les lettres et les chiffres ("A-Z", "a-z", "0-9") sont traités comme des signes de ponctuation et divisent les mots en jetons.

  • Tout le reste est analysé comme caractère UTF-8.

Acronymes

La tokenisation utilise des règles spéciales pour reconnaître les acronymes (des chaînes telles que "I.B.M", "a-b-c" ou "C I A"). Un acronyme est une chaîne de caractères alphabétiques uniques, tous séparés par le même caractère de séparation. Les caractères de séparation valides sont le point, le tiret ou n'importe quel nombre d'espaces. Le caractère de séparation est supprimé de la chaîne lorsqu'un acronyme est tokenisé. Ainsi, les exemples de chaînes mentionnés ci-dessus deviennent les jetons "ibm", "abc" et "cia". Le texte original reste dans le champ du document.

Lorsque vous travaillez avec des acronymes, notez les points suivants :

  • Un acronyme ne peut pas contenir plus de 21 lettres. Une chaîne d'acronyme valide comportant plus de 21 lettres sera divisée en une série d'acronymes de 21 lettres ou moins.
  • Si les lettres d'un acronyme sont séparées par des espaces, toutes les lettres doivent avoir la même casse. Les acronymes construits avec des points ou des tirets peuvent utiliser à la fois des lettres majuscules et minuscules.
  • Lorsque vous recherchez un acronyme, vous pouvez entrer la forme canonique de l'acronyme (la chaîne sans séparateurs) ou l'acronyme ponctué du tiret ou du point (mais pas les deux) entre ses lettres. Ainsi, le texte "I.B.M" peut être récupéré avec les termes de recherche "I-B-M", "I.B.M" ou "IBM".

Précision du champ de date

Lorsque vous créez un champ de date dans un document, vous définissez sa valeur sur "datetime.date" ou "datetime.datetime". Seuls les objets de date et heure "naive" (naïfs) de Python peuvent être utilisés. Les objets "aware" (conscients) ne sont pas autorisés. À des fins d'indexation et de recherche dans le champ de date, tout composant de temps est ignoré et la date est convertie en nombre de jours depuis le 01/01/1970 UTC. Cela signifie que même si un champ de date peut contenir une valeur d'heure précise, une requête sur la date ne peut spécifier qu'une valeur sous la forme yyyy-mm-dd. Cela signifie également que l'ordre des champs de date triés comportant la même date n'est pas bien défini.

Autres propriétés du document

Le rang d'un document est un entier positif qui détermine le classement par défaut des documents affichés à partir d'une recherche. Par défaut, le rang est défini au moment où le document est créé avec le nombre de secondes écoulées depuis le 1er janvier 2011. Vous pouvez définir explicitement le rang lorsque vous créez un document. Il est déconseillé d'attribuer le même rang à de nombreux documents et vous ne devez jamais attribuer plus de 10 000 documents au même rang. Si vous spécifiez les [sort options](/appengine/docs/standard/go/search/options#SortOptions), vous pouvez utiliser le rang comme clé de tri. Notez que lorsque le rang est utilisé dans une expression de tri ou dans une expression de champ, il est référencé sous la forme _rank.

La propriété "language" spécifie la langue dans laquelle les champs sont codés.

Consultez la page de référence de la classe Document pour plus de détails sur ces attributs.

Lier un document à d'autres ressources

Vous pouvez utiliser le doc_id d'un document ainsi que d'autres champs en tant que liens vers d'autres ressources de votre application. Par exemple, si vous utilisez Blobstore, vous pouvez associer le document à un blob spécifique en définissant le doc_id ou la valeur d'un champ Atom sur l'attribut BlobKey des données.

Créer un document

L'exemple de code suivant montre comment créer un objet de document. Le constructeur de document est appelé avec l'argument "fields" défini en tant que liste d'objets de champ. Chaque objet de la liste est créé et initialisé à l'aide de la fonction constructeur de la classe du champ. Notez l'utilisation du constructeur GeoPoint et de la classe Python datetime pour créer les types appropriés de valeurs de champ.

def create_document():
    document = search.Document(
        # Setting the doc_id is optional. If omitted, the search service will
        # create an identifier.
        doc_id='PA6-5000',
        fields=[
            search.TextField(name='customer', value='Joe Jackson'),
            search.HtmlField(
                name='comment', value='this is <em>marked up</em> text'),
            search.NumberField(name='number_of_visits', value=7),
            search.DateField(name='last_visit', value=datetime.now()),
            search.DateField(
                name='birthday', value=datetime(year=1960, month=6, day=19)),
            search.GeoField(
                name='home_location', value=search.GeoPoint(37.619, -122.37))
        ])
    return document

Travailler avec un index

Placer des documents dans un index

Lorsque vous placez un document dans un index, il est copié dans le stockage persistant, et chacun de ses champs est indexé en fonction de son nom, de son type et du doc_id.

L'exemple de code suivant montre comment accéder à un index et y insérer un document.

def add_document_to_index(document):
    index = search.Index('products')
    index.put(document)
Vous pouvez transmettre jusqu'à 200 documents à la fois à la méthode put(). Le traitement par lots est plus efficace que l'ajout de documents un à un.

Lorsque vous placez un document dans un index et que celui-ci contient déjà un document avec le même doc_id, le nouveau document remplace l'ancien. Aucun avertissement n'est donné. Vous pouvez appeler Index.get(id) avant de créer ou d'ajouter un document à un index pour vérifier si un doc_id spécifique existe déjà.

La méthode put renvoie une liste de PutResults, une pour chaque document transmis en tant qu'argument. Si vous n'avez pas spécifié le doc_id vous-même, vous pouvez examiner l'attribut id du résultat pour découvrir le doc_id qui a été généré :

def add_document_and_get_doc_id(documents):
    index = search.Index('products')
    results = index.put(documents)
    document_ids = [document.id for document in results]
    return document_ids

Notez que la création d'une instance de classe Index ne garantit pas l'existence d'un index persistant. Un index persistant est créé la première fois que vous y ajoutez un document avec la méthode put. Pour vérifier si un index existe réellement avant de commencer à l'utiliser, appelez la fonction search.get_indexes().

Mettre à jour des documents

Un document ne peut pas être modifié une fois que vous l'avez ajouté à un index. Vous ne pouvez pas ajouter ou supprimer de champs, ni modifier la valeur d'un champ. Toutefois, vous pouvez remplacer le document par un nouveau document ayant le même doc_id.

Récupérer des documents par doc_id

Il existe deux manières de récupérer des documents à partir d'un index à l'aide des identifiants de document :
  • Utiliser Index.get() pour récupérer un seul document à l'aide de son doc_id
  • Utiliser Index.get_range() pour récupérer un groupe de documents consécutifs classés par doc_id

Chaque appel est illustré dans l'exemple ci-dessous.

def get_document_by_id():
    index = search.Index('products')

    # Get a single document by ID.
    document = index.get("AZ125")

    # Get a range of documents starting with a given ID.
    documents = index.get_range(start_id="AZ125", limit=100)

    return document, documents

Recherche de documents par leur contenu

Pour récupérer des documents dans un index, construisez une chaîne de requête et appelez la méthode "Index.search()". La chaîne de requête peut être transmise directement en tant qu'argument, ou vous pouvez l'inclure dans un objet Requête transmis en tant qu'argument. Par défaut, search() affiche les documents correspondants triés par ordre de rang décroissant. Pour contrôler le nombre de documents affichés, leur mode de tri ou l'ajout de champs calculés aux résultats, vous devez utiliser un objet Query contenant une chaîne de requête, qui peut également spécifier d'autres options de recherche et de tri.

def query_index():
    index = search.Index('products')
    query_string = 'product: piano AND price < 5000'

    results = index.search(query_string)

    for scored_document in results:
        print(scored_document)

Supprimer des documents d'un index

Vous pouvez supprimer des documents d'un index en spécifiant le doc_id du ou des documents à supprimer dans la méthode Index.delete(). Pour obtenir une plage d'ID de document dans un index, spécifiez l'argument "ids_only" dans la méthode Index.get_range(). Lorsque vous appelez cette méthode, l'API affiche des objets de document ne contenant que le doc_id. Vous pouvez ensuite supprimer les documents en transmettant ces identifiants de documents à la méthode delete() :

def delete_all_in_index(index):
    # index.get_range by returns up to 100 documents at a time, so we must
    # loop until we've deleted all items.
    while True:
        # Use ids_only to get the list of document IDs in the index without
        # the overhead of getting the entire document.
        document_ids = [
            document.doc_id
            for document
            in index.get_range(ids_only=True)]

        # If no IDs were returned, we've deleted everything.
        if not document_ids:
            break

        # Delete the documents for the given IDs
        index.delete(document_ids)
Vous pouvez transmettre jusqu'à 200 documents à la fois à la méthode delete(). Il est plus efficace de supprimer des documents par lots que de les traiter un par un.

Cohérence dans le temps

Lorsque vous placez, mettez à jour ou supprimez un document d'un index, la modification se propage sur plusieurs centres de données. Cela se produit généralement rapidement, mais le temps nécessaire est variable. L'API Search garantit la cohérence à terme. Cela signifie que dans certains cas, si vous effectuez une recherche ou récupérez un ou plusieurs documents par leur identifiant, les résultats risquent de ne pas refléter la modification la plus récente.

Déterminer la taille d'un index

Un index stocke les documents pour pouvoir les récupérer. Un seul document peut être récupéré par son ID, un ensemble de documents par les ID consécutifs ou la totalité des documents par leur index. Vous pouvez également rechercher dans un index des documents répondant à des critères donnés de champs et de valeurs, spécifiés en tant que chaîne de requête. Vous pouvez gérer des groupes de documents en les plaçant dans des index distincts. Il n'y a pas de limite au nombre de documents dans un index, ni au nombre d'index que vous pouvez utiliser. La taille totale de tous les documents d'un index est limitée à 10 Go par défaut, mais elle peut être augmentée jusqu'à 200 Go en soumettant une demande à partir de la page App Engine Search de la console Google Cloud Platform. La propriété d'index storage_limit représente la taille maximale autorisée d'un index.

La propriété d'index storage_usage représente une estimation de la quantité d'espace de stockage utilisée par un index. Ce nombre est une estimation, car le système de surveillance d'index ne fonctionne pas en permanence. L'utilisation réelle est calculée périodiquement. La valeur storage_usage est ajustée entre les points d'échantillonnage en prenant en compte les ajouts de documents, mais pas les suppressions.

Exécuter des opérations asynchrones

Les appels asynchrones permettent d'exécuter plusieurs opérations sans interruption, puis d'extraire tous les résultats en même temps en ne bloquant l'exécution qu'une seule fois. Par exemple, le code suivant exécute plusieurs recherches de manière asynchrone :

def async_query(index):
    futures = [index.search_async('foo'), index.search_async('bar')]
    results = [future.get_result() for future in futures]
    return results

Schémas d'index

Chaque index dispose d'un schéma qui montre tous les noms et types de champs qui apparaissent dans les documents qu'il contient. Vous ne pouvez pas définir un schéma vous-même. Les schémas sont maintenus dynamiquement et mis à jour à mesure que des documents sont ajoutés à un index. Un schéma simple peut être semblable à ceci, au format JSON :

{'comment': ['TEXT'], 'date': ['DATE'], 'author': ['TEXT'], 'count': ['NUMBER']}

Chaque clé du dictionnaire est le nom d'un champ de document. La valeur de la clé est la liste des types de champs utilisés avec ce nom de champ. Si vous avez utilisé le même nom de champ avec différents types de champs, le schéma indiquera plusieurs types de champ pour un nom de champ, comme ci-dessous :

{'ambiguous-integer': ['TEXT', 'NUMBER', 'ATOM']}

Une fois qu'un champ apparaît dans un schéma, il ne peut plus être supprimé. Il n'est pas possible de supprimer un champ, même si l'index ne contient plus de document portant ce nom de champ particulier.

Vous pouvez afficher les schémas de vos index comme suit :

from google.appengine.api import search
...
for index in search.get_indexes(fetch_schema=True):
    logging.info("index %s", index.name)
    logging.info("schema: %s", index.schema)
Notez qu'un appel à get_indexes ne peut pas afficher plus de 1 000 index. Pour récupérer d'autres index, appelez la fonction à plusieurs reprises à l'aide de l'argument start_index_name.

Un schéma ne définit pas une "classe" au sens de la programmation orientée objet. En ce qui concerne l'API Search, chaque document est unique et les index peuvent contenir différentes sortes de documents. Si vous souhaitez traiter des collections d'objets avec la même liste de champs que les instances d'une classe, vous devez appliquer une abstraction dans votre code. Par exemple, vous pouvez vous assurer que tous les documents contenant le même ensemble de champs sont conservés dans leur propre index. Le schéma d'index peut être considéré comme la définition de la classe et chaque document de l'index comme une instance de la classe.

Afficher des index dans la console Google Cloud Platform

Dans la console GCP, vous pouvez afficher des informations sur les index de votre application et les documents qu'ils contiennent. Cliquer sur un nom d'index permet de consulter les documents qu'il contient. Tous les champs de schéma définis pour l'index s'affichent. Pour chaque document comportant un champ avec ce nom, la valeur du champ s'affiche. Vous pouvez également émettre des requêtes sur les données d'index directement à partir de la console.

Quotas de l'API Search

L'API Search dispose de plusieurs quotas gratuits :

Ressource ou appel d'API Quota gratuit
Stockage total (documents et index) 0,25 Go
Requêtes 1 000 requêtes par jour
Ajout de documents aux index 0,01 Go par jour

Pour assurer la fiabilité du service, l'API Search impose les limites suivantes. Celles-ci s'appliquent aux applications gratuites et payantes :

Ressource Quota de sécurité
Utilisation maximale des requêtes 100 minutes cumulées de temps d'exécution des requêtes par minute
Nombre maximal de documents ajoutés ou supprimés 15 000 par minute
Taille maximale par index (nombre illimité d'index autorisés) 10 Go

L'utilisation de l'API est comptabilisée de différentes manières en fonction du type d'appel :

  • Index.search() : chaque appel d'API est comptabilisé comme une requête. Le temps d'exécution est équivalent à la latence de l'appel.
  • Index.put() : lorsque vous ajoutez des documents à des index, la taille de chaque document et le nombre de documents sont pris en compte dans le quota d'indexation.
  • Tous les autres appels de l'API Search sont comptabilisés en fonction du nombre d'opérations impliquées :
    • search.get_indexes() : une opération pour chaque index effectivement affiché ou une opération si rien n'est affiché.
    • Index.get() et Index.get_range() : une opération pour chaque document effectivement affiché ou une opération si rien n'est affiché.
    • Index.delete() : une opération pour chaque document de la requête ou une opération si la requête est vide.

Le quota sur le débit de la requête est imposé de sorte qu'un utilisateur ne puisse pas monopoliser le service de recherche. Comme les requêtes peuvent s'exécuter simultanément, chaque application est autorisée à exécuter des requêtes qui consomment jusqu'à 100 minutes de temps d'exécution par minute. Si vous exécutez de nombreuses requêtes courtes, vous n'atteindrez probablement pas cette limite. Une fois que vous avez dépassé le quota, les requêtes suivantes échouent jusqu'à la période suivante, lorsque votre quota est restauré. Le quota n'est pas strictement imposé par tranches d'une minute. Une variante de l'algorithme leaky bucket (algorithme du seau percé) permet de contrôler la bande passante utilisée par la recherche par incréments de cinq secondes.

Vous trouverez plus d'informations sur les quotas à la page Quotas. Lorsqu'une application tente de dépasser ces montants, une erreur de quota insuffisant s'affiche.

Notez que, bien que ces limites soient appliquées à la minute, la console affiche les totaux quotidiens pour chacune d'entre elles. Les clients ayant souscrit une formule d'assistance Silver, Gold ou Platinum peuvent demander une augmentation des limites de débit en contactant leur conseiller de l'équipe d'assistance.

Tarifs de l'API Search

Si vous activez la facturation pour votre application, toute utilisation au-delà des quotas gratuits vous sera facturée. Les frais suivants s'appliquent aux applications facturées :

Ressource Coût
Stockage total (documents et index) 0,18 $ par Go par mois
Requêtes 0,50 $ pour 10 000 requêtes
Indexation de documents dans l'index de recherche 2,00 $ par Go

Pour en savoir plus sur les tarifs, consultez la page Tarifs.

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

Envoyer des commentaires concernant…

Environnement standard App Engine pour Python