Cómo buscar recursos en Knowledge Catalog

La búsqueda de Knowledge Catalog (anteriormente, Dataplex Universal Catalog) te permite descubrir recursos en toda tu organización con la ayuda de la búsqueda en lenguaje natural con coincidencias semánticas, la búsqueda por palabras clave y una sintaxis de búsqueda extensa.

Casos de uso

En la siguiente lista, se describen casos de uso de la búsqueda comunes, junto con descripciones y ejemplos de búsquedas:

  • Búsqueda de activos segmentada: Busca un activo específico con palabras clave relacionadas con el nombre, las columnas o la descripción del activo.

    Consultas de ejemplo

    • retail_transactions_2026
    • customer_id
    • column:customer_id

  • Descubrimiento de datos amplio: Identifica recursos relevantes en toda tu organización con consultas de lenguaje natural o palabras clave abiertas.

    Consultas de ejemplo

    • quarterly financial reports
    • ad campaign click through rates tables
    • server health metrics
    • audit logs system=bigquery

  • Recuperación de recursos con alcance para flujos de trabajo: Enumera los recursos dentro de un contenedor específico, como un proyecto, o con propiedades específicas, como el tipo o el sistema. Este enfoque se usa con frecuencia para los flujos de trabajo programáticos y basados en agentes.

    Consultas de ejemplo

    • type=table projectid:banking-prod aspect:classification.tier=PII
    • system=spanner projectid:inventory-service (parent=marketing_analytics OR parent=finance_analytics)

Tienes las siguientes opciones para acceder a la búsqueda en Knowledge Catalog:

Cómo funciona

La Búsqueda indexa automáticamente todo el contexto de los recursos de datos que se mantienen en Knowledge Catalog. Estas son algunas de ellas:

  • Metadatos que se transfieren automáticamente desde Google Cloud fuentes de datos, como BigQuery y Cloud SQL
  • Contexto para los recursos que transfieres a través de conectores e integraciones
  • Contexto adicional que creas para los recursos (por ejemplo, para representar el contexto empresarial o describir la semántica de los datos) y que se captura en forma de aspectos o términos comerciales vinculados

Cuando procesa tu búsqueda, Search aplica una combinación de concordancia semántica y de palabras clave. En la siguiente tabla, se describen los tipos de búsquedas que puedes usar con la búsqueda de Knowledge Catalog, junto con descripciones y ejemplos de búsquedas:

Tipo de consulta Uso Ejemplos
Palabra clave única Para la coincidencia exacta y de subcadenas en los elementos de metadatos, como el nombre, la descripción y el esquema del recurso prd_fin_invoices_fct_v02
Palabras clave parciales y fragmentos tokenizados Coincide con subcadenas en el contenido de los metadatos y encuentra recursos incluso con términos abreviados, palabras separadas o variaciones de nombres. fin transactions 2026 (coincide con prd_fin_transactions_fy2026_raw)
Consultas en lenguaje natural Utiliza la correlación semántica sin requerir coincidencias exactas de nombres o columnas. customer churn prediction features
Predicados estructurados Combina consultas de texto libre con filtros de predicado explícitos para reducir los resultados de la búsqueda. audit logs system=bigquery
Sintaxis extendida Para una búsqueda precisa, reducida a un alcance específico. La sintaxis extendida se usa con mayor frecuencia en casos de uso programáticos y de agentes. Para obtener más información, consulta Sintaxis de búsqueda. (system:bigquery OR system:spanner) AND column:credit_card_number aspect:classification.tier=PII -projectid:sandbox-project

Alcance de la búsqueda

Los resultados de la búsqueda en Knowledge Catalog respetan los permisos que tienes sobre los recursos correspondientes en los sistemas de origen.

Por ejemplo, si tienes acceso de lectura de metadatos de BigQuery a un objeto, ese objeto aparecerá en los resultados de la búsqueda de Knowledge Catalog. Si tienes acceso a una tabla de BigQuery, pero no al conjunto de datos que contiene esa tabla, la tabla seguirá apareciendo como se espera en la búsqueda de Knowledge Catalog.

De forma predeterminada, la búsqueda se limita a tu organización. Los resultados incluyen solo los recursos de la misma organización que el proyecto en el que realizas la búsqueda.

