Esta página se ha traducido con Cloud Translation API.

Gestionar aspectos y enriquecer metadatos

Los metadatos son fundamentales para organizar y comprender tus recursos de datos. Por ejemplo, los sectores regulados deben proteger la información personal identificable (IPI), como nombres, direcciones y números de documentos de identificación oficiales. Estos datos pueden aparecer en numerosas instancias en sistemas de datos distribuidos. Dataplex Universal Catalog puede ayudarte a descubrir y catalogar rápidamente tus recursos de datos distribuidos. Después, puede clasificar los datos como IPI.

Si enriquece las entradas de datos con contexto significativo, puede hacer que sus datos sean más fáciles de descubrir y más útiles. Dataplex Universal Catalog proporciona contexto de las siguientes formas:

Tipo de aspecto: una plantilla JSON que define datos relacionados. Por ejemplo, en el caso de la información de cumplimiento, puede tener la clasificación de IPI y el cumplimiento del RGPD.
Aspecto: una instancia de un tipo de aspecto. Por ejemplo, {"pii_classification": "confidential", "gdpr_compliant": true}. Puedes aplicar un aspecto a una tabla completa o a una columna de una tabla.

Una vez que haya clasificado los datos, podrá aplicarles políticas de calidad o de acceso.

Para obtener más información, consulta el artículo Acerca de la gestión de metadatos en Dataplex Universal Catalog.

Aspectos

Los aspectos te permiten captar metadatos en las entradas para proporcionar un contexto significativo. Puedes usar aspectos para almacenar lo siguiente:

Metadatos empresariales: información que proporciona contexto empresarial, como la clasificación de datos.
Metadatos técnicos: detalles técnicos sobre el recurso de datos, como su esquema.
Metadatos derivados de datos: información generada a partir de los datos en sí, como estadísticas de una tabla de BigQuery.

Los aspectos se consideran partes del recurso de entrada y no recursos independientes. Cuando modificas un aspecto, se modifica la entrada que lo contiene.

Puedes especificar aspectos a nivel de entrada para describir una entrada o a nivel de columna para describir una columna de una entrada.

Cada aspecto es una instancia de un tipo de aspecto. Un tipo de aspecto define una plantilla para sus aspectos. Cada tipo de aspecto contiene un conjunto de campos. Cuando creas aspectos, debes proporcionar valores para esos campos.

En una entrada determinada, solo puede haber un aspecto asociado a la entrada por tipo de aspecto. Puede haber varios aspectos asociados a las columnas de entrada por tipo de aspecto.

Google Cloud

Categorías de aspectos

Los aspectos se clasifican de la siguiente manera:

Aspectos obligatorios: aspectos que son obligatorios al crear una entrada. Estos aspectos se definen mediante el tipo de entrada de una entrada determinada. Todas las entradas pertenecientes a un tipo de entrada deben tener siempre todos los aspectos obligatorios definidos por ese tipo de entrada.

Dataplex Universal Catalog gestiona los aspectos necesarios (por ejemplo, el esquema) de las entradas del sistema.

Ten en cuenta lo siguiente:
- Solo puedes asociar aspectos obligatorios a entradas, no a las columnas de una entrada.
- No puedes eliminar los aspectos obligatorios de una entrada.
- Puedes leer los aspectos necesarios de las entradas del sistema, pero no modificarlas.
- Los aspectos de datos no pueden ser aspectos obligatorios.
Aspectos opcionales: puede asociar aspectos opcionales a entradas o a columnas de entrada. Puede rellenar los aspectos opcionales en el momento de crear la entrada o más adelante actualizándola.

Puedes eliminar aspectos opcionales después de que se hayan rellenado.

Aspectos de los datos

Los aspectos pueden contener información derivada de los datos, como los resultados de un perfil de datos o consultas de ejemplo. Se denominan aspectos de los datos.

Tipos de aspectos

Los tipos de aspectos son recursos reutilizables que proporcionan plantillas para aspectos.

Categorías de tipos de aspectos

Los tipos de aspectos se clasifican en tipos de aspectos personalizados y de sistema.

Tipos de aspecto personalizados

Los tipos de aspectos que creas en Dataplex Universal Catalog se denominan tipos de aspectos personalizados.

Los tipos de aspecto personalizados pueden ser globales o regionales. Puede crear tipos de aspectos personalizados en una ubicación regional específica (por ejemplo, us-central1) o como recurso global. La ubicación de un tipo de aspecto influye en el ámbito de su aplicabilidad y determina con qué entradas se puede usar:

Tipos de aspectos globales: se pueden usar para crear aspectos de entradas de cualquier región. Elige un tipo de aspecto global si necesitas aplicar la misma estructura a las entradas de varias regiones, ya que solo tienes que definirla una vez. Como la definición de un tipo de aspecto global se replica en todas las regiones, puede que esta opción no sea adecuada si el esquema del tipo de aspecto contiene información sensible o si se requiere una residencia de datos estricta para todos los componentes de metadatos.
Tipos de aspectos regionales: solo se pueden usar para crear aspectos de entradas que se encuentren en la misma región que el tipo de aspecto. Por ejemplo, un tipo de aspecto creado en us-central1 solo se puede usar con entradas de us-central1. Elige una ubicación regional si un tipo de aspecto solo es relevante para las entradas de una región específica o para asegurarte de que la definición del tipo de aspecto se encuentra en la región seleccionada, lo que puede ayudarte a cumplir los requisitos de soberanía y cumplimiento de los datos. Si usas tipos de aspectos regionales, pero necesitas la misma estructura en varias regiones, debes crear y gestionar definiciones de tipos de aspectos independientes en cada región.

Para obtener más información, consulta Restricciones de proyectos y ubicaciones.

Tipos de aspecto del sistema

Los tipos de aspectos que proporciona, usa y gestiona Dataplex Universal Catalog se denominan tipos de aspectos del sistema. Los tipos de aspectos del sistema siempre son globales, por lo que se pueden usar en cualquier región. Los tipos de aspectos del sistema se almacenan en un proyecto gestionado por Google con el número 655216118709. Por ejemplo, projects/655216118709/locations/global/aspectTypes/schema.

Cada tipo de aspecto definido por el sistema y cada tipo de entrada definido por el sistema tienen sus propios permisos de gestión de identidades y accesos. Para obtener más información, consulta Permisos de gestión de identidades y accesos para tipos de aspectos del sistema y tipos de entradas.

Los tipos de aspectos del sistema se clasifican en reutilizables y restringidos. En la siguiente tabla se describen las categorías de tipos de aspectos del sistema y la lista de tipos de aspectos que proporciona Dataplex Universal Catalog para cada una de las categorías:

Categoría del tipo de aspecto del sistema	Descripción	Tipos de aspectos que proporciona Dataplex Universal Catalog
Tipo de aspecto del sistema reutilizable	Puedes usar estos tipos de aspectos para crear o modificar aspectos.	`contacts` `data-profile` `data-quality-scorecard` `generic` `overview` `schema` `usage`
Tipo de aspecto del sistema restringido	Dataplex Universal Catalog gestiona estos tipos de aspectos. Puedes leer aspectos de estos tipos, pero no puedes crear ni editar aspectos de estos tipos.	Algunos ejemplos de este contenido: `analytics-hub` `aspecttype-aspect` `bigquery-dataset` `bigquery-table` `cloudsql-database` `cloudsql-instance` `cloudsql-table` `entrygroup-aspect` `entrytype-aspect` `sensitive-data-protection-profile` `storage` `storage-bucket` `storage-folder`

