Créer un connecteur de contenu

Un connecteur de contenu est un logiciel qui parcourt les données d'un dépôt d'entreprise et alimente une source de données. Google propose les options suivantes pour développer des connecteurs de contenu :

  • Le SDK Content Connector. Cette option est idéale pour les programmeurs Java. Le SDK est un wrapper pour l'API REST qui accélère la création des connecteurs. Pour créer un connecteur de contenu à l'aide du SDK, consultez Créer un connecteur de contenu à l'aide du SDK Content Connector.

  • Une API REST de bas niveau ou des bibliothèques d'API. Préférez ces options si vous n'utilisez pas Java, ou si votre base de code est mieux adaptée à une API REST ou à une bibliothèque. Pour créer un connecteur de contenu à l'aide de l'API REST, consultez Créer un connecteur de contenu à l'aide de l'API REST.

Un connecteur de contenu standard exécute les tâches suivantes :

  1. Lecture et traitement des paramètres de configuration
  2. Extraction de fragments distincts de données indexables, appelées éléments, à partir du dépôt tiers
  3. Combinaison des listes de contrôle d'accès (LCA), des métadonnées et des contenus dans les éléments indexables
  4. Indexe les éléments dans la source de données Cloud Search.
  5. (Facultatif) Écoute les notifications de modification en provenance du dépôt. Les notifications de modification sont converties en requêtes d'indexation pour que la source de données Cloud Search reste synchronisée. Le connecteur exécute cette tâche à condition que le dépôt autorise la détection des modifications.

Créer un connecteur de contenu à l'aide du SDK Content Connector

Les sections suivantes expliquent comment créer un connecteur de contenu à l'aide du SDK Content Connector.

Configurer des dépendances

Incluez ces dépendances dans votre fichier de compilation.

Maven

xml <dependency> <groupId>com.google.enterprise.cloudsearch</groupId> <artifactId>google-cloudsearch-indexing-connector-sdk</artifactId> <version>v1-0.0.3</version> </dependency>

Gradle

groovy compile group: 'com.google.enterprise.cloudsearch', name: 'google-cloudsearch-indexing-connector-sdk', version: 'v1-0.0.3'

Créer la configuration de votre connecteur

Chaque connecteur utilise un fichier de configuration pour les paramètres tels que l'ID de votre dépôt. Définissez les paramètres sous forme de paires clé-valeur, comme api.sourceId=1234567890abcdef.