Los resultados de la búsqueda solo incluyen los recursos que pertenecen al mismo perímetro de Controles del servicio de VPC que el proyecto en el que se realiza la búsqueda. Cuando usas la consola deGoogle Cloud , este es el proyecto que se selecciona en la consola.

Para ampliar el alcance de los resultados de la búsqueda más allá de los recursos dentro del perímetro de los Controles del servicio de VPC de tu proyecto, usa las reglas de entrada y salida de los Controles del servicio de VPC. Estas reglas facilitan el intercambio de datos privados y eficientes en toda tu organización. Puedes configurar reglas de entrada y salida con la consola deGoogle Cloud o a través de archivos JSON o YAML. Consulta el siguiente ejemplo de YAML y la documentación de los Controles del servicio de VPC para adaptar la regla a tus requisitos específicos.

egressPolicies:
  - egressFrom:
      identityType: ANY_USER_ACCOUNT
    egressTo:
      # Specify which resources should be present in the search results. In this example,
      # BigQuery.
      operations:
      - methodSelectors:
        - method: '*'
        serviceName: bigquery.googleapis.com
      # Specify project ids under which the search is performed.
      resources:
      - projects/SEARCH_PROJECT_ID
ingressPolicies:
  - ingressFrom:
      identityType: ANY_USER_ACCOUNT
      sources:
      - accessLevel: '*'
    ingressTo:
      # Specify which resources should be present in the search results. In this example,
      # BigQuery.
      operations:
      - methodSelectors:
        - method: '*'
        serviceName: bigquery.googleapis.com
      # Specify project ids to expose in search results.
      resources:
      - projects/INGRESS_PROJECT_ID

Para obtener más información sobre los roles de Identity and Access Management que necesitas usar para la búsqueda en Knowledge Catalog, consulta Roles de IAM de Knowledge Catalog.

Aísla los resultados de la búsqueda por entorno con los Controles del servicio de VPC

Para aislar los resultados de la búsqueda del Knowledge Catalog entre entornos, como el de desarrollo, prueba y producción, configura perímetros de Controles del servicio de VPC independientes para cada entorno. Asigna tanto los proyectos que contienen los recursos de datos como los proyectos que se usan para realizar búsquedas al perímetro del entorno correspondiente. Las búsquedas que se realizan desde un proyecto dentro de un perímetro específico solo mostrarán resultados de los activos que también se encuentran dentro de ese mismo perímetro.

Limitaciones de recuperación en la búsqueda

Las búsquedas en Knowledge Catalog no garantizan una recuperación completa, lo que significa que es posible que la búsqueda no devuelva resultados que coincidan con tu búsqueda. Además, los resultados devueltos (y los que no se devuelven) pueden variar si repites las búsquedas.

Para consultar todos los metadatos de Knowledge Catalog, puedes exportarlos a Cloud Storage y, luego, consultarlos desde BigQuery. Para obtener más información, consulta Exporta metadatos.

Antes de comenzar

Antes de realizar la búsqueda, asegúrate de que se te hayan otorgado los roles necesarios y de haber habilitado la API necesaria.

Roles obligatorios

Para obtener los permisos que necesitas para buscar entradas y acceder a los resultados de la búsqueda en Knowledge Catalog, pídele a tu administrador que te otorgue los siguientes roles de IAM:

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Los permisos en los resultados de la búsqueda se verifican de forma independiente del proyecto seleccionado.

El alcance de los resultados de la búsqueda en Knowledge Catalog se define según tu rol. Para buscar un activo en Knowledge Catalog, debes tener permisos para acceder al recurso correspondiente en el sistema fuente. Para obtener más información, consulta la sección Alcance de la búsqueda de este documento.

Por ejemplo, para buscar conjuntos de datos, tablas, vistas y modelos de BigQuery, necesitas los permisos correspondientes para esas entradas. Para obtener más información, consulta Permisos de BigQuery.

En la siguiente lista, se describen los permisos mínimos requeridos:

  • Para buscar una tabla, necesitas el permiso bigquery.tables.get para esa tabla.
  • Para buscar un conjunto de datos, necesitas el permiso bigquery.datasets.get para ese conjunto de datos.

Como otro ejemplo, para buscar instancias, bases de datos, esquemas, tablas y vistas de Cloud SQL, necesitas los permisos correspondientes en esas entradas. Para obtener más información, consulta Roles y permisos de Cloud SQL.