Antes de empezar

Antes de crear y gestionar tipos de aspectos y aspectos, completa las tareas descritas en esta sección.

Roles obligatorios

Para obtener los permisos que necesitas para crear y gestionar tipos y aspectos, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en el recurso:

Conjunto completo de permisos en los recursos de metadatos de Dataplex Universal Catalog, incluidos los tipos de aspectos y los aspectos de datos: Administrador de catálogo de Dataplex (roles/dataplex.catalogAdmin)
Crea y gestiona recursos de metadatos en Dataplex Universal Catalog, incluidos tipos de aspectos y aspectos de datos: Editor de catálogo de Dataplex (roles/dataplex.catalogEditor)
Conjunto completo de permisos en tipos de aspectos personalizados (excepto los permisos para usar tipos de aspectos para crear o editar entradas): Propietario del tipo de aspecto de Dataplex (roles/dataplex.aspectTypeOwner)
Consulta los tipos de aspectos y las políticas de gestión de identidades y accesos asociadas: Visor de catálogo de Dataplex (roles/dataplex.catalogViewer)
Usa tipos de aspectos para crear y modificar entradas con los aspectos correspondientes: Usuario del tipo de aspecto de Dataplex (roles/dataplex.aspectTypeUser)
Añade aspectos de algunos de los tipos de aspectos del sistema, como schema, overview y contacts: Propietario de Entry y EntryLink de Dataplex (roles/dataplex.entryOwner)

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Para obtener más información, consulta los roles de gestión de identidades y accesos de Dataplex Universal Catalog.

Activar la API

Habilita la API de Dataplex en tu proyecto de Dataplex Universal Catalog.

Habilitar la API

Crear un tipo de aspecto personalizado

Consola

En la Google Cloud consola, ve a la página Catálogo de Dataplex Universal Catalog.

Ir al catálogo

Haga clic en la pestaña Tipos de aspecto y plantillas de etiquetas > Personalizado.
Haz clic en Crear tipo de aspecto.
En la ventana Crear tipo de aspecto, introduzca lo siguiente:
Opcional: En el campo Nombre visible, introduce un nombre para el tipo de aspecto.
1. En el campo ID de tipo de aspecto, introduce un ID único para el tipo de aspecto.
2. Opcional: En el campo Descripción, escribe una descripción del tipo de aspecto.
3. En el campo Ubicación, selecciona una ubicación para el tipo de aspecto. No puedes modificar la ubicación de un tipo de aspecto después de crearlo. Para saber cómo influye elegir una ubicación global o regional, consulta la sección Tipos de aspectos personalizados.
Opcional: Define una plantilla para tu tipo de aspecto.

En la sección Plantilla, haz clic en Añadir campo. En la sección Nuevo campo, introduce lo siguiente:

En el campo Nombre, introduce un nombre.
1. Opcional: En el campo Nombre visible, introduce un nombre visible.
2. Opcional: En el campo Descripción, escriba una descripción.
3. En el campo Tipo, selecciona un tipo de datos para el campo. En función de lo que elijas, se mostrarán los siguientes campos y opciones:
```
        *   If you selected **Text** as the data type, follow
            these steps:
```
En el campo Tipo de texto, selecciona el tipo de texto. 1. En el campo Valores de texto, proporciona una pista para el campo de texto. Para ello, haz clic en Añadir valor e introduce la sugerencia. Puedes añadir varias sugerencias para un campo de texto. 1. Por último, haz clic en Listo.
```
            *   If you selected **Enum** as the data type, add an
                enum value:
```

Haz clic en Añadir un valor de enumeración. 1. En el campo Valor, introduce un valor de enum. Puedes añadir varios valores de enumeración. 1. Haz clic en Listo.

            *   If you selected **Array** as the data type, in the
                **Array item** section, define the types of items to
                be present in the array:

Haz clic en Añadir elemento de la matriz. 1. En el campo Name (Nombre), introduce un nombre para los elementos de la matriz. 1. Opcional: En el campo Nombre visible, introduce un nombre visible para los elementos de la matriz. 1. Opcional: En el campo Descripción, introduce una descripción de los elementos de la matriz. 1. En el campo Tipo, selecciona un tipo de datos para los elementos de la matriz.

En función de lo que elijas, se mostrará el siguiente conjunto de campos y opciones. Son similares a las opciones descritas para los tipos de datos Texto, Enum, Mapa, Matriz y Registro en otras partes de esta sección.

Haz clic en Listo.

            *   If you selected **Map** as the data type, in the
                **Map value** section, define the types of values to
                be present in the map:

Haz clic en Añadir valor de asignación. 1. En el campo Nombre, introduce un nombre para el mapa. 1. Opcional: En el campo Nombre visible, introduce un nombre visible para el mapa. 1. Opcional: En el campo Descripción, escribe una descripción del mapa. 1. En el campo Tipo, selecciona un tipo de datos para el mapa.

Haz clic en Listo.

            *   If you selected **Record** as the data type, enter
                the following:

En el campo ID de registro, introduce un ID único que otros campos de registro puedan usar para hacer referencia a este registro. Consulta la sección Ejemplo de uso de los campos ID de registro y Referencia de registro de este documento. 1. Opcional: Si quieres añadir una referencia a otro registro desde esta plantilla, usa el campo Referencia de registro. No puedes modificarlo después de crear el tipo de aspecto. Consulta la sección Ejemplo de uso de los campos ID de registro y Referencia de registro de este documento. 1. En la sección Campos de registro, puedes definir un objeto complejo con varios campos anidados. Para ello, haz clic en Añadir elemento de campo de registro y especifica lo siguiente:
En el campo Nombre, introduce un nombre para el campo de registro. 1. Opcional: En el campo Nombre visible, introduce un nombre visible para el campo de registro. 1. Opcional: En el campo Descripción, escribe una descripción del campo de registro. 1. En el campo Tipo, selecciona un tipo de datos.

Haz clic en Listo.
Para que el campo sea obligatorio en un aspecto de este tipo, selecciona Es obligatorio. Para obtener más información sobre los aspectos obligatorios y opcionales, consulta la sección Categorías de aspectos de este documento.
1. Haz clic en Listo.
2. Para añadir varios campos, haz clic en Añadir campo y repite los pasos anteriores.
Opcional: En la sección Etiquetas, añade etiquetas arbitrarias como pares clave-valor a los recursos:
Haz clic en Añadir etiqueta.
1. En el campo Clave, introduce una clave.
2. En el campo Valor, introduce un valor para la clave.
3. Para añadir más etiquetas, haz clic en Añadir etiqueta y repite los pasos.
Haz clic en Guardar.

gcloud

Para crear un tipo de aspecto personalizado, usa el comando gcloud dataplex aspect-types create.

C#