Le SDK Google Cloud Search inclut des paramètres fournis par Google pour tous les connecteurs. Vous devez déclarer les éléments suivants dans votre fichier de configuration :

  • Connecteur de contenu : déclarez api.sourceId et api.serviceAccountPrivateKeyFile. Ils identifient votre dépôt et la clé privée nécessaire pour y accéder.
  • Connecteur d'identité : déclarez api.identitySourceId pour identifier votre source d'identité externe. Pour la synchronisation des utilisateurs, déclarez également api.customerId (l'ID unique de votre compte Google Workspace).

Déclarez les autres paramètres fournis par Google uniquement pour remplacer leurs valeurs par défaut. Pour savoir comment générer des ID et des clés, consultez Paramètres fournis par Google.

Vous pouvez également définir des paramètres propres au dépôt dans votre fichier de configuration.

Transmettre le fichier de configuration au connecteur

Définissez la propriété système config pour transmettre le fichier de configuration. Utilisez l'argument -D lorsque vous démarrez le connecteur. Exemple :

java -classpath myconnector.jar -Dconfig=MyConfig.properties MyConnector

Si vous omettez cet argument, le SDK tente d'utiliser un fichier nommé connector-config.properties dans le répertoire local.

Déterminer votre stratégie de balayage

La fonction principale d'un connecteur de contenu consiste à parcourir un dépôt et à en indexer les données. Vous devez mettre en place une stratégie basée sur la taille et la disposition de votre dépôt. Vous pouvez concevoir votre propre stratégie ou en choisir une dans le SDK :

Stratégie de balayage complet
 Analyse l'intégralité du dépôt et indexe chaque élément. Cette stratégie est optimale pour les petits dépôts où vous pouvez vous permettre la surcharge d'un parcours complet lors de chaque indexation. Utilisez-la pour les petits dépôts contenant principalement des données statiques non hiérarchisées, ou lorsque la détection des modifications est difficile.
Stratégie de balayage de liste
 : analyse l'intégralité du dépôt pour déterminer l'état de chaque élément, puis indexe uniquement les éléments nouveaux ou modifiés. Utilisez cette méthode pour les mises à jour incrémentielles d'un grand index non hiérarchique lorsque la détection des modifications n'est pas prise en charge.
Parcours de graphe
 Analyse un nœud parent pour déterminer l'état de ses éléments, puis indexe les éléments nouveaux ou modifiés de ce nœud. Il traite ensuite les nœuds enfants de manière récursive. Utilisez cette stratégie pour les dépôts hiérarchiques pour lesquels il est difficile d'établir une liste exhaustive des ID, comme les structures de répertoires ou les sites Web.

Le SDK implémente ces stratégies dans des classes de connecteur de modèle. Ces modèles peuvent accélérer votre développement. Pour utiliser un modèle, consultez la section correspondante :

Créer un connecteur de balayage complet à partir d'un modèle de classe

Cette section fait référence au code de l'exemple FullTraversalSample.

Ajouter le point d'entrée du connecteur

Le point d'entrée est la méthode main(). Il crée une instance Application et appelle start() pour exécuter le connecteur.

Avant d'appeler application.start(), utilisez la classe IndexingApplication.Builder pour instancier le modèle FullTraversalConnector. Ce modèle accepte un objet Repository.

FullTraversalSample.java
/**
 * This sample connector uses the Cloud Search SDK template class for a full
 * traversal connector.
 *
 * @param args program command line arguments
 * @throws InterruptedException thrown if an abort is issued during initialization
 */
public static void main(String[] args) throws InterruptedException {
  Repository repository = new SampleRepository();
  IndexingConnector connector = new FullTraversalConnector(repository);
  IndexingApplication application = new IndexingApplication.Builder(connector, args).build();
  application.start();
}

Le SDK appelle initConfig() après que votre méthode main() a appelé Application.build(). La méthode initConfig() :

  1. S'assure que Configuration n'est pas déjà initialisé.
  2. Initialise l'objet Configuration avec les paires clé/valeur fournies par Google.

Implémenter l'interface Repository

L'objet Repository parcourt et indexe les éléments du dépôt. Lorsque vous utilisez un modèle, il vous suffit de remplacer certaines méthodes dans l'interface Repository. Pour FullTraversalConnector, remplacez :

  • init() : pour la configuration et l'initialisation du dépôt.
  • getAllDocs() : pour parcourir et indexer tous les éléments. Celle-ci est appelée une fois pour chaque balayage planifié.
  • (Facultatif) getChanges() : si votre dépôt accepte la détection des modifications, remplacez cette méthode pour récupérer et indexer les éléments modifiés.
  • (Facultatif) close() : pour le nettoyage du dépôt lors de l'arrêt.

Chaque méthode renvoie un objet ApiOperation, qui effectue l'indexation à l'aide de IndexingService.indexItem().

Récupérer les paramètres de configuration personnalisés

Pour gérer la configuration de votre connecteur, vous devez récupérer les éventuels paramètres personnalisés contenus dans l'objet Configuration. Effectuez cette tâche dans la méthode init() de la classe Repository.

La classe Configuration inclut des méthodes permettant de récupérer différents types de données. Chaque méthode renvoie un objet ConfigValue. Utilisez la méthode get() de l'objet ConfigValue pour récupérer la valeur. Cet extrait de code issu de FullTraversalSample montre comment récupérer une valeur entière personnalisée :

FullTraversalSample.java
@Override
public void init(RepositoryContext context) {
  log.info("Initializing repository");
  numberOfDocuments = Configuration.getInteger("sample.documentCount", 10).get();
}

Pour récupérer et analyser des paramètres comportant plusieurs valeurs, utilisez l'un des analyseurs de type de la classe Configuration. Cet extrait du connecteur du tutoriel utilise getMultiValue pour récupérer la liste des noms de dépôts GitHub :

GithubRepository.java
ConfigValue<List<String>> repos = Configuration.getMultiValue(
    "github.repos",
    Collections.emptyList(),
    Configuration.STRING_PARSER);

Effectuer un balayage complet

Remplacez getAllDocs() pour effectuer un balayage complet. Cette méthode accepte un point de contrôle pour reprendre l'indexation en cas d'interruption. Pour chaque élément :

  1. Définissez les autorisations.
  2. Définissez les métadonnées.
  3. Combinez-les dans un RepositoryDoc.
  4. Empaquetez chaque élément dans l'itérateur renvoyé par getAllDocs().

Si l'ensemble d'éléments est trop volumineux pour un seul appel, utilisez un point de contrôle et appelez hasMore(true).

Définir les autorisations pour un élément

Les dépôts utilisent des listes de contrôle d'accès (LCA) pour identifier les utilisateurs ou les groupes ayant accès à un élément. Une LCA liste les ID des utilisateurs ou groupes autorisés.

Pour vous assurer que les utilisateurs ne voient que les résultats de recherche auxquels ils sont autorisés à accéder, vous devez répliquer les LCA de votre dépôt. Incluez la LCA lors de l'indexation d'un élément afin que Google Cloud Search puisse fournir le niveau d'accès approprié.

Le SDK Content Connector inclut des classes et des méthodes permettant de modéliser les LCA de la plupart des dépôts. Analysez les LCA de votre dépôt et créez des LCA correspondantes pour Cloud Search lors de l'indexation. La modélisation des LCA complexes, comme celles qui utilisent l'héritage, nécessite une planification minutieuse. Pour en savoir plus, consultez LCA Cloud Search.

Utilisez la classe Acl.Builder pour définir l'accès. Cet extrait de l'exemple de parcours complet permet à tous les utilisateurs du domaine (getCustomerPrincipal()) de lire tous les éléments (setReaders()) :

FullTraversalSample.java
// Make the document publicly readable within the domain
Acl acl = new Acl.Builder()
    .setReaders(Collections.singletonList(Acl.getCustomerPrincipal()))
    .build();

Pour modéliser correctement les LCA de dépôt, en particulier ceux qui utilisent des modèles d'héritage, vous devez consulter les informations sur les LCA de Cloud Search.

Définir les métadonnées d'un élément

Les métadonnées sont stockées dans un objet Item. La création d'un Item nécessite un ID unique, un type d'élément, une LCA, une URL et une version. Utilisez la classe d'assistance IndexingItemBuilder.

FullTraversalSample.java
// Url is required. Use google.com as a placeholder for this sample.
String viewUrl = "https://www.google.com";

// Version is required, set to current timestamp.
byte[] version = Longs.toByteArray(System.currentTimeMillis());

// Using the SDK item builder class to create the document with appropriate attributes
// (this can be expanded to include metadata fields etc.)
Item item = IndexingItemBuilder.fromConfiguration(Integer.toString(id))
    .setItemType(IndexingItemBuilder.ItemType.CONTENT_ITEM)
    .setAcl(acl)
    .setSourceRepositoryUrl(IndexingItemBuilder.FieldOrValue.withValue(viewUrl))
    .setVersion(version)
    .build();
Créer l'élément indexable

Utilisez la classe RepositoryDoc.Builder.

FullTraversalSample.java
// For this sample, content is just plain text
String content = String.format("Hello world from sample doc %d", id);
ByteArrayContent byteContent = ByteArrayContent.fromString("text/plain", content);

// Create the fully formed document
RepositoryDoc doc = new RepositoryDoc.Builder()
    .setItem(item)
    .setContent(byteContent, IndexingService.ContentFormat.TEXT)
    .build();

Un RepositoryDoc est un ApiOperation qui exécute la requête IndexingService.indexItem().

Utilisez la méthode setRequestMode() de la classe RepositoryDoc.Builder pour définir la requête d'indexation sur ASYNCHRONOUS ou SYNCHRONOUS :

ASYNCHRONOUS
Ce mode présente une latence plus longue entre l'indexation et la diffusion, mais autorise un quota de débit plus important. Utilisez le mode asynchrone pour l'indexation initiale (remplissage) d'un dépôt entier.
SYNCHRONOUS
Ce mode présente une latence plus courte entre l'indexation et la diffusion, mais un quota de débit plus faible. Utilisez le mode synchrone pour indexer les mises à jour et les modifications apportées au dépôt. Si vous n'indiquez pas de mode de requête, la valeur SYNCHRONOUS est attribuée par défaut.
Empaqueter chaque élément indexable dans un itérateur

La méthode getAllDocs() renvoie un CheckpointCloseableIterable d'objets RepositoryDoc. Utilisez la classe CheckpointCloseableIterableImpl.Builder.

FullTraversalSample.java
CheckpointCloseableIterable<ApiOperation> iterator =
  new CheckpointCloseableIterableImpl.Builder<>(allDocs).build();

Étapes suivantes

Créer un connecteur de balayage de liste à partir d'un modèle de classe

La file d'attente d'indexation Cloud Search contient les ID et les hachages facultatifs des éléments du dépôt. Un connecteur de balayage de liste place les ID dans cette file d'attente et les récupère pour l'indexation. Cloud Search gère ces files d'attente pour déterminer l'état des éléments (s'ils ont été supprimés, par exemple). Consultez File d'attente d'indexation de Cloud Search.

Cette section fait référence à l'exemple ListTraversalSample.

Ajouter le point d'entrée du connecteur

La méthode main() crée une instance Application et appelle start(). Utilisez IndexingApplication.Builder pour instancier le modèle ListingConnector.

ListTraversalSample.java
/**
 * This sample connector uses the Cloud Search SDK template class for a
 * list traversal connector.
 *
 * @param args program command line arguments
 * @throws InterruptedException thrown if an abort is issued during initialization
 */
public static void main(String[] args) throws InterruptedException {
  Repository repository = new SampleRepository();
  IndexingConnector connector = new ListingConnector(repository);
  IndexingApplication application = new IndexingApplication.Builder(connector, args).build();
  application.start();
}

Implémenter l'interface Repository

Remplacez les méthodes suivantes pour ListingConnector :

  • init() : pour la configuration du dépôt.
  • getIds() : pour récupérer les ID et les hachages de tous les enregistrements.
  • getDoc() : permet d'ajouter, de mettre à jour ou de supprimer des éléments de l'index.
  • (Facultatif) getChanges() : pour les mises à jour incrémentielles à l'aide de la détection des modifications.
  • (Facultatif) close() : pour le nettoyage du dépôt.

Effectuer un balayage de liste

Remplacez getIds() pour récupérer les ID et les hachages. Remplacez getDoc() pour traiter chaque élément de la file d'attente d'indexation Cloud Search.

Transmettre les ID et valeurs de hachage des éléments

Remplacez getIds() pour récupérer les ID et les hachages de contenu. Regroupez-les dans une requête PushItems à la file d'attente d'indexation.

ListTraversalSample.java
PushItems.Builder allIds = new PushItems.Builder();
for (Map.Entry<Integer, Long> entry : this.documents.entrySet()) {
  String documentId = Integer.toString(entry.getKey());
  String hash = this.calculateMetadataHash(entry.getKey());
  PushItem item = new PushItem().setMetadataHash(hash);
  log.info("Pushing " + documentId);
  allIds.addPushItem(documentId, item);
}

Utilisez PushItems.Builder pour regrouper les ID et les hachages.

ListTraversalSample.java
ApiOperation pushOperation = allIds.build();
CheckpointCloseableIterable<ApiOperation> iterator =
  new CheckpointCloseableIterableImpl.Builder<>(
      Collections.singletonList(pushOperation))
  .build();
return iterator;
Récupérer et traiter chaque élément

Remplacez getDoc() pour gérer les éléments de la file d'attente d'indexation. Les éléments peuvent être nouveaux, modifiés, inchangés ou supprimés.

  1. Vérifiez si l'ID de l'élément existe dans le dépôt. Dans le cas contraire, supprimez-le.
  2. Interrogez l'index pour connaître l'état. Si l'état est ACCEPTED, ne faites rien.
  3. Pour les éléments d'index nouveaux ou modifiés, définissez les autorisations et les métadonnées, combinez-les dans un RepositoryDoc, puis renvoyez-le.
Traiter les éléments supprimés

Cet extrait montre comment déterminer si un élément existe et le supprimer s'il n'existe pas.

ListTraversalSample.java
String resourceName = item.getName();
int documentId = Integer.parseInt(resourceName);

if (!documents.containsKey(documentId)) {
  // Document no longer exists -- delete it
  log.info(() -> String.format("Deleting document %s", item.getName()));
  return ApiOperations.deleteItem(resourceName);
}
Traiter les éléments non modifiés

Interrogez la file d'attente d'indexation pour traiter les éléments non modifiés.

ListTraversalSample.java
String currentHash = this.calculateMetadataHash(documentId);
if (this.canSkipIndexing(item, currentHash)) {
  // Document neither modified nor deleted, ack the push
  log.info(() -> String.format("Document %s not modified", item.getName()));
  PushItem pushItem = new PushItem().setType("NOT_MODIFIED");
  return new PushItems.Builder().addPushItem(resourceName, pushItem).build();
}

L'exemple utilise un hachage pour détecter les modifications.

ListTraversalSample.java
/**
 * Checks to see if an item is already up to date
 *
 * @param previousItem Polled item
 * @param currentHash  Metadata hash of the current github object
 * @return PushItem operation
 */
private boolean canSkipIndexing(Item previousItem, String currentHash) {
  if (previousItem.getStatus() == null || previousItem.getMetadata() == null) {
    return false;
  }
  String status = previousItem.getStatus().getCode();
  String previousHash = previousItem.getMetadata().getHash();
  return "ACCEPTED".equals(status)
      && previousHash != null
      && previousHash.equals(currentHash);
}
Définir les autorisations pour un élément

Les dépôts utilisent des listes de contrôle d'accès (LCA) pour identifier les utilisateurs ou les groupes ayant accès à un élément. Une LCA liste les ID des utilisateurs ou groupes autorisés.

Pour vous assurer que les utilisateurs ne voient que les résultats de recherche auxquels ils sont autorisés à accéder, vous devez répliquer les LCA de votre dépôt. Incluez la LCA lors de l'indexation d'un élément afin que Google Cloud Search puisse fournir le niveau d'accès approprié.

Le SDK Content Connector inclut des classes et des méthodes permettant de modéliser les LCA de la plupart des dépôts. Analysez les LCA de votre dépôt et créez des LCA correspondantes pour Cloud Search lors de l'indexation. La modélisation des LCA complexes, comme celles qui utilisent l'héritage, nécessite une planification minutieuse. Pour en savoir plus, consultez LCA Cloud Search.

Utilisez la classe Acl.Builder pour définir l'accès. Cet extrait de l'exemple de parcours complet permet à tous les utilisateurs du domaine (getCustomerPrincipal()) de lire tous les éléments (setReaders()) :

FullTraversalSample.java
// Make the document publicly readable within the domain
Acl acl = new Acl.Builder()
    .setReaders(Collections.singletonList(Acl.getCustomerPrincipal()))
    .build();

Pour modéliser correctement les LCA de dépôt, en particulier ceux qui utilisent des modèles d'héritage, vous devez consulter les informations sur les LCA de Cloud Search.

Définir les métadonnées d'un élément
ListTraversalSample.java
// Url is required. Use google.com as a placeholder for this sample.
String viewUrl = "https://www.google.com";

// Version is required, set to current timestamp.
byte[] version = Longs.toByteArray(System.currentTimeMillis());

// Set metadata hash so queue can detect changes
String metadataHash = this.calculateMetadataHash(documentId);

// Using the SDK item builder class to create the document with
// appropriate attributes. This can be expanded to include metadata
// fields etc.
Item item = IndexingItemBuilder.fromConfiguration(Integer.toString(documentId))
    .setItemType(IndexingItemBuilder.ItemType.CONTENT_ITEM)
    .setAcl(acl)
    .setSourceRepositoryUrl(IndexingItemBuilder.FieldOrValue.withValue(viewUrl))
    .setVersion(version)
    .setHash(metadataHash)
    .build();
Créer un élément indexable
ListTraversalSample.java
// For this sample, content is just plain text
String content = String.format("Hello world from sample doc %d", documentId);
ByteArrayContent byteContent = ByteArrayContent.fromString("text/plain", content);

// Create the fully formed document
RepositoryDoc doc = new RepositoryDoc.Builder()
    .setItem(item)
    .setContent(byteContent, IndexingService.ContentFormat.TEXT)
    .build();

Utilisez la méthode setRequestMode() de la classe RepositoryDoc.Builder pour définir la requête d'indexation sur ASYNCHRONOUS ou SYNCHRONOUS :

ASYNCHRONOUS
Ce mode présente une latence plus longue entre l'indexation et la diffusion, mais autorise un quota de débit plus important. Utilisez le mode asynchrone pour l'indexation initiale (remplissage) d'un dépôt entier.
SYNCHRONOUS
Ce mode présente une latence plus courte entre l'indexation et la diffusion, mais un quota de débit plus faible. Utilisez le mode synchrone pour indexer les mises à jour et les modifications apportées au dépôt. Si vous n'indiquez pas de mode de requête, la valeur SYNCHRONOUS est attribuée par défaut.

Étapes suivantes

Voici quelques étapes que vous pouvez également suivre :

Créer un connecteur de balayage de graphe à partir d'un modèle de classe

La file d'attente d'indexation Cloud Search contient les ID et les valeurs de hachage (facultatives) de chaque élément du dépôt. Un connecteur de balayage de graphe place les ID d'élément dans la file d'attente d'indexation Google Cloud Search, puis les récupère un par un en vue d'indexer les éléments. Google Cloud Search gère les files d'attente et compare leur contenu afin de déterminer l'état des éléments (si un élément a été supprimé du dépôt, par exemple). Pour en savoir plus sur la file d'attente d'indexation Cloud Search, consultez File d'attente d'indexation de Google Cloud Search.

Pendant l'indexation, le contenu des éléments est récupéré dans le dépôt de données et les ID des éléments enfants sont placés dans la file d'attente. Le connecteur traite de manière récursive les ID parents et enfants jusqu'à ce que tous les éléments aient été traités.

Implémenter le point d'entrée du connecteur

Le point d'entrée d'un connecteur est la méthode main(). Cette méthode crée une instance de la classe Application et appelle sa méthode start() pour exécuter le connecteur.

Avant d'appeler application.start(), utilisez la classe IndexingApplication.Builder pour instancier le modèle ListingConnector. Le modèle ListingConnector accepte un objet Repository dont vous utiliserez les méthodes.

Implémenter l'interface Repository

Remplacez init(), getIds(), getDoc() et, éventuellement, getChanges() ou close().

Effectuer un balayage de graphe

Remplacez getIds() pour récupérer les ID initiaux et getDoc() pour gérer les éléments et envoyer les ID enfants dans la file d'attente.

Transmettre les ID et valeurs de hachage des éléments
GraphTraversalSample.java
PushItems.Builder allIds = new PushItems.Builder();
PushItem item = new PushItem();
allIds.addPushItem("root", item);
Récupérer et traiter chaque élément
  1. Vérifiez si l'ID existe dans le dépôt. Si ce n'est pas le cas, supprimez-le.
  2. Pour les éléments existants, définissez les autorisations et les métadonnées, puis combinez-les dans un RepositoryDoc.
  3. Transférez les ID enfants vers la file d'attente d'indexation.
  4. Renvoyez RepositoryDoc.
Traiter les éléments supprimés
GraphTraversalSample.java
String resourceName = item.getName();
if (documentExists(resourceName)) {
  return buildDocumentAndChildren(resourceName);
}
// Document doesn't exist, delete it
log.info(() -> String.format("Deleting document %s", resourceName));
return ApiOperations.deleteItem(resourceName);
Définir les métadonnées et créer l'élément
GraphTraversalSample.java
// Url is required. Use google.com as a placeholder for this sample.
String viewUrl = "https://www.google.com";

// Version is required, set to current timestamp.
byte[] version = Longs.toByteArray(System.currentTimeMillis());

// Using the SDK item builder class to create the document with
// appropriate attributes. This can be expanded to include metadata
// fields etc.
Item item = IndexingItemBuilder.fromConfiguration(documentId)
    .setItemType(IndexingItemBuilder.ItemType.CONTENT_ITEM)
    .setAcl(acl)
    .setSourceRepositoryUrl(IndexingItemBuilder.FieldOrValue.withValue(viewUrl))
    .setVersion(version)
    .build();
GraphTraversalSample.java
// For this sample, content is just plain text
String content = String.format("Hello world from sample doc %s", documentId);
ByteArrayContent byteContent = ByteArrayContent.fromString("text/plain", content);

RepositoryDoc.Builder docBuilder = new RepositoryDoc.Builder()
    .setItem(item)
    .setContent(byteContent, IndexingService.ContentFormat.TEXT);
Placer les ID des éléments enfants dans la file d'attente d'indexation
GraphTraversalSample.java
// Queue the child nodes to visit after indexing this document
Set<String> childIds = getChildItemNames(documentId);
for (String id : childIds) {
  log.info(() -> String.format("Pushing child node %s", id));
  PushItem pushItem = new PushItem();
  docBuilder.addChildId(id, pushItem);
}

RepositoryDoc doc = docBuilder.build();

Créer un connecteur de contenu à l'aide de l'API REST

Les sections suivantes expliquent comment créer un connecteur de contenu à l'aide de l'API REST.

Déterminer votre stratégie de balayage

Les stratégies (complète, liste et graphique) sont conceptuellement identiques à celles du SDK. Implémentez la stratégie choisie à l'aide de l'API REST.

Déployer votre stratégie de balayage et vos éléments d'index

Enregistrez votre schéma, puis remplissez l'index à l'aide de l'une des méthodes suivantes :

  1. (Facultatif) items.upload pour les fichiers de plus de 100 Kio.
  2. (Facultatif) media.upload pour les fichiers multimédias.

  3. items.index pour indexer l'élément.

    Exemple de demande d'indexation :

    {
  "name": "datasource/<data_source_id>/items/titanic",
  "acl": {
    "readers": [
      {
        "gsuitePrincipal": {
          "gsuiteDomain": true
        }
      }
    ]
  },
  "metadata": {
    "title": "Titanic",
    "viewUrl": "http://www.imdb.com/title/tt2234155/",
    "objectType": "movie"
  },
  "structuredData": {
    "object": {
      "properties": [
        {
          "name": "movieTitle",
          "textValues": { "values": ["Titanic"] }
        }
      ]
    }
  },
  "content": {
    "inlineContent": "A seventeen-year-old aristocrat falls in love...",
    "contentFormat": "TEXT"
  },
  "version": "01",
  "itemType": "CONTENT_ITEM"
}

  4. (Facultatif) Utilisez items.get pour vérifier l'indexation.

Gérer les modifications du dépôt

Réindexez régulièrement l'intégralité du dépôt pour une indexation complète. Pour le balayage de liste ou de graphique, utilisez la file d'attente d'indexation Google Cloud pour suivre les modifications et n'indexer que ce qui a changé. Utilisez items.push pour ajouter des éléments à la file d'attente.