Guía de inicio rápido para etiquetar tablas

En esta guía de inicio rápido:

  1. Crea un conjunto de datos de BigQuery y, luego, copia los datos de taxi público a una nueva tabla en tu conjunto de datos.
  2. Crea una plantilla de etiqueta con un esquema que defina cuatro campos de etiqueta de tipos distintos (string, double, boolean y enumerated).
  3. Busque la entrada del Data Catalog para su tabla.
  4. Adjunte la etiqueta a su tabla.

Antes de comenzar

  1. Configura tu proyecto:

    1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
    2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

      Ir al selector de proyectos

    3. Habilita las API de Data Catalog and BigQuery.

      Habilita las API

    4. Instala e inicializa el SDK de Cloud.
    5. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

      Ir al selector de proyectos

    6. Habilita las API de Data Catalog and BigQuery.

      Habilita las API

    7. Instala e inicializa el SDK de Cloud.

  2. Agrega un conjunto de datos públicos a tu proyecto.

    1. Ve a BigQuery en Google Cloud Console.
    2. En el panel Explorador de la izquierda, haz clic en + AGREGAR DATOS y selecciona Explorar conjuntos de datos públicos en la lista desplegable.

      Explora conjuntos de datos públicos

    3. En el panel Conjuntos de datos, busca “viajes en taxi en Nueva York” y haz clic en el resultado de la búsqueda relevante.

    4. En el panel Descripción general del conjunto de datos, haga clic en VER CONJUNTO DE DATOS.

  3. Crear un nuevo conjunto de datos. Debes ser el propietario del conjunto de datos para adjuntar una etiqueta a una tabla en el conjunto de datos como se muestra en esta guía de inicio rápido.

    1. Desde BigQuery en Google Cloud Console
    2. En el panel Explorador izquierdo, haga clic en el ID de su proyecto y, luego, en CREAR CONJUNTO DE DATOS.
    3. En el diálogo Crear conjunto de datos, realiza lo siguiente:
      • En ID del conjunto de datos, ingrese "demo_dataset".
      • Para Ubicación de datos, acepta la ubicación predeterminada, que establece la ubicación del conjunto de datos en US multi-region.
      • En Vencimiento predeterminado de datos, elige una de las siguientes opciones:
        • Never: (Predeterminado) las tablas creadas en el conjunto de datos nunca se borran de manera automática. Debes borrarlas tú mismo.
        • Cantidad de días después de la creación de la tabla: Cualquier tabla creada en el conjunto de datos se elimina después de los días especificados desde su creación. Este valor se aplica si no estableces el vencimiento de la tabla cuando la creas.
      • En Encriptación, deje seleccionada la opción Clave administrada por Google.
      • Haga clic en Crear conjunto de datos.
  4. Copia una tabla pública de taxis de Nueva York en tu demo_dataset.

    1. En BigQuery, en Google Cloud Console, en el panel Explorador de la izquierda, busca las tablas “tlc_yellow_trips” y selecciona una de ellas, como tlc_yellow_trips_2017. Luego, haga clic en COPIAR.
    2. En la sección Destino del cuadro de diálogo Copiar tabla, realiza lo siguiente:

      1. Selecciona tu proyecto en la lista desplegable Nombre del proyecto.
      2. Seleccione "demo_dataset" en la lista desplegable Nombre del conjunto de datos.
      3. Ingrese “viajes” en el campo Nombre de la tabla (Table name) y haga clic en COPIAR (COPY).
    3. En el panel Explorador de la izquierda, confirme que la tabla trips aparezca en su conjunto de datos demo_dataset.

      Agrega etiquetas de Data Catalog a la tabla en la siguiente sección.

Crea una plantilla de etiqueta y adjunta la etiqueta a tu tabla

Console