Antes de probar este ejemplo, sigue las C# instrucciones de configuración de la guía de inicio rápido de Dataplex Universal Catalog con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API C# Universal Catalog de Dataplex.

Para autenticarte en Dataplex Universal Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

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

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for CreateAspectType</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 CreateAspectTypeRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        CreateAspectTypeRequest request = new CreateAspectTypeRequest
        {
            ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
            AspectTypeId = "",
            AspectType = new AspectType(),
            ValidateOnly = false,
        };
        // Make the request
        Operation<AspectType, OperationMetadata> response = catalogServiceClient.CreateAspectType(request);

        // Poll until the returned long-running operation is complete
        Operation<AspectType, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        AspectType result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<AspectType, OperationMetadata> retrievedResponse = catalogServiceClient.PollOnceCreateAspectType(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            AspectType retrievedResult = retrievedResponse.Result;
        }
    }
}

Go

Antes de probar este ejemplo, sigue las Go instrucciones de configuración de la guía de inicio rápido de Dataplex Universal Catalog con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go Universal Catalog de Dataplex.


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.CreateAspectTypeRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#CreateAspectTypeRequest.
	}
	op, err := c.CreateAspectType(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

Antes de probar este ejemplo, sigue las Java instrucciones de configuración de la guía de inicio rápido de Dataplex Universal Catalog con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java Universal Catalog de Dataplex.

import com.google.cloud.dataplex.v1.AspectType;
import com.google.cloud.dataplex.v1.CatalogServiceClient;
import com.google.cloud.dataplex.v1.CreateAspectTypeRequest;
import com.google.cloud.dataplex.v1.LocationName;

public class SyncCreateAspectType {

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

  public static void syncCreateAspectType() 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()) {
      CreateAspectTypeRequest request =
          CreateAspectTypeRequest.newBuilder()
              .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
              .setAspectTypeId("aspectTypeId-423030675")
              .setAspectType(AspectType.newBuilder().build())
              .setValidateOnly(true)
              .build();
      AspectType response = catalogServiceClient.createAspectTypeAsync(request).get();
    }
  }
}

Python

Antes de probar este ejemplo, sigue las Python instrucciones de configuración de la guía de inicio rápido de Dataplex Universal Catalog con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python Universal Catalog de Dataplex.

# 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_create_aspect_type():
    # Create a client
    client = dataplex_v1.CatalogServiceClient()

    # Initialize request argument(s)
    aspect_type = dataplex_v1.AspectType()
    aspect_type.metadata_template.name = "name_value"
    aspect_type.metadata_template.type_ = "type__value"

    request = dataplex_v1.CreateAspectTypeRequest(
        parent="parent_value",
        aspect_type_id="aspect_type_id_value",
        aspect_type=aspect_type,
    )

    # Make the request
    operation = client.create_aspect_type(request=request)

    print("Waiting for operation to complete...")

    response = operation.result()

    # Handle the response
    print(response)

Ruby

Antes de probar este ejemplo, sigue las Ruby instrucciones de configuración de la guía de inicio rápido de Dataplex Universal Catalog con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Ruby Universal Catalog de Dataplex.

require "google/cloud/dataplex/v1"

##
# Snippet for the create_aspect_type 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#create_aspect_type.
#
def create_aspect_type
  # 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::CreateAspectTypeRequest.new

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

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Para crear un tipo de aspecto personalizado, usa el método aspectType.create.

Después de crear un tipo de aspecto personalizado, puedes añadir aspectos a las entradas.

Ejemplo de uso de los campos ID de registro y Referencia de registro

Puede usar los campos ID de registro y Referencia de registro para las referencias recursivas. En el siguiente ejemplo se muestra cómo usar estos campos:

Imagina un tipo de aspecto llamado Employee con los siguientes campos:

Nombre (tipo:Text)
Fecha de inicio (tipo:Date & time)
Designación (tipo:Text)
Dirección actual (tipo:Record)
Dirección permanente (tipo:Record)

Los campos de dirección Dirección actual y Dirección permanente son del mismo tipo de datos Record. Para evitar duplicados, puedes definir los valores ID de registro y Referencia de registro al definir estos campos.

Cuando definas el campo Dirección actual, puedes especificar ID de registro como address-field. En Domicilio permanente, puede especificar el mismo valor (address-field) en Referencia del registro. Por ejemplo:

Nombre (tipo:Text)
Fecha de inicio (tipo:Date & time)
Designation (tipo:Text)
Dirección actual (tipo:Record, ID de registro:address-field)
Dirección permanente (tipo:Record, referencia de registro:address-field)

De esta forma, no tendrás que duplicar los campos de otra dirección.

Añadir aspectos a una entrada

Después de crear un tipo de aspecto personalizado, puedes crear aspectos de ese tipo. Para añadir aspectos a una entrada, debes actualizarla, ya que los aspectos se almacenan en las entradas.

Ten en cuenta lo siguiente:

Puedes añadir aspectos a una entrada o a las columnas de una entrada.
Solo puedes editar los aspectos obligatorios de las entradas personalizadas. No puedes eliminar los aspectos obligatorios.
Puedes editar y eliminar los aspectos opcionales tanto de las entradas personalizadas como de las del sistema.

Consola

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

Ir a Buscar

En Choose search platform (Elegir plataforma de búsqueda), selecciona Dataplex Universal Catalog (Catálogo universal de Dataplex) como modo de búsqueda.
Busca la entrada a la que quieras añadir aspectos y haz clic en ella. Se abrirá la página de detalles de la entrada.
Para añadir aspectos a la entrada, sigue estos pasos:
1. Haga clic en la pestaña Detalles.
2. Para añadir aspectos obligatorios u opcionales a la entrada, en la sección Etiquetas y aspectos, haz clic en Añadir en la categoría correspondiente.
  No puedes añadir aspectos obligatorios si el tipo de entrada de la entrada seleccionada no tiene aspectos obligatorios definidos.
3. Busca y selecciona el aspecto que quieras añadir.
4. En la ventana Añadir aspecto, introduce los valores de los campos.
5. Haz clic en Guardar.
6. Para añadir aspectos a una columna de la entrada, sigue estos pasos:
7. En la página de detalles de la entrada, haga clic en la pestaña Esquema.
8. Selecciona las columnas a las que quieras añadir aspectos.
9. Haz clic en Añadir aspecto.
10. Busca y selecciona el aspecto que quieras añadir.
11. En la ventana Añadir aspecto, introduce los valores de los campos.
12. Haz clic en Guardar.

gcloud

Para añadir aspectos a una entrada o a una columna de una entrada, usa el gcloud dataplex entries updatecomando.

C#

using Google.Cloud.Dataplex.V1;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for UpdateEntry</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 UpdateEntryRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        UpdateEntryRequest request = new UpdateEntryRequest
        {
            Entry = new Entry(),
            UpdateMask = new FieldMask(),
            AllowMissing = false,
            DeleteMissingAspects = false,
            AspectKeys = { "", },
        };
        // Make the request
        Entry response = catalogServiceClient.UpdateEntry(request);
    }
}

Para añadir aspectos al objeto de entrada, consulta Aspectos.

