pulumi-gcp-kotlin/com.pulumi.gcp.discoveryengine.kotlin/SearchEngine

SearchEngine

class SearchEngine : KotlinCustomResource

Vertex AI Search and Conversation can be used to create a search engine or a chat application by connecting it with a datastore To get more information about SearchEngine, see:

Example Usage

Discoveryengine Searchengine Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const basic = new gcp.discoveryengine.DataStore("basic", {
    location: "global",
    dataStoreId: "example-datastore-id",
    displayName: "tf-test-structured-datastore",
    industryVertical: "GENERIC",
    contentConfig: "NO_CONTENT",
    solutionTypes: ["SOLUTION_TYPE_SEARCH"],
    createAdvancedSiteSearch: false,
});
const basicSearchEngine = new gcp.discoveryengine.SearchEngine("basic", {
    engineId: "example-engine-id",
    collectionId: "default_collection",
    location: basic.location,
    displayName: "Example Display Name",
    dataStoreIds: [basic.dataStoreId],
    searchEngineConfig: {},
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
basic = gcp.discoveryengine.DataStore("basic",
    location="global",
    data_store_id="example-datastore-id",
    display_name="tf-test-structured-datastore",
    industry_vertical="GENERIC",
    content_config="NO_CONTENT",
    solution_types=["SOLUTION_TYPE_SEARCH"],
    create_advanced_site_search=False)
basic_search_engine = gcp.discoveryengine.SearchEngine("basic",
    engine_id="example-engine-id",
    collection_id="default_collection",
    location=basic.location,
    display_name="Example Display Name",
    data_store_ids=[basic.data_store_id],
    search_engine_config={})
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var basic = new Gcp.DiscoveryEngine.DataStore("basic", new()
    {
        Location = "global",
        DataStoreId = "example-datastore-id",
        DisplayName = "tf-test-structured-datastore",
        IndustryVertical = "GENERIC",
        ContentConfig = "NO_CONTENT",
        SolutionTypes = new[]
        {
            "SOLUTION_TYPE_SEARCH",
        },
        CreateAdvancedSiteSearch = false,
    });
    var basicSearchEngine = new Gcp.DiscoveryEngine.SearchEngine("basic", new()
    {
        EngineId = "example-engine-id",
        CollectionId = "default_collection",
        Location = basic.Location,
        DisplayName = "Example Display Name",
        DataStoreIds = new[]
        {
            basic.DataStoreId,
        },
        SearchEngineConfig = null,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/discoveryengine"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		basic, err := discoveryengine.NewDataStore(ctx, "basic", &discoveryengine.DataStoreArgs{
			Location:         pulumi.String("global"),
			DataStoreId:      pulumi.String("example-datastore-id"),
			DisplayName:      pulumi.String("tf-test-structured-datastore"),
			IndustryVertical: pulumi.String("GENERIC"),
			ContentConfig:    pulumi.String("NO_CONTENT"),
			SolutionTypes: pulumi.StringArray{
				pulumi.String("SOLUTION_TYPE_SEARCH"),
			},
			CreateAdvancedSiteSearch: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		_, err = discoveryengine.NewSearchEngine(ctx, "basic", &discoveryengine.SearchEngineArgs{
			EngineId:     pulumi.String("example-engine-id"),
			CollectionId: pulumi.String("default_collection"),
			Location:     basic.Location,
			DisplayName:  pulumi.String("Example Display Name"),
			DataStoreIds: pulumi.StringArray{
				basic.DataStoreId,
			},
			SearchEngineConfig: nil,
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.discoveryengine.DataStore;
import com.pulumi.gcp.discoveryengine.DataStoreArgs;
import com.pulumi.gcp.discoveryengine.SearchEngine;
import com.pulumi.gcp.discoveryengine.SearchEngineArgs;
import com.pulumi.gcp.discoveryengine.inputs.SearchEngineSearchEngineConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var basic = new DataStore("basic", DataStoreArgs.builder()
            .location("global")
            .dataStoreId("example-datastore-id")
            .displayName("tf-test-structured-datastore")
            .industryVertical("GENERIC")
            .contentConfig("NO_CONTENT")
            .solutionTypes("SOLUTION_TYPE_SEARCH")
            .createAdvancedSiteSearch(false)
            .build());
        var basicSearchEngine = new SearchEngine("basicSearchEngine", SearchEngineArgs.builder()
            .engineId("example-engine-id")
            .collectionId("default_collection")
            .location(basic.location())
            .displayName("Example Display Name")
            .dataStoreIds(basic.dataStoreId())
            .searchEngineConfig()
            .build());
    }
}
Content copied to clipboard
resources:
  basic:
    type: gcp:discoveryengine:DataStore
    properties:
      location: global
      dataStoreId: example-datastore-id
      displayName: tf-test-structured-datastore
      industryVertical: GENERIC
      contentConfig: NO_CONTENT
      solutionTypes:
        - SOLUTION_TYPE_SEARCH
      createAdvancedSiteSearch: false
  basicSearchEngine:
    type: gcp:discoveryengine:SearchEngine
    name: basic
    properties:
      engineId: example-engine-id
      collectionId: default_collection
      location: ${basic.location}
      displayName: Example Display Name
      dataStoreIds:
        - ${basic.dataStoreId}
      searchEngineConfig: {}
Content copied to clipboard

Import

SearchEngine can be imported using any of these accepted formats:

  • projects/{{project}}/locations/{{location}}/collections/{{collection_id}}/engines/{{engine_id}}

  • {{project}}/{{location}}/{{collection_id}}/{{engine_id}}

  • {{location}}/{{collection_id}}/{{engine_id}} When using the pulumi import command, SearchEngine can be imported using one of the formats above. For example:

$ pulumi import gcp:discoveryengine/searchEngine:SearchEngine default projects/{{project}}/locations/{{location}}/collections/{{collection_id}}/engines/{{engine_id}}
Content copied to clipboard
$ pulumi import gcp:discoveryengine/searchEngine:SearchEngine default {{project}}/{{location}}/{{collection_id}}/{{engine_id}}
Content copied to clipboard
$ pulumi import gcp:discoveryengine/searchEngine:SearchEngine default {{location}}/{{collection_id}}/{{engine_id}}
Content copied to clipboard

Properties

Link copied to clipboard
val collectionId: Output<String>

The collection ID.

Link copied to clipboard
val commonConfig: Output<SearchEngineCommonConfig>?

Common config spec that specifies the metadata of the engine.

Link copied to clipboard
val createTime: Output<String>

Timestamp the Engine was created at.

Link copied to clipboard
val dataStoreIds: Output<List<String>>

The data stores associated with this engine. For SOLUTION_TYPE_SEARCH type of engines, they can only associate with at most one data store.

Link copied to clipboard
val displayName: Output<String>

Required. The display name of the engine. Should be human readable. UTF-8 encoded string with limit of 1024 characters.

Link copied to clipboard
val engineId: Output<String>

Unique ID to use for Search Engine App.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val industryVertical: Output<String>?

The industry vertical that the engine registers. The restriction of the Engine industry vertical is based on DataStore: If unspecified, default to GENERIC. Vertical on Engine has to match vertical of the DataStore liniked to the engine. Default value: "GENERIC" Possible values: "GENERIC", "MEDIA"

Link copied to clipboard
val location: Output<String>

Location.

Link copied to clipboard
val name: Output<String>

The unique full resource name of the search engine. Values are of the format projects/{project}/locations/{location}/collections/{collection_id}/engines/{engine_id}. This field must be a UTF-8 encoded string with a length limit of 1024 characters.

Link copied to clipboard
val project: Output<String>
Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val searchEngineConfig: Output<SearchEngineSearchEngineConfig>

Configurations for a Search Engine. Structure is documented below.

Link copied to clipboard
val updateTime: Output<String>

Timestamp the Engine was last updated.

Link copied to clipboard
val urn: Output<String>