Se usó la API de Cloud Translation para traducir esta página.

Administra aspectos y enriquece metadatos

Los metadatos son fundamentales para organizar y comprender tus activos de datos. Por ejemplo, las industrias reguladas deben proteger la información de identificación personal (PII), como nombres, direcciones y números de documentos de identidad emitidos por el Gobierno. Estos datos pueden aparecer en numerosas instancias en los sistemas de datos distribuidos. Dataplex Universal Catalog puede ayudarte a descubrir y catalogar rápidamente tus recursos de datos distribuidos. Luego, puedes clasificar los datos como PII.

Si enriqueces las entradas de datos con contexto significativo, puedes hacer que tus datos sean más fáciles de descubrir y más útiles. Dataplex Universal Catalog habilita el contexto a través de lo siguiente:

Tipo de aspecto: Es una plantilla JSON que define datos relacionados. Por ejemplo, para la información de cumplimiento, es posible que tengas la clasificación de PII y el cumplimiento del RGPD.
Aspecto: Es 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 tabla individual.

Una vez que hayas clasificado los datos, puedes aplicarles políticas de calidad o acceso.

Para obtener más información, consulta Acerca de la administración de metadatos en Dataplex Universal Catalog.

Aspectos

Los aspectos te permiten capturar metadatos con entradas para proporcionar contexto significativo. Puedes usar aspectos para almacenar lo siguiente:

Metadatos empresariales: Es la información que proporciona contexto empresarial, como la clasificación de datos.
Metadatos técnicos: Son los detalles técnicos sobre el activo de datos, por ejemplo, su esquema.
Metadatos derivados de los datos: Es la información que se genera a partir de los datos en sí, como las estadísticas de una tabla de BigQuery.

Se considera que los aspectos son partes del recurso de entrada y no recursos separados. Cuando modificas un aspecto, se modifica la entrada que lo contiene.

Puedes especificar aspectos a nivel de la entrada para describir una entrada o a nivel de la columna para describir una columna en 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.

Para una entrada determinada, puede haber como máximo un aspecto asociado a la entrada por tipo de aspecto. Puedes tener varios aspectos asociados con las columnas de entrada por tipo de aspecto.

Categorías de aspectos

Los aspectos se clasifican de la siguiente manera:

Aspectos obligatorios: Son los aspectos que se deben incluir cuando se crea una entrada. El tipo de entrada de una entrada determinada define estos aspectos. Todas las entradas que pertenecen a un tipo de entrada siempre deben tener todos los aspectos obligatorios que define ese tipo de entrada.

Dataplex Universal Catalog administra los aspectos requeridos (por ejemplo, el esquema) para las entradas del sistema.

Ten en cuenta lo siguiente:
- Solo puedes asociar aspectos obligatorios con las entradas y no con las columnas de una entrada.
- No puedes borrar los aspectos obligatorios de una entrada.
- Puedes leer los aspectos obligatorios de las entradas del sistema, pero no puedes modificarlos.
- Los aspectos de datos no pueden ser aspectos obligatorios.
Aspectos opcionales: Puedes asociar aspectos opcionales con entradas o con columnas de entrada. Puedes completar los aspectos opcionales en el momento de la creación de la entrada o más tarde actualizándola.

Puedes borrar aspectos opcionales después de que se hayan completado.

Aspectos de datos

Los aspectos pueden contener información derivada de los datos, como los resultados del perfil de datos o las consultas de ejemplo. Estos se conocen como aspectos de los datos.

Tipos de aspecto

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

Categorías de tipos de aspecto

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

Tipos de aspectos personalizados

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

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

Tipos de aspectos globales: Se pueden usar para crear aspectos para entradas en cualquier región. Elige un tipo de aspecto global si necesitas aplicar la misma estructura a las entradas en varias regiones, ya que solo necesitas definirla una vez. Dado que la definición de un tipo de aspecto global se replica en todas las regiones, es posible 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 para entradas que residen 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 en 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 garantizar que la definición del tipo de aspecto resida dentro de la región seleccionada, lo que puede ayudar a cumplir con los requisitos de soberanía y cumplimiento de datos. Si usas tipos de aspectos regionales, pero necesitas la misma estructura en varias regiones, debes crear y administrar definiciones de tipos de aspectos separadas en cada región.

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

Tipos de aspectos del sistema

Los tipos de aspectos que Dataplex Universal Catalog proporciona, usa y administra 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 administrado por Google con el número de proyecto 655216118709. Por ejemplo, projects/655216118709/locations/global/aspectTypes/schema

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-quality-scorecard` `generic` `overview` `schema` `usage`
Tipo de aspecto del sistema restringido	Dataplex Universal Catalog administra estos tipos de aspectos. Puedes leer aspectos de estos tipos de aspectos, pero no puedes crear ni editar aspectos de estos tipos de aspectos.	Incluidos, sin limitaciones, los siguientes: `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 comenzar