Puedes crear una plantilla de etiqueta desde la IU de Data Catalog en Google Cloud Console. Para crear una etiqueta, haz lo siguiente:

  1. Abre la pestaña Plantillas de etiquetas en el menú de la izquierda y haz clic en el botón CREAR PLANTILLA DE ETIQUETA (CREATE TAG TEMPLATE) en la barra de acciones superior.
  2. Complete el formulario de la plantilla para definir una “Plantilla de etiqueta de demostración”. Por ejemplo:
    1. ID de plantilla: demo_tag_template
    2. Nombre comercial de la plantilla: Demo Tag Template
    3. Ubicación: Selecciona una ubicación de la lista desplegable.
  3. A continuación, cree cuatro campos de etiqueta. Haz clic en “Agregar campo” (Add field) para abrir el diálogo New field. Crea cuatro campos con los valores que se enumeran a continuación. Ten en cuenta que el campo “fuente” define un campo de etiqueta obligatorio.
      • ID del campo: source
      • Hacer que este campo sea obligatorio: Checked
      • Nombre visible del campo: Source of data asset
      • Tipo: String
      • Haga clic en Done
      • ID del campo: num_rows
      • Hacer que este campo sea obligatorio: Not checked
      • Nombre visible del campo: Number of rows in the data asset
      • Tipo: Double
      • Haga clic en Done
      • ID del campo: has_pii
      • Hacer que este campo sea obligatorio: Not checked
      • Nombre visible del campo: Has PII
      • Tipo: Boolean
      • Haga clic en Done
      • ID del campo: pii_type
      • Hacer que este campo sea obligatorio: Not checked
      • Nombre visible del campo: PII type
      • Tipo: Enumerated
        Agrega 3 valores:
        1. Dirección de correo electrónico
        2. US_SOCIAL_SECURITY_NUMBER
        3. NINGUNO
      • Haga clic en Done

    El formulario de plantilla de etiqueta que se completó debe enumerar los cuatro atributos de etiqueta:

    Haz clic en CREAR. La página Plantilla de etiqueta de Data Catalog muestra los campos y detalles de la plantilla.

  4. Para adjuntar una etiqueta a una tabla de su conjunto de datos, haga lo siguiente:
    1. En la página principal de Data Catalog, verifica tu proyecto en el panel Filtros > Proyectos .
    2. Inserte "demo_dataset" en el cuadro de búsqueda y haga clic en BUSCAR .
  5. La tabla demo_dataset y trips que copiaste en el conjunto de datos se muestran en los resultados de búsqueda. Haz clic en el vínculo trips.
  6. Se abre la página Información de las entradas (Entry details). Haz clic en Adjuntar etiquetas (Attach Tags).
  7. En el panel Adjuntar etiquetas, sigue estos pasos:
    1. En Elegir qué etiquetar, selecciona la tabla trips y haz clic en Aceptar.
    2. En Elige las plantillas de etiquetas (Choose the tag templates), busca y selecciona Demo Tag Template, y, luego, haz clic en Aceptar.
    3. En Completar valores de etiqueta, completa los siguientes valores para cada campo:
      • Fuente del recurso de datos: Copied from tlc_yellow_trips_2017
      • Cantidad de filas en el recurso de datos: 113496874
      • Has PII: FALSE
      • Tipo de PII: NONE

      Haz clic en Save. Los campos de etiqueta ahora se enumeran en la sección Etiquetas debajo de Detalles del conjunto de datos de BigQuery.

gcloud

Ejecuta el comando de gcloud data-catalog tag-templates create que se muestra a continuación para crear una plantilla de etiqueta con los siguientes cuatro campos de etiqueta (también llamados “atributos”):

  1. display_name: Source of data asset
    id: source
    required: TRUE
    type: String
  2. display_name: Number of rows in the data asset
    id: num_rows
    required: FALSE
    type: Double
  3. display_name: Has PII
    id: has_pii
    required: FALSE
    type: Boolean
  4. display_name: PII type
    id: pii_type
    required: FALSE
    type: Enumerated
    values:
    1. Dirección de correo electrónico
    2. US_SOCIAL_SECURITY_NUMBER
    3. NINGUNO
# -------------------------------
# Create a Tag Template.
# -------------------------------
gcloud data-catalog tag-templates create demo_template \
    --location=us-central1 \
    --display-name="Demo Tag Template" \
    --field=id=source,display-name="Source of data asset",type=string,required=TRUE \
    --field=id=num_rows,display-name="Number of rows in the data asset",type=double \
    --field=id=has_pii,display-name="Has PII",type=bool \
    --field=id=pii_type,display-name="PII type",type='enum(EMAIL_ADDRESS|US_SOCIAL_SECURITY_NUMBER|NONE)'

# -------------------------------
# Lookup the Data Catalog entry for the table.
# -------------------------------
ENTRY_NAME=$(gcloud data-catalog entries lookup '//bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET/tables/TABLE' --format="value(name)")

