Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.
Guida rapida: aggiungere tag a una tabella BigQuery utilizzando Data Catalog

Codifica di una tabella BigQuery mediante Data Catalog

Questa guida rapida consente di completare le seguenti attività:

  1. Crea un set di dati e una tabella BigQuery.

  2. Crea un modello di tag con uno schema che definisce cinque campi di tag di tipo diverso. string, double, boolean, enumerated e richtext.

  3. Cerca la voce Data Catalog nella tabella.

  4. In Google Cloud Console, crea metadati aziendali per la tua voce che includano una panoramica, gestione dei dati e un tag.

Data Catalog consente di cercare e taggare voci come le tabelle BigQuery con metadati. Alcuni esempi di metadati che puoi utilizzare per la codifica includono tag pubblici e privati, gestori dei dati e panoramica in formato RTF.

Prima di iniziare

  1. Configurare il progetto.
    1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
    2. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

      Vai al selettore progetti

    3. Abilita le API Data Catalog and BigQuery.

      Abilita le API

    4. Installa e inizializza Google Cloud CLI.
    5. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

      Vai al selettore progetti

    6. Abilita le API Data Catalog and BigQuery.

      Abilita le API

    7. Installa e inizializza Google Cloud CLI.

Aggiungere una voce di dati pubblici al progetto

Le voci di Data Catalog includono risorse di dati come set di dati BigQuery o argomento Pub/Sub.

  • Aggiungi un set di dati pubblico al progetto.

    1. Nella console, vai alla pagina BigQuery.

      Vai a BigQuery

    2. Nella sezione Explorer, fai clic su + AGGIUNGI DATI e seleziona Esplora i set di dati pubblici dall'elenco a discesa.

    3. Nel riquadro Marketplace, cerca New York taxi trips e fai clic sul risultato di ricerca pertinente.

    4. Fai clic su Visualizza set di dati.

Creare un set di dati e una tabella

  1. Crea un set di dati.

    1. Nella console, apri la pagina BigQuery.

      Vai a BigQuery

    2. Nel riquadro Explorer, seleziona il progetto in cui vuoi creare il set di dati.

    3. Fai clic sull'icona Azioni e poi su Crea set di dati.

    4. Nella pagina Crea set di dati, inserisci i seguenti dettagli:

      • In ID set di dati, inserisci demo_dataset.
      • Per Località dei dati, seleziona US multi-region.
      • Attiva la scadenza della tabella e specifica il numero di giorni.
      • In Crittografia, lascia selezionata l'opzione Chiave gestita da Google.
      • Fai clic su Crea set di dati.

  2. Copia una tabella accessibile pubblicamente in demo_dataset.

    1. Nella console, apri la pagina BigQuery.

      Vai a BigQuery

    2. Nel riquadro Explorer, cerca le tabelle tlc_yellow_trips e selezionane una, ad esempio tlc_yellow_trips_2017. Poi, fai clic su Copia.

    3. Nel riquadro Copia tabella inserisci le seguenti informazioni:

      1. Nell'elenco a discesa Nome progetto, seleziona il progetto.
      2. Nell'elenco a discesa Nome set di dati, seleziona demo_dataset.
      3. Per Nome tabella, inserisci trips e fai clic su Copia.
    4. Nel riquadro Explorer, verifica che la tabella trips sia elencata in demo_dataset.

Aggiungi i tag Data Catalog alla tabella nella sezione successiva.

Crea un modello di tag pubblico e allega un tag per la voce

Devi essere il proprietario del set di dati per associare un tag a una tabella nel set di dati. Per ulteriori informazioni sui tag pubblici e privati, consulta Tag pubblici e privati.

In un modello di tag, i campi del tag sono facoltativi. Non è necessario fornire un valore per un campo quando colleghi un tag a una voce di Data Catalog. Tuttavia, se un modello definisce un campo come richiesto, devi fornire un valore per il campo. Se il valore non viene fornito, viene generato un errore.

Per definire i nomi dei campi puoi utilizzare lettere minuscole e trattini bassi. I campi del modello di tag creati in questo esempio sono solo campi dimostrativi e non vengono aggiornati automaticamente o sincronizzati con BigQuery.