Habilita la API

Habilitar la API de Dataplex

Roles necesarios para habilitar las APIs

Para habilitar APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtener este permiso a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén más información para otorgar roles.

Habilitar la API

Buscar recursos

Console

Para buscar recursos, sigue estos pasos:

  1. En la consola de Google Cloud , ve a la página Búsqueda de Knowledge Catalog.

    Ir a Búsqueda

  2. Si ves el mensaje del botón Probar la búsqueda en lenguaje natural, haz clic en él. De forma predeterminada, se selecciona la búsqueda en lenguaje natural.

  3. En el campo Encuentra recursos en todos los proyectos con lenguaje natural, ingresa tu consulta y, luego, haz clic en Intro.

  4. Para definir mejor tu búsqueda, haz clic en Filtros. Para ver la lista de filtros disponibles, consulta Filtros.

  5. Para ver más información sobre el recurso buscado, haz clic en su nombre en los resultados de la búsqueda. Se abrirá la página de detalles de la entrada.

Google Cloud CLI

Para buscar recursos, usa el comando gcloud dataplex entries search:

gcloud dataplex entries search 'foo' \
  --project=PROJECT_ID \
  [--semantic-search]

Reemplaza PROJECT_ID por el ID del proyecto Google Cloud .

C#

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para C# que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog C#.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

using Google.Api.Gax;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dataplex.V1;
using System;

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for SearchEntries</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void SearchEntriesRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        SearchEntriesRequest request = new SearchEntriesRequest
        {
            LocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
            Query = "",
            OrderBy = "",
            Scope = "",
            SemanticSearch = false,
        };
        // Make the request
        PagedEnumerable<SearchEntriesResponse, SearchEntriesResult> response = catalogServiceClient.SearchEntries(request);

        // Iterate over all response items, lazily performing RPCs as required
        foreach (SearchEntriesResult item in response)
        {
            // Do something with each item
            Console.WriteLine(item);
        }

        // Or iterate over pages (of server-defined size), performing one RPC per page
        foreach (SearchEntriesResponse page in response.AsRawResponses())
        {
            // Do something with each page of items
            Console.WriteLine("A page of results:");
            foreach (SearchEntriesResult item in page)
            {
                // Do something with each item
                Console.WriteLine(item);
            }
        }

        // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
        int pageSize = 10;
        Page<SearchEntriesResult> singlePage = response.ReadPage(pageSize);
        // Do something with the page of items
        Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
        foreach (SearchEntriesResult item in singlePage)
        {
            // Do something with each item
            Console.WriteLine(item);
        }
        // Store the pageToken, for when the next page is required.
        string nextPageToken = singlePage.NextPageToken;
    }
}

Go

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog Go.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 


//go:build examples

package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewCatalogClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.SearchEntriesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#SearchEntriesRequest.
	}
	it := c.SearchEntries(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*dataplexpb.SearchEntriesResponse)
	}
}

Java

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog Java.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

import com.google.cloud.dataplex.v1.CatalogServiceClient;
import com.google.cloud.dataplex.v1.LocationName;
import com.google.cloud.dataplex.v1.SearchEntriesRequest;
import com.google.cloud.dataplex.v1.SearchEntriesResult;

public class SyncSearchEntries {

  public static void main(String[] args) throws Exception {
    syncSearchEntries();
  }

  public static void syncSearchEntries() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (CatalogServiceClient catalogServiceClient = CatalogServiceClient.create()) {
      SearchEntriesRequest request =
          SearchEntriesRequest.newBuilder()
              .setName(LocationName.of("[PROJECT]", "[LOCATION]").toString())
              .setQuery("query107944136")
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setOrderBy("orderBy-1207110587")
              .setScope("scope109264468")
              .setSemanticSearch(true)
              .build();
      for (SearchEntriesResult element : catalogServiceClient.searchEntries(request).iterateAll()) {
        // doThingsWith(element);
      }
    }
  }
}

Node.js

Node.js

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog Node.js.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. The project to which the request should be attributed in the
 *  following form: `projects/{project}/locations/global`.
 */
// const name = 'abc123'
/**
 *  Required. The query against which entries in scope should be matched.
 *  The query syntax is defined in Search syntax for Dataplex Universal
 *  Catalog (https://cloud.google.com/dataplex/docs/search-syntax).
 */