# -------------------------------
# Attach a Tag to the table.
# -------------------------------

# Create the Tag file.
cat > tag_file.json << EOF
  {
    "source": "BigQuery",
    "num_rows": 1000,
    "has_pii": true,
    "pii_type": "EMAIL_ADDRESS"
  }
EOF

gcloud data-catalog tags create --entry=${ENTRY_NAME} \
    --tag-template=demo_template --tag-template-location=us-central1 --tag-file=tag_file.json

Go

Antes de probar esta muestra, sigue las instrucciones de configuración para Go que se encuentran en la guía de inicio rápido de Data Catalog mediante bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Data Catalog de Go.


// The datacatalog_quickstart application demonstrates how to define a tag
// template, populate values in the template, and attach a tag based on the
// template to a BigQuery table.
package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"strings"
	"time"

	datacatalog "cloud.google.com/go/datacatalog/apiv1"
	datacatalogpb "google.golang.org/genproto/googleapis/cloud/datacatalog/v1"
)

func main() {
	projectID := flag.String("project_id", "", "Cloud Project ID, used for session creation.")
	location := flag.String("location", "us-central1", "data catalog region to use for the quickstart")
	table := flag.String("table", "myproject.mydataset.mytable", "bigquery table to tag in project.dataset.table format")

	flag.Parse()

	ctx := context.Background()
	client, err := datacatalog.NewClient(ctx)
	if err != nil {
		log.Fatalf("datacatalog.NewClient: %v", err)
	}
	defer client.Close()

	// Create the tag template.
	tmpl, err := createQuickstartTagTemplate(ctx, client, *projectID, *location)
	if err != nil {
		log.Fatalf("createQuickstartTagTemplate: %v", err)
	}
	fmt.Printf("Created tag template: %s\n", tmpl.GetName())

	// Convert a BigQuery resource identifier into the equivalent datacatalog
	// format.
	resource, err := convertBigQueryResourceRepresentation(*table)
	if err != nil {
		log.Fatalf("couldn't parse --table flag (%s): %v", *table, err)
	}

	// Lookup the entry metadata for the BQ table resource.
	entry, err := client.LookupEntry(ctx, &datacatalogpb.LookupEntryRequest{
		TargetName: &datacatalogpb.LookupEntryRequest_LinkedResource{
			LinkedResource: resource,
		},
	})
	if err != nil {
		log.Fatalf("client.LookupEntry: %v", err)
	}
	fmt.Printf("Successfully looked up table entry: %s\n", entry.GetName())

	// Create a tag based on the template, and apply it to the entry.
	tag, err := createQuickstartTag(ctx, client, "my-quickstart-tag", tmpl.GetName(), entry.GetName())
	if err != nil {
		log.Fatalf("couldn't create tag: %v", err)
	}
	fmt.Printf("Created tag: %s", tag.GetName())
}

// createQuickstartTagTemplate registers a tag template in datacatalog.
func createQuickstartTagTemplate(ctx context.Context, client *datacatalog.Client, projectID, location string) (*datacatalogpb.TagTemplate, error) {
	loc := fmt.Sprintf("projects/%s/locations/%s", projectID, location)

	// Define the tag template.
	template := &datacatalogpb.TagTemplate{
		DisplayName: "Quickstart Tag Template",
		Fields: map[string]*datacatalogpb.TagTemplateField{
			"source": {
				DisplayName: "Source of data asset",
				Type: &datacatalogpb.FieldType{
					TypeDecl: &datacatalogpb.FieldType_PrimitiveType_{
						PrimitiveType: datacatalogpb.FieldType_STRING,
					},
				},
			},
			"num_rows": {
				DisplayName: "Number of rows in data asset",
				Type: &datacatalogpb.FieldType{
					TypeDecl: &datacatalogpb.FieldType_PrimitiveType_{
						PrimitiveType: datacatalogpb.FieldType_DOUBLE,
					},
				},
			},
			"has_pii": {
				DisplayName: "Has PII",
				Type: &datacatalogpb.FieldType{
					TypeDecl: &datacatalogpb.FieldType_PrimitiveType_{
						PrimitiveType: datacatalogpb.FieldType_BOOL,
					},
				},
			},
			"pii_type": {
				DisplayName: "PII Type",
				Type: &datacatalogpb.FieldType{
					TypeDecl: &datacatalogpb.FieldType_EnumType_{
						EnumType: &datacatalogpb.FieldType_EnumType{
							AllowedValues: []*datacatalogpb.FieldType_EnumType_EnumValue{
								{DisplayName: "EMAIL"},
								{DisplayName: "SOCIAL SECURITY NUMBER"},
								{DisplayName: "NONE"},
							},
						},
					},
				},
			},
		},
	}

	//Construct the creation request using the template definition.
	req := &datacatalogpb.CreateTagTemplateRequest{
		Parent:        loc,
		TagTemplateId: "quickstart_tag_template",
		TagTemplate:   template,
	}

	return client.CreateTagTemplate(ctx, req)

}

