Crear una plantilla de etiqueta y adjuntar una etiqueta a una tabla de BigQuery
Explora más
Para obtener documentación en la que se incluye esta muestra de código, consulta lo siguiente:
Muestra de código
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 con bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Go de Data Catalog.
Para autenticarte en Data Catalog, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.
// 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"
"cloud.google.com/go/datacatalog/apiv1/datacatalogpb"
)
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 con bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Java de Data Catalog.
Para autenticarte en Data Catalog, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.
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 con bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Node.js de Data Catalog.
Para autenticarte en Data Catalog, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.
// 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 con bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Python de Data Catalog.
Para autenticarte en Data Catalog, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.
# 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}")¿Qué sigue?
Para buscar y filtrar muestras de código para otros productos de Google Cloud, consulta el navegador de muestra de Google Cloud.