Go


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.UpdateEntryRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#UpdateEntryRequest.
	}
	resp, err := c.UpdateEntry(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Para añadir aspectos al objeto Entry, consulta Entry.

Java

import com.google.cloud.dataplex.v1.Aspect;
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.EntrySource;
import com.google.protobuf.FieldMask;
import com.google.protobuf.Struct;
import com.google.protobuf.Value;
import java.util.Map;

public class UpdateEntry {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    // Available locations: https://cloud.google.com/dataplex/docs/locations
    String location = "MY_LOCATION";
    String entryGroupId = "MY_ENTRY_GROUP_ID";
    String entryId = "MY_ENTRY_ID";

    Entry createdEntry = updateEntry(projectId, location, entryGroupId, entryId);
    System.out.println("Successfully updated entry: " + createdEntry.getName());
  }

  // Method to update Entry located in projectId, location, entryGroupId and with entryId
  public static Entry updateEntry(
      String projectId, String location, String entryGroupId, String entryId) throws Exception {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (CatalogServiceClient client = CatalogServiceClient.create()) {
      Entry entry =
          Entry.newBuilder()
              .setName(EntryName.of(projectId, location, entryGroupId, entryId).toString())
              .setEntrySource(
                  EntrySource.newBuilder()
                      .setDescription("updated description of the entry")
                      .build())
              .putAllAspects(
                  Map.of(
                      "dataplex-types.global.generic",
                      Aspect.newBuilder()
                          .setAspectType(
                              "projects/dataplex-types/locations/global/aspectTypes/generic")
                          .setData(
                              Struct.newBuilder()
                                  // "Generic" Aspect Type have fields called "type" and "system.
                                  // The values below are a sample of possible options.
                                  .putFields(
                                      "type",
                                      Value.newBuilder()
                                          .setStringValue("updated example value")
                                          .build())
                                  .putFields(
                                      "system",
                                      Value.newBuilder()
                                          .setStringValue("updated example system")
                                          .build())
                                  .build())
                          .build()))
              .build();

      // Update mask specifies which fields will be updated.
      // For more information on update masks, see: https://google.aip.dev/161
      FieldMask updateMask =
          FieldMask.newBuilder().addPaths("aspects").addPaths("entry_source.description").build();
      return client.updateEntry(entry, updateMask);
    }
  }
}

Python

from google.cloud import dataplex_v1
from google.protobuf import struct_pb2


def update_entry(
    project_id: str, location: str, entry_group_id: str, entry_id: str
) -> dataplex_v1.Entry:
    """Method to update Entry located in project_id, location, entry_group_id and with entry_id"""

    # Initialize client that will be used to send requests across threads. This
    # client only needs to be created once, and can be reused for multiple requests.
    # After completing all of your requests, call the "__exit__()" method to safely
    # clean up any remaining background resources. Alternatively, use the client as
    # a context manager.
    with dataplex_v1.CatalogServiceClient() as client:
        # The resource name of the Entry
        name = f"projects/{project_id}/locations/{location}/entryGroups/{entry_group_id}/entries/{entry_id}"
        entry = dataplex_v1.Entry(
            name=name,
            entry_source=dataplex_v1.EntrySource(
                description="updated description of the entry"
            ),
            aspects={
                "dataplex-types.global.generic": dataplex_v1.Aspect(
                    aspect_type="projects/dataplex-types/locations/global/aspectTypes/generic",
                    data=struct_pb2.Struct(
                        fields={
                            # "Generic" Aspect Type have fields called "type" and "system.
                            # The values below are a sample of possible options.
                            "type": struct_pb2.Value(
                                string_value="updated example value"
                            ),
                            "system": struct_pb2.Value(
                                string_value="updated example system"
                            ),
                        }
                    ),
                )
            },
        )

        # Update mask specifies which fields will be updated.
        # For more information on update masks, see: https://google.aip.dev/161
        update_mask = {"paths": ["aspects", "entry_source.description"]}
        return client.update_entry(entry=entry, update_mask=update_mask)


if __name__ == "__main__":
    # TODO(developer): Replace these variables before running the sample.
    project_id = "MY_PROJECT_ID"
    # Available locations: https://cloud.google.com/dataplex/docs/locations
    location = "MY_LOCATION"
    entry_group_id = "MY_ENTRY_GROUP_ID"
    entry_id = "MY_ENTRY_ID"

    updated_entry = update_entry(project_id, location, entry_group_id, entry_id)
    print(f"Successfully updated entry: {updated_entry.name}")

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the update_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#update_entry.
#
def update_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::UpdateEntryRequest.new

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

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

Para añadir aspectos al objeto de entrada, consulta #required_aspects=.

REST

Para añadir aspectos a una entrada o a una columna de una entrada, usa el método entry.patch.

No se pueden crear ni usar aspectos en una entrada en la que el tipo de aspecto y la entrada estén en organizaciones Google Cloud diferentes.

Adjuntar aspectos de tipos de aspectos del sistema reutilizables

Puedes adjuntar aspectos de tipos de aspectos de sistema reutilizables a las entradas.

Puedes editar un aspecto de un tipo de aspecto reutilizable en la Google Cloud consola en función de su estructura. Los tipos de aspectos que contienen campos anidados no se pueden editar en la consola de Google Cloud . Debes usar la herramienta de línea de comandos gcloud o la API REST para adjuntar o actualizar aspectos de este tipo.

Tarjeta de valoración de la calidad de los datos

Una tarjeta de resultados de calidad de los datos es un aspecto que proporciona un resumen de la calidad de los datos, a menudo basado en análisis de calidad de los datos u otros procesos. Puede adjuntar una tarjeta de resultados de calidad de los datos a una entrada para proporcionar información personalizada sobre la calidad de los datos. Para ello, adjunta un aspecto del tipo definido por el sistema data-quality-scorecard.

El campo data del aspecto data-quality-scorecard puede incluir los siguientes campos:

job: opcional. Registro que contiene detalles sobre el trabajo que ha generado la tarjeta de resultados.
- name: nombre del recurso del trabajo de calidad de los datos.
- runTime: tiempo de ejecución del trabajo de calidad de los datos.
score: opcional. La puntuación general de calidad de los datos. La puntuación está comprendida entre [0, 100].
status: obligatorio. El estado de la tarjeta de resultados de calidad de los datos, que indica si se ha superado o no el umbral de calidad (PASS o FAIL).
dimensions: opcional. Matriz de resultados de dimensiones. Cada resultado incluye lo siguiente:
- name: nombre de la dimensión. Puede ser ACCURACY, COMPLETENESS, CONSISTENCY, FRESHNESS, UNIQUENESS, VALIDITY, VOLUME o el nombre de una dimensión personalizada. Los nombres de las dimensiones personalizadas deben usar letras mayúsculas y tener 30 caracteres como máximo.
- score: puntuación general a nivel de dimensión, que va de 0 a 100.
- status: estado de la dimensión, que indica si ha superado o no el umbral de calidad (PASS o FAIL).
columns: opcional. Una matriz de resultados de columnas. Cada resultado incluye lo siguiente:
- name: nombre de la columna.
- score: la puntuación general a nivel de columna, que va de 0 a 100.
- status: estado de la columna, que indica si ha superado o no el umbral de calidad (PASS o FAIL).
- dimensions: array de puntuaciones de dimensión de la columna. Cada puntuación de dimensión incluye lo siguiente:
  - name: nombre de la dimensión.
  - score: puntuación de la dimensión, que va de 0 a 100.
  - status: estado de la dimensión de la columna, que indica si ha superado o no el umbral de calidad (PASS o FAIL).