// createQuickstartTag populates tag values according to the template, and attaches
// the tag to the designeated entry.
func createQuickstartTag(ctx context.Context, client *datacatalog.Client, tagID, templateName, entryName string) (*datacatalogpb.Tag, error) {
	tag := &datacatalogpb.Tag{
		Name:     fmt.Sprintf("%s/tags/%s", entryName, tagID),
		Template: templateName,
		Fields: map[string]*datacatalogpb.TagField{
			"source": {
				Kind: &datacatalogpb.TagField_StringValue{StringValue: "Copied from tlc_yellow_trips_2018"},
			},
			"num_rows": {
				Kind: &datacatalogpb.TagField_DoubleValue{DoubleValue: 113496874},
			},
			"has_pii": {
				Kind: &datacatalogpb.TagField_BoolValue{BoolValue: false},
			},
			"pii_type": {
				Kind: &datacatalogpb.TagField_EnumValue_{
					EnumValue: &datacatalogpb.TagField_EnumValue{
						DisplayName: "NONE",
					},
				},
			},
		},
	}

	req := &datacatalogpb.CreateTagRequest{
		Parent: entryName,
		Tag:    tag,
	}
	return client.CreateTag(ctx, req)
}

// convertBigQueryResourceRepresentation converts a table identifier in standard sql form
// (project.datadata.table) into the representation used within data catalog.
func convertBigQueryResourceRepresentation(table string) (string, error) {
	parts := strings.Split(table, ".")
	if len(parts) != 3 {
		return "", fmt.Errorf("specified table string is not in expected project.dataset.table format: %s", table)
	}
	return fmt.Sprintf("//bigquery.googleapis.com/projects/%s/datasets/%s/tables/%s", parts[0], parts[1], parts[2]), nil
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración para Java que se encuentran en la guía de inicio rápido de Data Catalog mediante bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Data Catalog para Java.

import com.google.cloud.datacatalog.v1.CreateTagRequest;
import com.google.cloud.datacatalog.v1.CreateTagTemplateRequest;
import com.google.cloud.datacatalog.v1.DataCatalogClient;
import com.google.cloud.datacatalog.v1.Entry;
import com.google.cloud.datacatalog.v1.FieldType;
import com.google.cloud.datacatalog.v1.FieldType.EnumType;
import com.google.cloud.datacatalog.v1.FieldType.EnumType.EnumValue;
import com.google.cloud.datacatalog.v1.FieldType.PrimitiveType;
import com.google.cloud.datacatalog.v1.LocationName;
import com.google.cloud.datacatalog.v1.LookupEntryRequest;
import com.google.cloud.datacatalog.v1.Tag;
import com.google.cloud.datacatalog.v1.TagField;
import com.google.cloud.datacatalog.v1.TagTemplate;
import com.google.cloud.datacatalog.v1.TagTemplateField;
import java.io.IOException;

public class Quickstart {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String tagTemplateId = "my_tag_template";
    createTags(projectId, tagTemplateId);
  }

  public static void createTags(String projectId, String tagTemplateId) throws IOException {
    // Currently, Data Catalog stores metadata in the us-central1 region.
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DataCatalogClient dataCatalogClient = DataCatalogClient.create()) {

      // -------------------------------
      // Create a Tag Template.
      // -------------------------------
      TagTemplateField sourceField =
          TagTemplateField.newBuilder()
              .setDisplayName("Source of data asset")
              .setType(FieldType.newBuilder().setPrimitiveType(PrimitiveType.STRING).build())
              .build();

      TagTemplateField numRowsField =
          TagTemplateField.newBuilder()
              .setDisplayName("Number of rows in data asset")
              .setType(FieldType.newBuilder().setPrimitiveType(PrimitiveType.DOUBLE).build())
              .build();

      TagTemplateField hasPiiField =
          TagTemplateField.newBuilder()
              .setDisplayName("Has PII")
              .setType(FieldType.newBuilder().setPrimitiveType(PrimitiveType.BOOL).build())
              .build();

      TagTemplateField piiTypeField =
          TagTemplateField.newBuilder()
              .setDisplayName("PII type")
              .setType(
                  FieldType.newBuilder()
                      .setEnumType(
                          EnumType.newBuilder()
                              .addAllowedValues(
                                  EnumValue.newBuilder().setDisplayName("EMAIL").build())
                              .addAllowedValues(
                                  EnumValue.newBuilder()
                                      .setDisplayName("SOCIAL SECURITY NUMBER")
                                      .build())
                              .addAllowedValues(
                                  EnumValue.newBuilder().setDisplayName("NONE").build())
                              .build())
                      .build())
              .build();

      TagTemplate tagTemplate =
          TagTemplate.newBuilder()
              .setDisplayName("Demo Tag Template")
              .putFields("source", sourceField)
              .putFields("num_rows", numRowsField)
              .putFields("has_pii", hasPiiField)
              .putFields("pii_type", piiTypeField)
              .build();

      CreateTagTemplateRequest createTagTemplateRequest =
          CreateTagTemplateRequest.newBuilder()
              .setParent(
                  LocationName.newBuilder()
                      .setProject(projectId)
                      .setLocation(location)
                      .build()
                      .toString())
              .setTagTemplateId(tagTemplateId)
              .setTagTemplate(tagTemplate)
              .build();

      // Create the Tag Template.
      tagTemplate = dataCatalogClient.createTagTemplate(createTagTemplateRequest);

      // -------------------------------
      // Lookup Data Catalog's Entry referring to the table.
      // -------------------------------
      String linkedResource =
          String.format(
              "//bigquery.googleapis.com/projects/%s/datasets/test_dataset/tables/test_table",
              projectId);
      LookupEntryRequest lookupEntryRequest =
          LookupEntryRequest.newBuilder().setLinkedResource(linkedResource).build();
      Entry tableEntry = dataCatalogClient.lookupEntry(lookupEntryRequest);

      // -------------------------------
      // Attach a Tag to the table.
      // -------------------------------
      TagField sourceValue =
          TagField.newBuilder().setStringValue("Copied from tlc_yellow_trips_2017").build();
      TagField numRowsValue = TagField.newBuilder().setDoubleValue(113496874).build();
      TagField hasPiiValue = TagField.newBuilder().setBoolValue(false).build();
      TagField piiTypeValue =
          TagField.newBuilder()
              .setEnumValue(TagField.EnumValue.newBuilder().setDisplayName("NONE").build())
              .build();

      Tag tag =
          Tag.newBuilder()
              .setTemplate(tagTemplate.getName())
              .putFields("source", sourceValue)
              .putFields("num_rows", numRowsValue)
              .putFields("has_pii", hasPiiValue)
              .putFields("pii_type", piiTypeValue)
              .build();

      CreateTagRequest createTagRequest =
          CreateTagRequest.newBuilder().setParent(tableEntry.getName()).setTag(tag).build();

      dataCatalogClient.createTag(createTagRequest);
      System.out.printf("Tag created successfully");
    }
  }
}

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración para Node.js que se encuentran en la guía de inicio rápido de Data Catalog mediante bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Data Catalog de Node.js.