console

  1. Vai alla pagina Catalogo dati > Modelli di tag.

    Vai ai modelli di tag Data Catalog

  2. Fai clic su Crea modello tag e inserisci i seguenti dettagli:

    1. Specifica il Nome modello come Demo Tag Template.
    2. Mantieni la posizione predefinita.
    3. Mantieni la visibilità del modello di tag come Pubblica.
    4. Fai clic su Aggiungi campo per aggiungere 5 campi. Utilizza la tabella seguente e tieni vuota la Descrizione campo.

      Nome visualizzato del campo ID campo Campo obbligatorio Tipo
      Origine dell'asset di dati origine Stringa
      Righe nell'asset num_righe No Double
      Contiene PII ha_pii No Booleano
      Tipo PII pii_type No Enumerato

      Aggiungi i valori EMAIL_ADDRESS, US_SOCIAL_SECURITY_NUMBER e NONE.

      Context context No RTF
  3. Fai clic su Crea.

    Nella pagina Dettagli modello sono elencate tutte le informazioni sul modello di tag.

  4. Per associare un tag alla pagina demo_dataset, vai alla pagina Catalogo dati.

    Vai a Data Catalog

  5. Nella casella di ricerca, inserisci demo_dataset. Nei risultati di ricerca, puoi vedere il set di dati demo_dataset e la tabella trips.

  6. Fai clic sulla tabella trips. Si apre la pagina Dettagli tabella BigQuery.

  7. Fai clic su Associa tag.

  8. Nel riquadro Associa tag, inserisci i seguenti dettagli:

    1. Seleziona il target come trips.
    2. Seleziona il modello di tag come Demo Tag Template.
    3. Per i valori tag, inserisci i seguenti dettagli:
      • Origine dell'asset di dati: Copied from tlc_yellow_trips_2017
      • Numero di righe nell'asset di dati: 113496874
      • Presenta PII: FALSE
      • Tipo di PII: NONE
    4. Fai clic su Salva.

      I campi del tag sono ora elencati nella sezione Tag nei dettagli della tabella BigQuery.

gcloud

Esegui il comando gcloud data-catalog tag-templates create mostrato di seguito per creare un modello di tag con i seguenti cinque campi di tag:

  1. display_name: Origine dell'asset di dati
    id: origine
    required: TRUE
    type: Stringa
  2. display_name: Numero di righe nell'asset di dati
    id: num_rows
    required: FALSE
    type: Doppio
  3. display_name: contiene PII
    id: has_pii
    required: FALSE
    type: Booleano
  4. display_name: Tipo di PII
    id: pii_type
    required: FALSE
    type: Enumerato
    values:
    1. EMAIL_ADDRESS
    2. US_SOCIAL_SECURITY_NUMBER
    3. NESSUNO
# -------------------------------
# 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

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nella guida rapida di Data Catalog utilizzando le librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Data Catalog 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Data Catalog utilizzando le librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java di Data Catalog.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nella guida rapida di Data Catalog utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Data Catalog 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Data Catalog utilizzando le librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python di Data Catalog.

# 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}")

REST &CMD LINE

REST &CMD LINE

Se non hai accesso alle librerie client di Cloud per il tuo linguaggio o vuoi testare l'API utilizzando le richieste REST, consulta i seguenti esempi e consulta la documentazione dell'API REST di Data Catalog.

1. Crea un modello di tag.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • project-id: ID progetto GCP

Metodo HTTP e URL:

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

Corpo JSON richiesta:


{
  "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"
            }
          ]
        }
      }
    }
  }
}

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "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. Cerca in entry-id Data Catalog la tabella BigQuery.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • project-id: ID progetto GCP

Metodo HTTP e URL:

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

Corpo JSON richiesta:

Request body is empty.

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "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 un tag dal modello e collegalo alla tabella BigQuery.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • project-id: ID progetto GCP
  • entry-id: ID voce Data Catalog per la tabella delle corse del set di dati demo (restituito nei risultati di ricerca nel passaggio precedente).

Metodo HTTP e URL:

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

Corpo JSON richiesta:

{
  "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"
      }
    }
  }
}

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "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"
}
Attenzione: la ridenominazione della tabella in BigQuery elimina tutti i tag associati e le relative colonne.

Crea una panoramica per la voce

All'interno della console, puoi utilizzare il formato RTF per descrivere una voce nel tuo progetto Data Catalog.

  1. Per creare una panoramica per la tabella trips, vai alla pagina Catalogo dati.

    Vai a Data Catalog

  2. Nella casella di ricerca, inserisci demo_dataset.

    Nei risultati di ricerca, puoi vedere il set di dati demo_dataset e la tabella trips.

  3. Fai clic sulla tabella trips.

    Si apre la pagina Dettagli tabella BigQuery.

  4. Fai clic su Panoramica e inserisci il testo. Puoi anche includere immagini e testo in formato formattato.

  5. Fai clic su Salva.

Aggiungi un gestore dati per la voce

Nella console, puoi aggiungere uno o più gestori dei dati a una voce nel tuo progetto Data Catalog. È possibile contattare un gestore di dati per una richiesta di dati.

  1. Per creare una panoramica per la tabella trips, ripeti i primi tre passaggi della sezione precedente.

  2. Fai clic sull'icona Modifica gestore e aggiungi uno o più indirizzi email.

    Puoi aggiungere un utente con un account email non Google.

  3. Fai clic su Salva.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai creato per il tutorial.

Per eliminare il progetto:

  1. In Google Cloud Console, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Eliminazione del set di dati

  1. Se necessario, vai alla pagina BigQuery.

    Vai a BigQuery

  2. Nel riquadro Explorer, cerca il set di dati demo_dataset che hai creato.

  3. Fai clic sull'opzione Azioni e poi su Elimina set di dati.

  4. Conferma l'azione di eliminazione.

Elimina il modello di tag

  1. Vai alla pagina Catalogo dati > Modelli.

    Vai ai modelli di Data Catalog

  2. Seleziona Modello tag demo.

  3. Nella riga, fai clic sull'opzione Azioni e poi su Elimina questo modello.

  4. Conferma l'azione di eliminazione.

Passaggi successivi