Cuando ejecutas el comando para adjuntar un aspecto, se sustituyen los datos que ya haya de ese aspecto concreto. Por ejemplo, si actualiza una tarjeta de resultados que tiene una puntuación de 80 con un nuevo archivo que muestra una puntuación de 90, se sobrescribe la puntuación 80. No combina los datos.

Para adjuntar un cuadro de resultados de calidad de los datos, sigue estos pasos:

gcloud

Para actualizar los aspectos de una entrada, usa el comando gcloud dataplex entries update-aspects.

Crea un archivo JSON (dq-aspect.json) con el siguiente contenido.

  {
    "dataplex-types.global.data-quality-scorecard": {
      "data": {
        "score": 0.8,
        "status": "PASS",
        "dimensions": [
          {
            "name": "completeness",
            "score": 0.9,
            "status": "PASS"
          },
          {
            "name": "uniqueness",
            "score": 0.7,
            "status": "FAIL"
          }
        ],
        "columns": [
          {
            "name": "col1",
            "score": 0.85,
            "status": "PASS"
          }
        ]
      }
    }
  }
}

Ejecuta el siguiente comando:
```
  gcloud dataplex entries update-aspects ENTRY_ID
  --location=LOCATION
  --entry-group=ENTRY_GROUP_ID
  --project=PROJECT_ID
  --aspects=dq-aspect.json
```
Sustituye las siguientes variables:
- ENTRY_ID: el ID de la entrada. Por ejemplo: example-entry
- LOCATION: la ubicación de la entrada. Por ejemplo: us-central1
- ENTRY_GROUP_ID: el ID del grupo de entradas. Por ejemplo, example-entry-group.
- PROJECT_ID: el ID del proyecto (por ejemplo, example-project).

REST

Para actualizar los aspectos de una entrada, usa el método entry.patch.

Crea un archivo llamado payload.json y pega en él el contenido JSON de tu solicitud.


  {
    "aspects": {
      "dataplex-types.global.data-quality-scorecard": {
        "aspectType": "projects/<var>PROJECT_ID</var>/locations/global/aspectTypes/data-quality-scorecard",
        "data": {
          "score": 80,
          "status": "PASS",
          "dimensions": [
            {
              "name": "completeness",
              "score": 90,
              "status": "PASS"
            },
            {
              "name": "uniqueness",
              "score": 70,
              "status": "FAIL"
            }
          ],
          "columns": [
            {
              "name": "col1",
              "score": 85,
              "status": "PASS"
            }
          ]
        }
      }
    }
  }

Ejecuta este comando en el terminal:

 curl -X PATCH \
 -H "Authorization: Bearer $(gcloud auth print-access-token)" \
 -H "Content-Type: application/json" \
 -d @payload.json \
 "https://dataplex.googleapis.com/v1/projects/<var>PROJECT_ID</var>/locations/<var>LOCATION</var>/entryGroups/<var>ENTRY_GROUP_ID</var>/entries/<var>ENTRY_ID</var>?updateMask=aspects"

Haz los cambios siguientes:

PROJECT_ID: el ID del proyecto (por ejemplo, example-project)
LOCATION: la ubicación de la entrada (por ejemplo, us-central1).
ENTRY_GROUP_ID: el ID del grupo de entradas (por ejemplo, example-entry-group).
ENTRY_ID: el ID de la entrada (por ejemplo, example-entry)

Otros tipos de aspectos reutilizables

También se pueden usar los siguientes tipos de aspectos del sistema. Puede adjuntarlos con los mismos métodos de la API REST o gcloud que se muestran en la tarjeta de resultados de calidad de los datos. En el caso de los tipos de aspectos sin campos anidados, como generic, puedes usar la consola.

Contactos. Usa el tipo de aspecto contacts para asignar la propiedad o la gestión. Entre los campos se incluyen los siguientes:
- identities (matriz): lista de contactos. Cada contacto incluye lo siguiente:
  - role (cadena): el rol del contacto (por ejemplo, owner, steward, producer o admin).
  - name (cadena): el nombre del contacto.
  - id (cadena): dirección de correo o ID del contacto.
Crea el archivo payload.json de la siguiente manera:
```
 {
   "aspects": {
     "dataplex-types.global.contacts": {
       "data": {
         "identities": [
           {
             "role": "steward",
             "name": "Jane Doe",
             "id": "jane.doe@example.com"
           }
         ]
       }
     }
   }
 }
```
Perfil de datos. Utiliza el tipo de aspecto data-profile para capturar los resultados de la creación de perfiles de datos. Para obtener más información, consulta el artículo Acerca de la creación de perfiles de datos. Los campos son los siguientes:
- sourceDataInfo (registro): información sobre los datos de origen analizados para generar el perfil.
  - scope (enum): el ámbito del perfil (PREVIEW, SAMPLED o ALL).
  - scannedRows (int): número de filas analizadas.
  - samplingPercentage (doble): porcentaje de muestreo utilizado.
- fields (mapa): un mapa de nombres de columnas y sus perfiles de datos, incluidas métricas como los valores uniqueness, nullness y topN, y estadísticas específicas de cada tipo para las columnas numeric, string, datetime y array.
Crea el archivo payload.json de la siguiente manera:
```
 {
   "aspects": {
     "dataplex-types.global.data-profile": {
       "data": {
         "sourceDataInfo": {
         "scope": "ALL",
         "scannedRows": 100
       },
       "fields": {
         "col1": {
           "nullness": 0.0,
           "uniqueness": 0.1,
      "string": {
        "length": {
          "min": 1,
          "max": 20,
          "avg": 12.54
        }
      }
         }
       }
     }
   }
 }}
```
Genérico. Usa el tipo de aspecto generic para la información de entrada genérica. Entre los campos se incluyen los siguientes:
- type (cadena): campo de formato libre para almacenar un tipo especificado por el usuario.
- system (cadena): el sistema de la entrada personalizada.
Crea el archivo payload.json de la siguiente manera:
```
{
  "aspects": {
    "dataplex-types.global.generic": {
      "data": {
        "type": "custom-type",
        "system": "custom-system"
      }
    }
  }
}
```
Descripción general. Usa el tipo de aspecto overview para proporcionar una descripción de texto enriquecido. Entre los campos se incluyen los siguientes:
- content (cadena): resumen de la entrada, que admite el formato HTML.
- links (array): lista de enlaces del sistema de origen. Cada enlace incluye lo siguiente:
  - url (cadena): la URL del enlace.
  - title (cadena): el título del enlace.