// Import the Google Cloud client library and create a client.
const {DataCatalogClient} = require('@google-cloud/datacatalog').v1;
const datacatalog = new DataCatalogClient();

async function quickstart() {
  // Common fields.
  let request;
  let responses;

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const projectId = 'my_project'; // Google Cloud Platform project
  // const datasetId = 'demo_dataset';
  // const tableId = 'trips';

  // Currently, Data Catalog stores metadata in the
  // us-central1 region.
  const location = 'us-central1';

  // Create Fields.
  const fieldSource = {
    displayName: 'Source of data asset',
    type: {
      primitiveType: 'STRING',
    },
  };

  const fieldNumRows = {
    displayName: 'Number of rows in data asset',
    type: {
      primitiveType: 'DOUBLE',
    },
  };

  const fieldHasPII = {
    displayName: 'Has PII',
    type: {
      primitiveType: 'BOOL',
    },
  };

  const fieldPIIType = {
    displayName: 'PII type',
    type: {
      enumType: {
        allowedValues: [
          {
            displayName: 'EMAIL',
          },
          {
            displayName: 'SOCIAL SECURITY NUMBER',
          },
          {
            displayName: 'NONE',
          },
        ],
      },
    },
  };

  // Create Tag Template.
  const tagTemplateId = 'demo_tag_template';

  const tagTemplate = {
    displayName: 'Demo Tag Template',
    fields: {
      source: fieldSource,
      num_rows: fieldNumRows,
      has_pii: fieldHasPII,
      pii_type: fieldPIIType,
    },
  };

  const tagTemplatePath = datacatalog.tagTemplatePath(
    projectId,
    location,
    tagTemplateId
  );

  // Delete any pre-existing Template with the same name.
  try {
    request = {
      name: tagTemplatePath,
      force: true,
    };
    await datacatalog.deleteTagTemplate(request);
    console.log(`Deleted template: ${tagTemplatePath}`);
  } catch (error) {
    console.log(`Cannot delete template: ${tagTemplatePath}`);
  }

  // Create the Tag Template request.
  const locationPath = datacatalog.locationPath(projectId, location);

  request = {
    parent: locationPath,
    tagTemplateId: tagTemplateId,
    tagTemplate: tagTemplate,
  };

  // Execute the request.
  responses = await datacatalog.createTagTemplate(request);
  const createdTagTemplate = responses[0];
  console.log(`Created template: ${createdTagTemplate.name}`);

  // Lookup Data Catalog's Entry referring to the table.
  responses = await datacatalog.lookupEntry({
    linkedResource:
      '//bigquery.googleapis.com/projects/' +
      `${projectId}/datasets/${datasetId}/tables/${tableId}`,
  });
  const entry = responses[0];
  console.log(`Entry name: ${entry.name}`);
  console.log(`Entry type: ${entry.type}`);
  console.log(`Linked resource: ${entry.linkedResource}`);

  // Attach a Tag to the table.
  const tag = {
    name: entry.name,
    template: createdTagTemplate.name,
    fields: {
      source: {
        stringValue: 'copied from tlc_yellow_trips_2017',
      },
      num_rows: {
        doubleValue: 113496874,
      },
      has_pii: {
        boolValue: false,
      },
      pii_type: {
        enumValue: {
          displayName: 'NONE',
        },
      },
    },
  };

  request = {
    parent: entry.name,
    tag: tag,
  };

  // Create the Tag.
  await datacatalog.createTag(request);
  console.log(`Tag created for entry: ${entry.name}`);
}
quickstart();

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la guía de inicio rápido de Data Catalog mediante bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Data Catalog de Python.