Antes de crear y administrar tipos y aspectos, completa las tareas que se describen en esta sección.

Roles obligatorios

Para obtener los permisos que necesitas para crear y administrar tipos y aspectos de aspectos, pídele a tu administrador que te otorgue los siguientes roles de IAM en el recurso:

Conjunto completo de permisos sobre los recursos de metadatos en Dataplex Universal Catalog, incluidos los tipos de aspectos y los aspectos de datos: Administrador del catálogo de Dataplex (roles/dataplex.catalogAdmin)
Crea y administra recursos de metadatos en Dataplex Universal Catalog, incluidos los tipos de aspectos y los aspectos de datos: Editor del catálogo de Dataplex (roles/dataplex.catalogEditor)
Conjunto completo de permisos sobre tipos de aspectos personalizados (excepto los permisos para usar tipos de aspectos para crear o editar entradas): Propietario de Tipos de aspecto de Dataplex (roles/dataplex.aspectTypeOwner)
Ver los tipos de aspectos y las políticas de IAM asociadas a ellos: Visualizador del catálogo de Dataplex (roles/dataplex.catalogViewer)
Usa tipos de aspectos para crear y modificar entradas con los aspectos correspondientes: Usuario de tipo de aspecto de Dataplex (roles/dataplex.aspectTypeUser)
Agrega aspectos de algunos de los tipos de aspectos del sistema, como schema, overview y contacts: Propietario de entrada y vínculo de entrada de Dataplex (roles/dataplex.entryOwner)

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

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

Para obtener más información, consulta Roles de IAM de Dataplex Universal Catalog.

Habilita la API

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

Habilitar la API

Crea un tipo de aspecto personalizado

Console

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

Ir al catálogo
Haz 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, ingresa lo siguiente:
1. Opcional: En el campo Nombre visible, ingresa un nombre para el tipo de aspecto.
2. En el campo ID de tipo de aspecto, ingresa un ID único para el tipo de aspecto.
3. Opcional: En el campo Descripción, ingresa una descripción para el tipo de aspecto.
4. 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 comprender el impacto de elegir una ubicación global en comparación con una 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 Agregar campo. En la sección Campo nuevo, ingresa lo siguiente:
1. En el campo Nombre, ingresa un nombre.
2. Opcional: En el campo Nombre visible, ingresa un nombre visible.
3. Opcional: en el campo Descripción, ingresa una descripción.
4. En el campo Tipo, selecciona un tipo de datos para el campo. Según tu selección, se mostrará el siguiente conjunto de campos y opciones:
  - Si seleccionaste Texto como el tipo de datos, sigue estos pasos:
    1. En el campo Tipo de texto, selecciona el tipo de texto.
    2. En el campo Valores de texto, proporciona una sugerencia para el campo de texto. Para ello, haz clic en Agregar valor y, luego, ingresa la sugerencia. Puedes agregar varias sugerencias para un campo de texto.
    3. Haz clic en Listo.
  - Si seleccionaste Enum como el tipo de datos, agrega un valor de enumeración:
    1. Haz clic en Agrega un valor de enum.
    2. En el campo Valor, ingresa un valor de enumeración. Puedes agregar varios valores de enumeración.
    3. Haz clic en Listo.
  - Si seleccionaste Array como el tipo de datos, en la sección Elemento del array, define los tipos de elementos que estarán presentes en el array:
    1. Haz clic en Agregar elemento de array.
    2. En el campo Nombre, ingresa un nombre para los elementos del array.
    3. Opcional: En el campo Nombre visible, ingresa un nombre visible para los elementos del array.
    4. Opcional: En el campo Descripción, ingresa una descripción para los elementos del array.
    5. En el campo Tipo, selecciona un tipo de datos para los elementos del array.
      
      Según tu selección, se mostrará el siguiente conjunto de campos y opciones. Son similares a las opciones que se describen para los tipos de datos Text, Enum, Map, Array y Record en otras partes de esta sección.
    6. Haz clic en Listo.
  - Si seleccionaste Mapa como el tipo de datos, en la sección Valor del mapa, define los tipos de valores que estarán presentes en el mapa:
    1. Haz clic en Agregar valor de mapa.
    2. En el campo Nombre, ingresa un nombre para el mapa.
    3. Opcional: En el campo Nombre visible, ingresa un nombre visible para el mapa.
    4. Opcional: En el campo Descripción, ingresa una descripción para el mapa.
    5. En el campo Tipo, selecciona un tipo de datos para el mapa.
      
      Según tu selección, se mostrará el siguiente conjunto de campos y opciones. Son similares a las opciones que se describen para los tipos de datos Text, Enum, Map, Array y Record en otras partes de esta sección.
    6. Haz clic en Listo.
  - Si seleccionaste Registro como el tipo de datos, ingresa lo siguiente:
    1. En el campo ID de registro, ingresa 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.
    2. Opcional: Si deseas agregar 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.
    3. En la sección Campos de registro, puedes definir un objeto complejo con varios campos anidados. Para ello, haz clic en Agregar elemento de campo de registro y especifica lo siguiente:
    4. En el campo Nombre, ingresa un nombre para el campo del registro.
    5. Opcional: En el campo Nombre visible, ingresa un nombre visible para el campo de registro.
    6. Opcional: En el campo Descripción, ingresa una descripción para el campo del registro.
    7. En el campo Tipo, selecciona un tipo de datos.
      
      Según tu selección, se mostrará el siguiente conjunto de campos y opciones. Son similares a las opciones descritas para los tipos de datos Text, Enum, Map, Array y Record que se mencionaron anteriormente en esta sección.
    8. Haz clic en Listo.