Crea el archivo payload.json de la siguiente manera:
```
{
  "aspects": {
    "dataplex-types.global.overview": {
      "data": {
        "content": "This is a <b>rich text</b> description.",
      "links": [
        {
          "url": "https://example.com",
          "title": "Example Link"
        }
      ]
    }
  }
}}
```
Esquema. Utilice el tipo de aspecto schema para describir la estructura de los datos.
- fields (matriz): lista de campos de esquema. Entre los campos se incluyen los siguientes:
  - name (cadena): nombre del campo.
  - dataType (cadena): el tipo de datos del campo.
  - metadataType (enum): el tipo de metadatos (por ejemplo, STRING, BOOLEAN).
  - mode (enum): el modo del campo (NULLABLE, REQUIRED, REPEATED).
  - description (cadena): descripción del campo.
Crea el archivo payload.json de la siguiente manera:
```
{
  "aspects": {
    "dataplex-types.global.schema": {
      "data": {
        "fields": [
        {
          "name": "id",
          "dataType": "string",
          "metadataType": "STRING",
          "mode": "REQUIRED"
        }
      ]
    }
  }
}}
```
Uso. Usa el tipo de aspecto usage para monitorizar las métricas de uso. Los campos incluyen lo siguiente:
- metrics (matriz): lista de métricas de uso. Cada métrica incluye lo siguiente:
  - name (cadena): nombre de la métrica (por ejemplo, views o reads).
  - timeSeries (matriz): lista de datos de series temporales. Cada elemento incluye lo siguiente:
    - interval (cadena): intervalo de agregación (por ejemplo, 30d).
    - value (entero): el valor agregado.
- refreshTime (fecha y hora): la hora en la que se actualizaron las métricas por última vez.
Crea el archivo payload.json de la siguiente manera:
```
{
  "aspects": {
    "dataplex-types.global.usage": {
      "data": {
        "metrics": [
        {
          "name": "views",
          "timeSeries": [
            {
              "interval": "30d",
              "value": 100
            }
          ]
        }
      ],
      "refreshTime": "2025-01-01T12:00:00Z"
    }
  }
}}
```

Gestionar los aspectos de una entrada

En esta sección se describe cómo actualizar y eliminar los aspectos de una entrada.

Actualizar un aspecto

Puedes editar los aspectos opcionales tanto de las entradas personalizadas como de las del sistema. Solo puedes editar los aspectos obligatorios de las entradas personalizadas.

Consola

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

Ir a Buscar

En Choose search platform (Elegir plataforma de búsqueda), selecciona Dataplex Universal Catalog (Catálogo universal de Dataplex) como modo de búsqueda.
Busca la entrada cuyos aspectos quieras actualizar y haz clic en ella.

Se abrirá la página de detalles de la entrada.

1.  Click the **Details** tab.

En la sección Etiquetas y aspectos, despliega el aspecto o la etiqueta que quieras actualizar y haz clic en Editar.
En la ventana Editar aspecto, actualiza los campos obligatorios.
Haz clic en Guardar.

gcloud

Para actualizar aspectos de una entrada o de una columna de una entrada, usa el comando gcloud dataplex entries update.

C#

using Google.Cloud.Dataplex.V1;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for UpdateEntry</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 UpdateEntryRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        UpdateEntryRequest request = new UpdateEntryRequest
        {
            Entry = new Entry(),
            UpdateMask = new FieldMask(),
            AllowMissing = false,
            DeleteMissingAspects = false,
            AspectKeys = { "", },
        };
        // Make the request
        Entry response = catalogServiceClient.UpdateEntry(request);
    }
}

Go


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.UpdateEntryRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#UpdateEntryRequest.
	}
	resp, err := c.UpdateEntry(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

import com.google.cloud.dataplex.v1.CatalogServiceClient;
import com.google.cloud.dataplex.v1.Entry;
import com.google.cloud.dataplex.v1.UpdateEntryRequest;
import com.google.protobuf.FieldMask;
import java.util.ArrayList;

public class SyncUpdateEntry {

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

  public static void syncUpdateEntry() 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()) {
      UpdateEntryRequest request =
          UpdateEntryRequest.newBuilder()
              .setEntry(Entry.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .setAllowMissing(true)
              .setDeleteMissingAspects(true)
              .addAllAspectKeys(new ArrayList<String>())
              .build();
      Entry response = catalogServiceClient.updateEntry(request);
    }
  }
}

Python

# 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_update_entry():
    # Create a client
    client = dataplex_v1.CatalogServiceClient()

    # Initialize request argument(s)
    entry = dataplex_v1.Entry()
    entry.entry_type = "entry_type_value"

    request = dataplex_v1.UpdateEntryRequest(
        entry=entry,
    )

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

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the update_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#update_entry.
#
def update_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::UpdateEntryRequest.new

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

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

REST

Para actualizar los aspectos de una entrada o una columna de una entrada, usa el método entry.patch.

Eliminar un aspecto

Consola

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

Ir a Buscar

En Choose search platform (Elegir plataforma de búsqueda), selecciona Dataplex Universal Catalog (Catálogo universal de Dataplex) como modo de búsqueda.
Busca la entrada cuyos aspectos quieras eliminar y haz clic en ella.

Se abrirá la página de detalles de la entrada.

1.  Click the **Details** tab.

En la sección Etiquetas y aspectos, despliega el aspecto o la etiqueta que quieras eliminar y haz clic en Eliminar.
Haz clic en Confirmar.

gcloud

Para eliminar un aspecto de una entrada, usa el gcloud dataplex entries update comando.

C#

using Google.Cloud.Dataplex.V1;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for UpdateEntry</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 UpdateEntryRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        UpdateEntryRequest request = new UpdateEntryRequest
        {
            Entry = new Entry(),
            UpdateMask = new FieldMask(),
            AllowMissing = false,
            DeleteMissingAspects = false,
            AspectKeys = { "", },
        };
        // Make the request
        Entry response = catalogServiceClient.UpdateEntry(request);
    }
}

Go


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.UpdateEntryRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#UpdateEntryRequest.
	}
	resp, err := c.UpdateEntry(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

import com.google.cloud.dataplex.v1.CatalogServiceClient;
import com.google.cloud.dataplex.v1.Entry;
import com.google.cloud.dataplex.v1.UpdateEntryRequest;
import com.google.protobuf.FieldMask;
import java.util.ArrayList;

public class SyncUpdateEntry {

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

  public static void syncUpdateEntry() 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()) {
      UpdateEntryRequest request =
          UpdateEntryRequest.newBuilder()
              .setEntry(Entry.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .setAllowMissing(true)
              .setDeleteMissingAspects(true)
              .addAllAspectKeys(new ArrayList<String>())
              .build();
      Entry response = catalogServiceClient.updateEntry(request);
    }
  }
}

Python

# 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_update_entry():
    # Create a client
    client = dataplex_v1.CatalogServiceClient()

    # Initialize request argument(s)
    entry = dataplex_v1.Entry()
    entry.entry_type = "entry_type_value"

    request = dataplex_v1.UpdateEntryRequest(
        entry=entry,
    )

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

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the update_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#update_entry.
#
def update_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::UpdateEntryRequest.new

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

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

REST

Para eliminar un aspecto de una entrada, utiliza el método entry.patch.

Gestionar tipos de aspectos