# Import required modules.
from google.cloud import datacatalog_v1

# TODO: Set these values before running the sample.
# Google Cloud Platform project.
project_id = "my_project"
# Set dataset_id to the ID of existing dataset.
dataset_id = "demo_dataset"
# Set table_id to the ID of existing table.
table_id = "trips"
# Tag template to create.
tag_template_id = "example_tag_template"

# For all regions available, see:
# https://cloud.google.com/data-catalog/docs/concepts/regions
location = "us-central1"

# Use Application Default Credentials to create a new
# Data Catalog client. GOOGLE_APPLICATION_CREDENTIALS
# environment variable must be set with the location
# of a service account key file.
datacatalog_client = datacatalog_v1.DataCatalogClient()

# Create a Tag Template.
tag_template = datacatalog_v1.types.TagTemplate()

tag_template.display_name = "Demo Tag Template"

tag_template.fields["source"] = datacatalog_v1.types.TagTemplateField()
tag_template.fields["source"].display_name = "Source of data asset"
tag_template.fields[
    "source"
].type_.primitive_type = datacatalog_v1.types.FieldType.PrimitiveType.STRING

tag_template.fields["num_rows"] = datacatalog_v1.types.TagTemplateField()
tag_template.fields["num_rows"].display_name = "Number of rows in data asset"
tag_template.fields[
    "num_rows"
].type_.primitive_type = datacatalog_v1.types.FieldType.PrimitiveType.DOUBLE

tag_template.fields["has_pii"] = datacatalog_v1.types.TagTemplateField()
tag_template.fields["has_pii"].display_name = "Has PII"
tag_template.fields[
    "has_pii"
].type_.primitive_type = datacatalog_v1.types.FieldType.PrimitiveType.BOOL