5. Para que el campo sea obligatorio para 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.
6. Haz clic en Listo.
7. Para agregar varios campos, haz clic en Agregar campo y repite los pasos anteriores.
Opcional: En la sección Etiquetas, agrega etiquetas arbitrarias como pares clave-valor a tus recursos:
1. Haz clic en Agregar etiqueta.
2. En el campo Clave, ingresa una clave.
3. En el campo Valor, ingresa un valor para la clave.
4. Para agregar más etiquetas, haz clic en Agregar 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 instrucciones de configuración para C# que se encuentran en la guía de inicio rápido del catálogo universal de Dataplex sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de C# de Dataplex Universal Catalog.

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

using Google.Api.Gax.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 instrucciones de configuración para Go que se encuentran en la guía de inicio rápido del catálogo universal de Dataplex sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Go de Dataplex Universal Catalog.


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 instrucciones de configuración para Java que se encuentran en la guía de inicio rápido del catálogo universal de Dataplex sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Java de Dataplex Universal Catalog.

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 instrucciones de configuración para Python que se encuentran en la guía de inicio rápido del catálogo universal de Dataplex sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Python de Dataplex Universal Catalog.

# 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 instrucciones de configuración para Ruby que se encuentran en la guía de inicio rápido del catálogo universal de Dataplex sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Ruby de Dataplex Universal Catalog.

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 agregar aspectos a las entradas.

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

Puedes 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:

Considera 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 dos campos de dirección Dirección actual y Dirección permanente son del mismo tipo de datos Record. Para evitar la duplicación, puedes establecer los valores de ID de registro y Referencia de registro cuando definas estos campos.

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

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

De esta manera, no es necesario que dupliques los campos de otra dirección.

Agrega aspectos a una entrada

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

Ten en cuenta lo siguiente:

Puedes agregar aspectos a una entrada o a las columnas de una entrada.
Solo puedes editar los aspectos obligatorios de las entradas personalizadas. No puedes borrar los aspectos obligatorios.
Puedes editar y borrar los aspectos opcionales de las entradas personalizadas y del sistema.

Console

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

Ir a Búsqueda
En Elige una plataforma de búsqueda, selecciona Dataplex Universal Catalog como el modo de búsqueda.
Busca la entrada a la que deseas agregar aspectos y haz clic en ella. Se abrirá la página de detalles de la entrada.
Para agregar aspectos a la entrada, sigue estos pasos:
1. Haz clic en la pestaña Detalles.
2. Para agregar aspectos obligatorios u opcionales a la entrada, en la sección Aspectos y etiquetas, haz clic en Agregar para la categoría correspondiente.
  No puedes agregar aspectos obligatorios si el tipo de entrada de la entrada seleccionada no tiene aspectos obligatorios definidos.
3. Busca y selecciona el aspecto que quieras agregar.
4. En la ventana Agregar aspecto, ingresa los valores de los campos.
5. Haz clic en Guardar.
Para agregar aspectos a una columna de la entrada, sigue estos pasos:
1. En la página de detalles de la entrada, haz clic en la pestaña Esquema.
2. Selecciona las columnas a las que deseas agregar aspectos.
3. Haz clic en Agregar aspecto.
4. Busca y selecciona el aspecto que quieras agregar.
5. En la ventana Agregar aspecto, ingresa los valores de los campos.
6. Haz clic en Guardar.

gcloud

Para agregar aspectos a una entrada o a 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);
    }
}

Para agregar 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 agregar aspectos al objeto de entrada, 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 agregar aspectos al objeto de entrada, consulta #required_aspects=.

REST

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

No se admite la creación ni el uso de aspectos en una entrada en la que el tipo de aspecto respectivo y la entrada se encuentran en diferentes organizaciones de Google Cloud .