// const query = 'abc123'
/**
 *  Optional. Number of results in the search page. If <=0, then defaults
 *  to 10. Max limit for page_size is 1000. Throws an invalid argument for
 *  page_size > 1000.
 */
// const pageSize = 1234
/**
 *  Optional. Page token received from a previous `SearchEntries` call. Provide
 *  this to retrieve the subsequent page.
 */
// const pageToken = 'abc123'
/**
 *  Optional. Specifies the ordering of results.
 *  Supported values are:
 *  * `relevance`
 *  * `last_modified_timestamp`
 *  * `last_modified_timestamp asc`
 */
// const orderBy = 'abc123'
/**
 *  Optional. The scope under which the search should be operating. It must
 *  either be `organizations/<org_id>` or `projects/<project_ref>`. If it is
 *  unspecified, it defaults to the organization where the project provided in
 *  `name` is located.
 */
// const scope = 'abc123'
/**
 *  Optional. Specifies whether the search should understand the meaning and
 *  intent behind the query, rather than just matching keywords.
 */
// const semanticSearch = true

// Imports the Dataplex library
const {CatalogServiceClient} = require('@google-cloud/dataplex').v1;

// Instantiates a client
const dataplexClient = new CatalogServiceClient();

async function callSearchEntries() {
  // Construct request
  const request = {
    name,
    query,
  };

  // Run request
  const iterable = dataplexClient.searchEntriesAsync(request);
  for await (const response of iterable) {
      console.log(response);
  }
}

callSearchEntries();

PHP

PHP

Antes de probar este ejemplo, sigue las instrucciones de configuración para PHP que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog PHP.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Cloud\Dataplex\V1\Client\CatalogServiceClient;
use Google\Cloud\Dataplex\V1\SearchEntriesRequest;
use Google\Cloud\Dataplex\V1\SearchEntriesResult;

/**
 * Searches for Entries matching the given query and scope.
 *
 * @param string $formattedName The project to which the request should be attributed in the
 *                              following form: `projects/{project}/locations/global`. Please see
 *                              {@see CatalogServiceClient::locationName()} for help formatting this field.
 * @param string $query         The query against which entries in scope should be matched.
 *                              The query syntax is defined in [Search syntax for Dataplex Universal
 *                              Catalog](https://cloud.google.com/dataplex/docs/search-syntax).
 */