tag_template.fields["pii_type"] = datacatalog_v1.types.TagTemplateField()
tag_template.fields["pii_type"].display_name = "PII type"

for display_name in ["EMAIL", "SOCIAL SECURITY NUMBER", "NONE"]:
    enum_value = datacatalog_v1.types.FieldType.EnumType.EnumValue(
        display_name=display_name
    )
    tag_template.fields["pii_type"].type_.enum_type.allowed_values.append(
        enum_value
    )

expected_template_name = datacatalog_v1.DataCatalogClient.tag_template_path(
    project_id, location, tag_template_id
)

# Create the Tag Template.
try:
    tag_template = datacatalog_client.create_tag_template(
        parent=f"projects/{project_id}/locations/{location}",
        tag_template_id=tag_template_id,
        tag_template=tag_template,
    )
    print(f"Created template: {tag_template.name}")
except OSError as e:
    print(f"Cannot create template: {expected_template_name}")
    print(f"{e}")

# Lookup Data Catalog's Entry referring to the table.
resource_name = (
    f"//bigquery.googleapis.com/projects/{project_id}"
    f"/datasets/{dataset_id}/tables/{table_id}"
)
table_entry = datacatalog_client.lookup_entry(
    request={"linked_resource": resource_name}
)

# Attach a Tag to the table.
tag = datacatalog_v1.types.Tag()

tag.template = tag_template.name
tag.name = "my_super_cool_tag"

tag.fields["source"] = datacatalog_v1.types.TagField()
tag.fields["source"].string_value = "Copied from tlc_yellow_trips_2018"

tag.fields["num_rows"] = datacatalog_v1.types.TagField()
tag.fields["num_rows"].double_value = 113496874

tag.fields["has_pii"] = datacatalog_v1.types.TagField()
tag.fields["has_pii"].bool_value = False

tag.fields["pii_type"] = datacatalog_v1.types.TagField()
tag.fields["pii_type"].enum_value.display_name = "NONE"

tag = datacatalog_client.create_tag(parent=table_entry.name, tag=tag)
print(f"Created tag: {tag.name}")

LÍNEA DE REST Y CMD

LÍNEA DE REST Y CMD

Si no tienes acceso a las bibliotecas cliente de Cloud en tu idioma o quieres probar la API con solicitudes de REST, consulta los siguientes ejemplos y la documentación de la API de REST de Data Catalog.

1. Crea una plantilla de etiqueta.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • project-id: Es el ID del proyecto de GCP.

Método HTTP y URL:

POST https://datacatalog.googleapis.com/v1/projects/project-id/locations/us-central1/tagTemplates?tagTemplateId=demo_tag_template

Cuerpo JSON de la solicitud:


{
  "displayName":"Demo Tag Template",
  "fields":{
    "source":{
      "displayName":"Source of data asset",
      "isRequired": "true",
      "type":{
        "primitiveType":"STRING"
      }
    },
    "num_rows":{
      "displayName":"Number of rows in data asset",
      "isRequired": "false",
      "type":{
        "primitiveType":"DOUBLE"
      }
    },
    "has_pii":{
      "displayName":"Has PII",
      "isRequired": "false",
      "type":{
        "primitiveType":"BOOL"
      }
    },
    "pii_type":{
      "displayName":"PII type",
      "isRequired": "false",
      "type":{
        "enumType":{
          "allowedValues":[
            {
              "displayName":"EMAIL_ADDRESS"
            },
            {
              "displayName":"US_SOCIAL_SECURITY_NUMBER"
            },
            {
              "displayName":"NONE"
            }
          ]
        }
      }
    }
  }
}

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name":"projects/project-id/locations/us-central1/tagTemplates/demo_tag_template",
  "displayName":"Demo Tag Template",
  "fields":{
    "num_rows":{
      "displayName":"Number of rows in data asset",
      "isRequired": "false",
      "type":{
        "primitiveType":"DOUBLE"
      }
    },
    "has_pii":{
      "displayName":"Has PII",
      "isRequired": "false",
      "type":{
        "primitiveType":"BOOL"
      }
    },
    "pii_type":{
      "displayName":"PII type",
      "isRequired": "false",
      "type":{
        "enumType":{
          "allowedValues":[
            {
              "displayName":"EMAIL_ADDRESS"
            },
            {
              "displayName":"NONE"
            },
            {
              "displayName":"US_SOCIAL_SECURITY_NUMBER"
            }
          ]
        }
      }
    },
    "source":{
      "displayName":"Source of data asset",
      "isRequired":"true",
      "type":{
        "primitiveType":"STRING"
      }
    }
  }
}