Administra los aspectos existentes de una entrada

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

Actualiza un aspecto

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

Console

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

Ir a Búsqueda
En Elige una plataforma de búsqueda, selecciona Dataplex Universal Catalog como el modo de búsqueda.
Busca la entrada cuyos aspectos deseas actualizar y haz clic en ella.

Se abrirá la página de detalles de la entrada.
Haz clic en la pestaña Detalles.
En la sección Aspectos y etiquetas, expande el aspecto o la etiqueta que deseas 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 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 aspectos de una entrada o una columna de una entrada, usa el método entry.patch.

Borra un aspecto

Console

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

Ir a Búsqueda
En Elige una plataforma de búsqueda, selecciona Dataplex Universal Catalog como el modo de búsqueda.
Busca la entrada cuyos aspectos quieres borrar y haz clic en ella.

Se abrirá la página de detalles de la entrada.
Haz clic en la pestaña Detalles.
En la sección Aspectos y etiquetas, expande el aspecto o la etiqueta que deseas borrar y haz clic en Borrar.
Haz clic en Confirmar.

gcloud

Para borrar un aspecto 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 borrar un aspecto de una entrada, usa el método entry.patch.

Administra tipos de aspectos

En esta sección, se describe cómo ver, actualizar y borrar tipos de aspectos.

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

Console

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

Ir al catálogo
Haz 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 personalizados, haz clic en la pestaña Personalizado. En la pestaña Personalizado, la columna Fuente del catálogo muestra dónde reside el recurso: Dataplex Universal Catalog o Data Catalog.

Para ver los tipos de aspectos del sistema, haz 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 en el proyecto seleccionado, haz clic en la pestaña Personalizado y, luego, en el botón de activación Mostrar desde todos los proyectos para desactivarlo.

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

Nota: Si el botón de activación Mostrar de todos los proyectos está activado, no puedes editar ni borrar un tipo de aspecto directamente. En su lugar, haz clic en el tipo de aspecto para abrir la página Detalles del tipo de aspecto y, luego, edítalo o bórralo.

gcloud

Para enumerar 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.

Cómo ver los detalles de un tipo de aspecto o una plantilla de etiqueta

Console

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

Ir al catálogo
Haz 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 abrirá la página de detalles del tipo de aspecto, en la que podrás 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, haz 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, haz clic en ella. Se abrirá la página de detalles de la plantilla de etiqueta en Data Catalog, donde podrás 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.

Actualiza un tipo de aspecto personalizado

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

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

Console

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

Ir al catálogo
Haz clic en la pestaña Tipos de aspecto y plantillas de etiquetas.
Haz clic en el tipo de aspecto que deseas actualizar.
En la página Detalles del tipo de aspecto, haz clic en Editar.
Edita el nombre visible, la descripción, los campos de la plantilla y las etiquetas según sea necesario.
Opcional: Para marcar un campo en el tipo de aspecto como obsoleto, sigue estos pasos:
1. En la sección Plantilla, expande el campo.
2. Selecciona Is Deprecated.
3. En el campo Motivo de la baja, ingresa un motivo para dar de baja el campo seleccionado.
4. Haz clic en Listo.
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.

Borra un tipo de aspecto personalizado

Console

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

Ir al catálogo
Haz clic en la pestaña Tipos de aspecto y plantillas de etiquetas.
Haz clic en el tipo de aspecto que deseas borrar.
En la página Detalles del tipo de aspecto, haz clic en Borrar. Confirma cuando se te solicite.

gcloud

Para borrar 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 borrar un tipo de aspecto personalizado existente, usa el método aspectTypes.delete.

¿Qué sigue?

Aprende a buscar recursos de datos en Dataplex Universal Catalog.
Obtén más información para administrar entradas y transferir fuentes personalizadas.
Aprende a importar metadatos a Dataplex Universal Catalog.
Obtén más información sobre la administración de metadatos en Dataplex Universal Catalog.
Obtén más información para migrar de Data Catalog a Dataplex Universal Catalog.
Sigue un codelab: Gobernanza fundamental con Dataplex Universal Catalog.

Administra aspectos y enriquece metadatos Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Aspectos

Categorías de aspectos

Aspectos de datos

Tipos de aspecto

Categorías de tipos de aspecto

Tipos de aspectos personalizados

Tipos de aspectos del sistema

Antes de comenzar

Roles obligatorios

Habilita la API

Crea un tipo de aspecto personalizado

Console

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

Agrega aspectos a una entrada

Console

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Administra los aspectos existentes de una entrada

Actualiza un aspecto

Console

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Borra un aspecto

Console

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Administra tipos de aspectos

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

Console

gcloud

C#

C#

Go

Go

Java

Java

Python

Administra aspectos y enriquece metadatos