function search_entries_sample(string $formattedName, string $query): void
{
    // Create a client.
    $catalogServiceClient = new CatalogServiceClient();

    // Prepare the request message.
    $request = (new SearchEntriesRequest())
        ->setName($formattedName)
        ->setQuery($query);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $catalogServiceClient->searchEntries($request);

        /** @var SearchEntriesResult $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = CatalogServiceClient::locationName('[PROJECT]', '[LOCATION]');
    $query = '[QUERY]';

    search_entries_sample($formattedName, $query);
}

Python

Python

Antes de probar este ejemplo, sigue las instrucciones de configuración para Python que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog Python.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_search_entries():
    # Create a client
    client = dataplex_v1.CatalogServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.SearchEntriesRequest(
        name="name_value",
        query="query_value",
    )

    # Make the request
    page_result = client.search_entries(request=request)

    # Handle the response
    for response in page_result:
        print(response)

Ruby

Ruby

Antes de probar este ejemplo, sigue las instrucciones de configuración para Ruby que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog Ruby.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

require "google/cloud/dataplex/v1"

##
# Snippet for the search_entries call in the CatalogService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::CatalogService::Client#search_entries.
#
def search_entries
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::CatalogService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::SearchEntriesRequest.new

  # Call the search_entries method.
  result = client.search_entries request

  # The returned object is of type Gapic::PagedEnumerable. You can iterate
  # over elements, and API calls will be issued to fetch pages as needed.
  result.each do |item|
    # Each element is of type ::Google::Cloud::Dataplex::V1::SearchEntriesResult.
    p item
  end
end

REST

Para buscar recursos, usa el método searchEntries con el parámetro semanticSearch establecido en true.

POST https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:searchEntries?query=foo&semanticSearch=true

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID de tu proyecto de Google Cloud .
  • LOCATION: Es la región en la que existe el proyecto (por ejemplo, us-central1).

Filtros

Los filtros te permiten acotar los resultados de la búsqueda.

Cuando proporcionas filtros en varias secciones, se evalúan con el operador lógico AND. Los resultados de la búsqueda contienen recursos que coinciden con al menos una condición de cada sección seleccionada. Por ejemplo, si seleccionas el sistema de BigQuery y el tipo de recurso del conjunto de datos, los resultados de la búsqueda incluirán conjuntos de datos de BigQuery, pero no conjuntos de datos de Vertex AI.

Si seleccionas varios filtros dentro de una misma sección, se evalúan con el operador lógico OR. Por ejemplo, si seleccionas el tipo de recurso de conjunto de datos y el tipo de recurso de tabla, los resultados de la búsqueda incluirán tanto conjuntos de datos como tablas.

Están disponibles los siguientes filtros:

  • Alcance: Busca en toda la organización (opción predeterminada), en el proyecto actual o solo en los recursos destacados. Para obtener más información, consulta la sección Alcance de la búsqueda de este documento.
  • Sistemas: El Google Cloud servicio al que pertenece el recurso, como BigQuery. El sistema de Knowledge Catalog contiene grupos de entradas.
  • Proyectos: Son los proyectos en los que se realizará la búsqueda.
  • Tipo: Es el tipo de recurso, como conexión de BigQuery, bucket de Cloud Storage o base de datos. Según el tipo de recurso, también puedes filtrar por subtipo, como el tipo de conexión o el dialecto de SQL.
  • Selecciona ubicaciones: Son las ubicaciones en las que se realizará la búsqueda.
  • Seleccionar conjuntos de datos: Los resultados de la búsqueda se limitan a los recursos de BigQuery que pertenecen a los conjuntos de datos de BigQuery seleccionados. En el campo Escribe para filtrar, ingresa el nombre del conjunto de datos.
  • Tipos de aspectos: Son los tipos de aspectos de Knowledge Catalog que se asocian con el recurso que buscas. Para filtrar por valores de aspecto, haz clic en Filtrar los valores de tipo de aspecto y, luego, selecciona los valores.

Cómo ver los detalles de un activo que se devolvió en la búsqueda

Console

Usa la búsqueda de Knowledge Catalog para ver los detalles de un recurso.

  1. Busca un recurso en Knowledge Catalog.

  2. En los resultados de la búsqueda, haz clic en el activo cuyos detalles deseas ver.

    Se abrirá la página de detalles de la entrada. La página incluye las siguientes secciones:

    • Detalles de la entrada: Incluye información como el tipo de entrada, el sistema, la plataforma, el nombre completo, la hora de creación, la hora de la última modificación, la descripción y los administradores.
    • Descripción general: Es una descripción general de la entrada, si está disponible.
    • Aspectos: Son los aspectos obligatorios y opcionales definidos para la entrada. Para obtener más información, consulta Categorías de aspectos.

gcloud

Comando gcloud dataplex entries lookup:

gcloud dataplex entries lookup ENTRY_ID \
  --entry-group=ENTRY_GROUP_ID \
  --location=LOCATION \
  --project=PROJECT_ID

Reemplaza lo siguiente:

  • ENTRY_ID: Es el ID de la entrada.
  • ENTRY_GROUP_ID: Es el ID del grupo de entradas.
  • LOCATION: Es la región en la que existe el proyecto.
  • PROJECT_ID: Es el ID del proyecto de Google Cloud .

C#

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para C# que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog C#.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

using Google.Cloud.Dataplex.V1;

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for LookupEntry</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void LookupEntryRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        LookupEntryRequest request = new LookupEntryRequest
        {
            Name = "",
            View = EntryView.Unspecified,
            AspectTypes = { "", },
            Paths = { "", },
            EntryAsEntryName = EntryName.FromProjectLocationEntryGroupEntry("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]"),
        };
        // Make the request
        Entry response = catalogServiceClient.LookupEntry(request);
    }
}

Go

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog Go.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 


//go:build examples

package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewCatalogClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.LookupEntryRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#LookupEntryRequest.
	}
	resp, err := c.LookupEntry(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog Java.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

import com.google.cloud.dataplex.v1.CatalogServiceClient;
import com.google.cloud.dataplex.v1.Entry;
import com.google.cloud.dataplex.v1.EntryName;
import com.google.cloud.dataplex.v1.EntryView;
import com.google.cloud.dataplex.v1.LookupEntryRequest;
import java.util.ArrayList;

public class SyncLookupEntry {

  public static void main(String[] args) throws Exception {
    syncLookupEntry();
  }

  public static void syncLookupEntry() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (CatalogServiceClient catalogServiceClient = CatalogServiceClient.create()) {
      LookupEntryRequest request =
          LookupEntryRequest.newBuilder()
              .setName("name3373707")
              .setView(EntryView.forNumber(0))
              .addAllAspectTypes(new ArrayList<String>())
              .addAllPaths(new ArrayList<String>())
              .setEntry(
                  EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]").toString())
              .build();
      Entry response = catalogServiceClient.lookupEntry(request);
    }
  }
}

Node.js

Node.js

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog Node.js.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. The project to which the request should be attributed in the
 *  following form: `projects/{project}/locations/{location}`.
 */
// const name = 'abc123'
/**
 *  Optional. View to control which parts of an entry the service should
 *  return.
 *  **Please check the limitations on returned aspects in the Entry view
 *  documentation. Amount of returned aspects depends on the selected Entry
 *  View.**
 */
// const view = {}
/**
 *  Optional. Limits the aspects returned to the provided aspect types.
 *  It only works for CUSTOM view.
 */
// const aspectTypes = ['abc','def']
/**
 *  Optional. Limits the aspects returned to those associated with the provided
 *  paths within the Entry. It only works for CUSTOM view.
 */
// const paths = ['abc','def']
/**
 *  Required. The resource name of the Entry:
 *  `projects/{project}/locations/{location}/entryGroups/{entry_group}/entries/{entry}`.
 */
// const entry = 'abc123'

// Imports the Dataplex library
const {CatalogServiceClient} = require('@google-cloud/dataplex').v1;

// Instantiates a client
const dataplexClient = new CatalogServiceClient();

async function callLookupEntry() {
  // Construct request
  const request = {
    name,
    entry,
  };

  // Run request
  const response = await dataplexClient.lookupEntry(request);
  console.log(response);
}

callLookupEntry();

PHP

PHP

Antes de probar este ejemplo, sigue las instrucciones de configuración para PHP que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog PHP.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

use Google\ApiCore\ApiException;
use Google\Cloud\Dataplex\V1\Client\CatalogServiceClient;
use Google\Cloud\Dataplex\V1\Entry;
use Google\Cloud\Dataplex\V1\LookupEntryRequest;

/**
 * Looks up an entry by name using the permission on the source system.
 *
 * @param string $name           The project to which the request should be attributed in the
 *                               following form: `projects/{project}/locations/{location}`.
 * @param string $formattedEntry The resource name of the Entry:
 *                               `projects/{project}/locations/{location}/entryGroups/{entry_group}/entries/{entry}`. Please see
 *                               {@see CatalogServiceClient::entryName()} for help formatting this field.
 */
function lookup_entry_sample(string $name, string $formattedEntry): void
{
    // Create a client.
    $catalogServiceClient = new CatalogServiceClient();

    // Prepare the request message.
    $request = (new LookupEntryRequest())
        ->setName($name)
        ->setEntry($formattedEntry);

    // Call the API and handle any network failures.
    try {
        /** @var Entry $response */
        $response = $catalogServiceClient->lookupEntry($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $name = '[NAME]';
    $formattedEntry = CatalogServiceClient::entryName(
        '[PROJECT]',
        '[LOCATION]',
        '[ENTRY_GROUP]',
        '[ENTRY]'
    );

    lookup_entry_sample($name, $formattedEntry);
}

Python

Python

Antes de probar este ejemplo, sigue las instrucciones de configuración para Python que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog Python.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_lookup_entry():
    # Create a client
    client = dataplex_v1.CatalogServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.LookupEntryRequest(
        name="name_value",
        entry="entry_value",
    )

    # Make the request
    response = client.lookup_entry(request=request)

    # Handle the response
    print(response)

Ruby

Ruby

Antes de probar este ejemplo, sigue las instrucciones de configuración para Ruby que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog Ruby.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

require "google/cloud/dataplex/v1"

##
# Snippet for the lookup_entry call in the CatalogService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::CatalogService::Client#lookup_entry.
#
def lookup_entry
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::CatalogService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::LookupEntryRequest.new

  # Call the lookup_entry method.
  result = client.lookup_entry request

  # The returned object is of type Google::Cloud::Dataplex::V1::Entry.
  p result
end

REST

Para ver los detalles de un activo, usa el método lookupEntry.

Knowledge Catalog proporciona un modo de búsqueda solo por palabras clave para la retrocompatibilidad, y el modo de búsqueda estándar admite la concordancia semántica y de palabras clave.

Te recomendamos que uses el modo de búsqueda estándar, a menos que se requiera la búsqueda solo por palabras clave para la retrocompatibilidad.

Filtros de búsqueda solo por palabras clave

En el caso de la búsqueda de palabras clave, los filtros se agrupan en las siguientes secciones:

  • Sistemas como BigQuery, Cloud SQL y otros. El sistema de Knowledge Catalog contiene entradas personalizadas.
  • En Aspectos, se enumeran todos los aspectos disponibles para ti. Para filtrar por valores de aspecto, haz clic en Filtrar los valores de aspecto y, luego, selecciona los valores.
  • En Proyecto, se enumeran todos los proyectos disponibles para ti.
  • Los alias de tipo son tipos de datos asociados a un tipo de entrada. Un tipo de entrada puede tener el nombre projects/test-project/locations/us/entryTypes/my-entry-type, pero puedes buscarlo con sus alias de tipo TABLE o DATABASE. Puedes establecer uno o más alias de tipo cuando creas o actualizas un tipo de entrada.
  • Los conjuntos de datos provienen de BigQuery.

Los filtros Sistemas, Alias de tipo, Proyecto y Conjuntos de datos se muestran según la búsqueda actual en el campo Buscar.

Para usar la búsqueda solo por palabras clave, haz lo siguiente:

Console

  1. Si estás en el modo de búsqueda en lenguaje natural, haz clic en Volver a la búsqueda por palabra clave.
  2. En el campo Encuentra recursos en todos los proyectos, ingresa tu búsqueda.

  3. Para definir mejor tu búsqueda, usa el panel Filtros.

    Para obtener la lista de filtros disponibles, consulta Filtros de búsqueda por palabra clave.

    Puedes agregar manualmente los siguientes filtros:

    • Agrega un filtro de proyecto: En Proyecto, haz clic en Agregar proyecto. Busca un proyecto específico, selecciónalo y, luego, haz clic en Abrir.
    • Agrega un filtro de tipo de aspecto: En Aspectos, haz clic en el menú Agregar más tipos de aspectos. Busca una plantilla específica, selecciónala y, luego, haz clic en Aceptar.

  4. Opcional: Además de los recursos disponibles para ti, puedes buscar recursos disponibles de forma pública en Google Cloud seleccionando Incluir conjuntos de datos públicos.

    Usa las siguientes sugerencias para crear una búsqueda:

    • Encierra tu expresión de búsqueda entre comillas si contiene espacios. Por ejemplo, "search terms".
    • Antepón NOT a una palabra clave para que coincida con la negación lógica del filtro keyword:term. También puedes usar los operadores booleanos AND y OR para combinar expresiones de búsqueda. Los operadores AND, OR y NOT no distinguen mayúsculas de minúsculas.

    Por ejemplo, NOT column:term enumera todas las columnas, excepto las que coinciden con el término especificado. Para obtener una lista de palabras clave y otros términos que puedes usar en una expresión de búsqueda de Knowledge Catalog, consulta Sintaxis de búsqueda.

gcloud

Para buscar recursos con el modo de búsqueda solo por palabras clave, usa el comando gcloud dataplex entries search y omite la marca --semantic-search, o bien usa la marca --no-semantic-search.

REST

Para buscar recursos con el modo de búsqueda solo por palabras clave, usa el método searchEntries con el parámetro de búsqueda semanticSearch establecido en false.

Limitaciones

La Búsqueda tiene las siguientes limitaciones:

  • Los recursos públicos no están dentro del alcance de la búsqueda en lenguaje natural.
  • Los aspectos adjuntos a los vínculos de entrada no se incluyen en el alcance de la búsqueda en lenguaje natural.

¿Qué sigue?