2 Busca el Data Catalog entry-id para tu tabla de BigQuery.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • project-id: ID del proyecto de GCP

Método HTTP y URL:

GET https://datacatalog.googleapis.com/v1/entries:lookup?linkedResource=//bigquery.googleapis.com/projects/project-id/datasets/demo_dataset/tables/trips

Cuerpo JSON de la solicitud:

Request body is empty.

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name": "projects/project-id/locations/US/entryGroups/@bigquery/entries/entry-id",
  "type": "TABLE",
  "schema": {
    "columns": [
      {
        "type": "STRING",
        "description": "A code indicating the TPEP provider that provided the record. 1= ",
        "mode": "REQUIRED",
        "column": "vendor_id"
      },
      ...
    ]
  },
  "sourceSystemTimestamps": {
    "createTime": "2019-01-25T01:45:29.959Z",
    "updateTime": "2019-03-19T23:20:26.540Z"
  },
  "linkedResource": "//bigquery.googleapis.com/projects/project-id/datasets/demo_dataset/tables/trips",
  "bigqueryTableSpec": {
    "tableSourceType": "BIGQUERY_TABLE"
  }
}

3. Crea una etiqueta a partir de la plantilla y adjúntala a tu tabla BigQuery.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • project-id: ID del proyecto de GCP
  • entry-id: ID de entrada de Data Catalog para la tabla de viajes del conjunto de datos de demostración (que se muestra en los resultados de la búsqueda en el paso anterior).

Método HTTP y URL:

POST https://datacatalog.googleapis.com/v1/projects/project-id/locations/us-central1/entryGroups/@bigquery/entries/entry-id/tags

Cuerpo JSON de la solicitud:

{
  "template":"projects/project-id/locations/us-central1/tagTemplates/demo_tag_template",
  "fields":{
    "source":{
      "stringValue":"Copied from tlc_yellow_trips_2017"
    },
    "num_rows":{
      "doubleValue":113496874
    },
    "has_pii":{
      "boolValue":false
    },
    "pii_type":{
      "enumValue":{
        "displayName":"NONE"
      }
    }
  }
}

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name":"projects/project-id/locations/US/entryGroups/@bigquery/entries/entry-id/tags/tag-id",
  "template":"projects/project-id/locations/us-central1/tagTemplates/demo_tag_template",
  "fields":{
    "pii_type":{
      "displayName":"PII type",
      "enumValue":{
        "displayName":"NONE"
      }
    },
    "has_pii":{
      "displayName":"Has PII",
      "boolValue":false
    },
    "source":{
      "displayName":"Source of data asset",
      "stringValue":"Copied from tlc_yellow_trips_2017"
    },
    "num_rows":{
      "displayName":"Number of rows in data asset",
      "doubleValue":113496874
    }
  },
  "templateDisplayName":"Demo Tag Template"
}
Precaución: Renombra la tabla en BigQuery borra todas las etiquetas adjuntas a ella y a sus columnas.

Limpia

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, sigue estos pasos:

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Elimina el conjunto de datos

  1. Si es necesario, abre la IU web de BigQuery.

    Ir a la IU web de BigQuery

  2. En el panel de navegación, en la sección Recursos, haz clic en el conjunto de datos demo_dataset que creaste.

  3. En el lado derecho del panel de detalles, haz clic en Borrar conjunto de datos. Con esta acción, se borra el conjunto de datos, la tabla y todos los datos.

  4. En el cuadro de diálogo Borrar conjunto de datos, ingresa el nombre del conjunto de datos (demo_dataset) y, luego, haz clic en Borrar para confirmar el comando de borrado.

Elimina la plantilla de etiqueta

  1. Abre la UI de Data Catalog en Google Cloud Console. En Plantilla de etiqueta, haz clic en Administrar plantillas de etiquetas.

  2. Haz clic en Plantilla de etiqueta de demostración.

  3. En la página Plantilla de etiqueta, haz clic en Borrar para borrar la plantilla de etiqueta de demostración.

¿Qué sigue?