En esta sección se describe cómo ver tipos de aspectos, así como actualizar y eliminar tipos de aspectos personalizados.

Ver la lista de tipos de aspectos y plantillas de etiquetas disponibles

Consola

En la Google Cloud consola, ve a la página Catálogo de Dataplex Universal Catalog.

Ir al catálogo

Haga clic en la pestaña Tipos de aspecto y plantillas de etiquetas.

En esta página se enumeran todos los tipos de aspectos de Dataplex Universal Catalog y las plantillas de etiquetas de Data Catalog disponibles.

Para ver los tipos de aspecto y las plantillas de etiquetas personalizadas, haga clic en la pestaña Personalizado. En la pestaña Personalizado, la columna Fuente del catálogo muestra dónde se encuentra el recurso: Dataplex Universal Catalog o Data Catalog.

Para ver los tipos de aspectos del sistema, haga clic en la pestaña Sistema.

Para obtener más información sobre los tipos de aspectos personalizados y del sistema, consulta la sección Categorías de tipos de aspectos de este documento.

Opcional: Para ver la lista de tipos de aspectos y plantillas de etiquetas del proyecto seleccionado, haga clic en la pestaña Personalizado y, a continuación, en el interruptor Mostrar de todos los proyectos para desactivarlo.

El interruptor Mostrar de todos los proyectos está activado de forma predeterminada y la lista incluye recursos de Dataplex Universal Catalog de la organización seleccionada y recursos de Data Catalog de todas las organizaciones a las que puedes acceder.

gcloud

Para ver una lista de todos los tipos de aspectos disponibles, usa el comando gcloud dataplex aspect-types list.

C#

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

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for ListAspectTypes</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 ListAspectTypesRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        ListAspectTypesRequest request = new ListAspectTypesRequest
        {
            ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
            Filter = "",
            OrderBy = "",
        };
        // Make the request
        PagedEnumerable<ListAspectTypesResponse, AspectType> response = catalogServiceClient.ListAspectTypes(request);

        // Iterate over all response items, lazily performing RPCs as required
        foreach (AspectType 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 (ListAspectTypesResponse page in response.AsRawResponses())
        {
            // Do something with each page of items
            Console.WriteLine("A page of results:");
            foreach (AspectType 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<AspectType> 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 (AspectType 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


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.ListAspectTypesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#ListAspectTypesRequest.
	}
	it := c.ListAspectTypes(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.ListAspectTypesResponse)
	}
}

Java

import com.google.cloud.dataplex.v1.AspectType;
import com.google.cloud.dataplex.v1.CatalogServiceClient;
import com.google.cloud.dataplex.v1.ListAspectTypesRequest;
import com.google.cloud.dataplex.v1.LocationName;

public class SyncListAspectTypes {

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

  public static void syncListAspectTypes() 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()) {
      ListAspectTypesRequest request =
          ListAspectTypesRequest.newBuilder()
              .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setFilter("filter-1274492040")
              .setOrderBy("orderBy-1207110587")
              .build();
      for (AspectType element : catalogServiceClient.listAspectTypes(request).iterateAll()) {
        // doThingsWith(element);
      }
    }
  }
}

Python

# 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_list_aspect_types():
    # Create a client
    client = dataplex_v1.CatalogServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.ListAspectTypesRequest(
        parent="parent_value",
    )

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

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

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the list_aspect_types 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#list_aspect_types.
#
def list_aspect_types
  # 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::ListAspectTypesRequest.new

  # Call the list_aspect_types method.
  result = client.list_aspect_types 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::AspectType.
    p item
  end
end

REST

Para enumerar todos los tipos de aspectos disponibles, usa el método aspectTypes.list.

Ver los detalles de un tipo de aspecto o una plantilla de etiqueta

Consola

En la Google Cloud consola, ve a la página Catálogo de Dataplex Universal Catalog.

Ir al catálogo

Haga clic en la pestaña Tipos de aspecto y plantillas de etiquetas.
Para ver los detalles de un tipo de aspecto de Dataplex Universal Catalog, haz clic en el tipo de aspecto. Se abre la página de detalles del tipo de aspecto, donde puede acceder a detalles como el nombre visible, el ID del tipo de aspecto, la descripción, el ID del proyecto, la ubicación, las etiquetas, la fecha de creación y la fecha de la última modificación.
- Para ver la estructura del tipo de aspecto seleccionado, haga clic en la pestaña Plantilla.
- Para ver la lista de las 10 entradas relacionadas creadas recientemente, haz clic en la pestaña Entradas de ejemplo.
- Para buscar todas las entradas relacionadas, haz clic en Mostrar todas las entradas relacionadas en la búsqueda. Este botón solo aparece si hay al menos una entrada relacionada.
Para ver los detalles de una plantilla de etiqueta de Data Catalog, haga clic en ella. La página de detalles de la plantilla de etiquetas se abre en Data Catalog, donde puedes acceder a detalles como el nombre visible, el ID de la plantilla, el ID del proyecto, la ubicación, la visibilidad y las etiquetas.

gcloud

Para obtener los detalles de un tipo de aspecto, usa el comando gcloud dataplex aspect-types describe.

C#

using Google.Cloud.Dataplex.V1;

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for GetAspectType</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 GetAspectTypeRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        GetAspectTypeRequest request = new GetAspectTypeRequest
        {
            AspectTypeName = AspectTypeName.FromProjectLocationAspectType("[PROJECT]", "[LOCATION]", "[ASPECT_TYPE]"),
        };
        // Make the request
        AspectType response = catalogServiceClient.GetAspectType(request);
    }
}

Go


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.GetAspectTypeRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#GetAspectTypeRequest.
	}
	resp, err := c.GetAspectType(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

import com.google.cloud.dataplex.v1.AspectType;
import com.google.cloud.dataplex.v1.AspectTypeName;
import com.google.cloud.dataplex.v1.CatalogServiceClient;
import com.google.cloud.dataplex.v1.GetAspectTypeRequest;

public class SyncGetAspectType {

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

  public static void syncGetAspectType() 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()) {
      GetAspectTypeRequest request =
          GetAspectTypeRequest.newBuilder()
              .setName(AspectTypeName.of("[PROJECT]", "[LOCATION]", "[ASPECT_TYPE]").toString())
              .build();
      AspectType response = catalogServiceClient.getAspectType(request);
    }
  }
}

Python

# 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_get_aspect_type():
    # Create a client
    client = dataplex_v1.CatalogServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.GetAspectTypeRequest(
        name="name_value",
    )

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

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the get_aspect_type 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#get_aspect_type.
#
def get_aspect_type
  # 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::GetAspectTypeRequest.new

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

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

REST

Para obtener los detalles de un tipo de aspecto, usa el método aspectTypes.get.

Actualizar un tipo de aspecto personalizado

Puede actualizar el nombre visible, la descripción, los campos de plantilla y las etiquetas de un tipo de aspecto personalizado. No puedes eliminar un campo de una plantilla.

No puedes actualizar el ID y la ubicación del tipo de aspecto después de crear el tipo de aspecto.

Consola

En la Google Cloud consola, ve a la página Catálogo de Dataplex Universal Catalog.

Ir al catálogo

Haga clic en la pestaña Tipos de aspecto y plantillas de etiquetas.
Haz clic en el tipo de aspecto que quieras actualizar.
En la página Detalles del tipo de aspecto, haga clic en Editar.
Edita el nombre visible, la descripción, los campos de plantilla y las etiquetas según sea necesario.
Opcional: Para marcar un campo del tipo de aspecto como obsoleto, sigue estos pasos:
1. En la sección Plantilla, despliega el campo.
2. Selecciona Está obsoleto.
3. En el campo Motivo de la obsolescencia, indica el motivo por el que se va a retirar el campo seleccionado.
4. Haz clic en Listo.
5. Haz clic en Guardar.

gcloud

Para actualizar un tipo de aspecto personalizado, usa el comando gcloud dataplex aspect-types update.

C#

using Google.Cloud.Dataplex.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for UpdateAspectType</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 UpdateAspectTypeRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        UpdateAspectTypeRequest request = new UpdateAspectTypeRequest
        {
            AspectType = new AspectType(),
            UpdateMask = new FieldMask(),
            ValidateOnly = false,
        };
        // Make the request
        Operation<AspectType, OperationMetadata> response = catalogServiceClient.UpdateAspectType(request);

        // Poll until the returned long-running operation is complete
        Operation<AspectType, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        AspectType result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<AspectType, OperationMetadata> retrievedResponse = catalogServiceClient.PollOnceUpdateAspectType(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            AspectType retrievedResult = retrievedResponse.Result;
        }
    }
}

Go


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.UpdateAspectTypeRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#UpdateAspectTypeRequest.
	}
	op, err := c.UpdateAspectType(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

import com.google.cloud.dataplex.v1.AspectType;
import com.google.cloud.dataplex.v1.CatalogServiceClient;
import com.google.cloud.dataplex.v1.UpdateAspectTypeRequest;
import com.google.protobuf.FieldMask;

public class SyncUpdateAspectType {

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

  public static void syncUpdateAspectType() 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()) {
      UpdateAspectTypeRequest request =
          UpdateAspectTypeRequest.newBuilder()
              .setAspectType(AspectType.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .setValidateOnly(true)
              .build();
      AspectType response = catalogServiceClient.updateAspectTypeAsync(request).get();
    }
  }
}

Python

# 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_update_aspect_type():
    # Create a client
    client = dataplex_v1.CatalogServiceClient()

    # Initialize request argument(s)
    aspect_type = dataplex_v1.AspectType()
    aspect_type.metadata_template.name = "name_value"
    aspect_type.metadata_template.type_ = "type__value"

    request = dataplex_v1.UpdateAspectTypeRequest(
        aspect_type=aspect_type,
    )

    # Make the request
    operation = client.update_aspect_type(request=request)

    print("Waiting for operation to complete...")

    response = operation.result()

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the update_aspect_type 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#update_aspect_type.
#
def update_aspect_type
  # 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::UpdateAspectTypeRequest.new

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

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Para actualizar un tipo de aspecto personalizado, usa el método aspectTypes.patch.

Eliminar un tipo de aspecto personalizado

Consola

En la Google Cloud consola, ve a la página Catálogo de Dataplex Universal Catalog.

Ir al catálogo

Haga clic en la pestaña Tipos de aspecto y plantillas de etiquetas.
Haz clic en el tipo de aspecto que quieras eliminar.
En la página Detalles del tipo de aspecto, haz clic en Eliminar. Confirma la acción cuando se te solicite.

gcloud

Para eliminar un tipo de aspecto personalizado, usa el comando gcloud dataplex aspect-types delete.

C#

using Google.Cloud.Dataplex.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for DeleteAspectType</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 DeleteAspectTypeRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        DeleteAspectTypeRequest request = new DeleteAspectTypeRequest
        {
            AspectTypeName = AspectTypeName.FromProjectLocationAspectType("[PROJECT]", "[LOCATION]", "[ASPECT_TYPE]"),
            Etag = "",
        };
        // Make the request
        Operation<Empty, OperationMetadata> response = catalogServiceClient.DeleteAspectType(request);

        // Poll until the returned long-running operation is complete
        Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        Empty result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<Empty, OperationMetadata> retrievedResponse = catalogServiceClient.PollOnceDeleteAspectType(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            Empty retrievedResult = retrievedResponse.Result;
        }
    }
}

Go


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.DeleteAspectTypeRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#DeleteAspectTypeRequest.
	}
	op, err := c.DeleteAspectType(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

Java

import com.google.cloud.dataplex.v1.AspectTypeName;
import com.google.cloud.dataplex.v1.CatalogServiceClient;
import com.google.cloud.dataplex.v1.DeleteAspectTypeRequest;
import com.google.protobuf.Empty;

public class SyncDeleteAspectType {

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

  public static void syncDeleteAspectType() 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()) {
      DeleteAspectTypeRequest request =
          DeleteAspectTypeRequest.newBuilder()
              .setName(AspectTypeName.of("[PROJECT]", "[LOCATION]", "[ASPECT_TYPE]").toString())
              .setEtag("etag3123477")
              .build();
      catalogServiceClient.deleteAspectTypeAsync(request).get();
    }
  }
}

Python

# 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_delete_aspect_type():
    # Create a client
    client = dataplex_v1.CatalogServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.DeleteAspectTypeRequest(
        name="name_value",
    )

    # Make the request
    operation = client.delete_aspect_type(request=request)

    print("Waiting for operation to complete...")

    response = operation.result()

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the delete_aspect_type 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#delete_aspect_type.
#
def delete_aspect_type
  # 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::DeleteAspectTypeRequest.new

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

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Para eliminar un tipo de aspecto personalizado, usa el método aspectTypes.delete.

Siguientes pasos

Consulta cómo buscar recursos de datos en Dataplex Universal Catalog.
Consulta cómo gestionar entradas e ingerir fuentes personalizadas.
Consulta cómo importar metadatos a Dataplex Universal Catalog.
Consulta más información sobre la gestión de metadatos en Dataplex Universal Catalog.
Consulta más información sobre la transición de Data Catalog a Dataplex Universal Catalog.
Sigue un codelab sobre gobernanza básica con Dataplex Universal Catalog.

Gestionar aspectos y enriquecer metadatos Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Aspectos

Categorías de aspectos

Aspectos de los datos

Tipos de aspectos

Categorías de tipos de aspectos

Tipos de aspecto personalizados

Tipos de aspecto del sistema

Antes de empezar

Roles obligatorios

Activar la API

Crear un tipo de aspecto personalizado

Consola

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Ejemplo de uso de los campos ID de registro y Referencia de registro

Añadir aspectos a una entrada

Consola

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Adjuntar aspectos de tipos de aspectos del sistema reutilizables

Tarjeta de valoración de la calidad de los datos

gcloud

REST

Otros tipos de aspectos reutilizables

Gestionar los aspectos de una entrada

Actualizar un aspecto

Consola

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Eliminar un aspecto

Consola

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Gestionar tipos de aspectos

Ver la lista de tipos de aspectos y plantillas de etiquetas disponibles

Consola

gcloud

C#

C#

Gestionar aspectos y enriquecer metadatos