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 atributos de etiqueta de distintos tipos (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.

      Si todavía no tienes una cuenta, regístrate para obtener una nueva.

    2. En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

      Ir a la página Selector de proyectos

    3. Habilita las API de Data Catalog and BigQuery.

      Habilita las API

    4. Instala e inicializa el SDK de Cloud.

  2. Crear un 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. Ve a BigQuery en Google Cloud Console.
    2. En el panel de navegación izquierdo, haz clic en el nombre del proyecto y, luego, en CREATE DATASET (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. Cree un conjunto de datos
      • Haz clic en Create dataset. Nota: No puedes agregar una descripción o una etiqueta cuando creas un conjunto de datos con Google Cloud Console. Después de crear el conjunto de datos, puedes agregar una descripción y agregar una etiqueta.
  3. Copia una tabla pública de taxis de Nueva York en tu demo_dataset.

    1. Desde BigQuery en Google Cloud Console, en el proyecto “bigquery-public-data”, selecciona el conjunto de datos “new_york_taxi_trips” y, luego, selecciona una de las tablas “tlc_yellow_trips”, como tlc_yellow_trips_2017. Haz clic en COPY TABLE (COPIAR TABLA) para abrir el panel Detalles de la tabla:viajes.
    2. En la sección “Destination” (Destino) del cuadro de diálogo “Copy table” (Copiar tabla), selecciona tu proyecto y el “demo_dataset”. Inserta “trips” (viajes) para el nombre de la tabla y haz clic en COPY (COPIAR).
    3. Confirma que la tabla trips aparece en el demo_dataset.
      Agregarás 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.

  1. Selecciona “Create tag template” (Crear plantilla de etiqueta) para abrir la página Create template (Crear plantilla). Completa el formulario de la plantilla para definir una “Demo Tag Template” (Plantilla de etiqueta de demostración).
    1. ID de plantilla: demo_tag_template
    2. Nombre comercial de la plantilla: Demo Tag Template
    3. Proyecto Selecciona tu proyecto
  2. A continuación, crea cuatro atributos de etiqueta (también llamados “campos” de etiqueta). Haz clic en “Add attribute” (Agregar atributo) para abrir el cuadro de diálogo Nuevo atributo. Crea cuatro atributos con los valores que se enumeran a continuación. Ten en cuenta que el atributo “fuente” define un atributo de etiqueta requerido.
      • ID del atributo: source
      • Hacer que este atributo sea obligatorio: Checked
      • Nombre comercial del atributo Source of data asset
      • Tipo: String
      • Haz clic en Listo.
      • ID del atributo: num_rows
      • Hacer que este atributo sea obligatorio: Not checked
      • Nombre comercial del atributo Number of rows in the data asset
      • Tipo: Double
      • Haz clic en Listo.
      • ID del atributo: has_pii
      • Hacer que este atributo sea obligatorio: Not checked
      • Nombre comercial del atributo Has PII
      • Tipo: Boolean
      • Haz clic en Listo.
      • ID del atributo: pii_type
      • Hacer que este atributo sea obligatorio: Not checked
      • Nombre comercial del atributo PII type
      • Tipo: Enumerated
        Agrega 3 valores:
        1. EMAIL
        2. SOCIAL SECURITY NUMBER
        3. NINGUNO
      • Haz clic en Listo.

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

    Haz clic en CREAR. La página Tag template (Plantilla de etiqueta) del Data Catalog muestra los detalles y los atributos de la plantilla.

  3. Para adjuntar una etiqueta a una tabla en su conjunto de datos, abra la IU de Data Catalog, inserta “demo_dataset” en el cuadro de búsqueda y haz clic en Search (Buscar).
  4. 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.
  5. Se abre la página Entry details (Detalles de la entrada). Haz clic en Attach Tag (Adjuntar etiqueta).
  6. En el cuadro de diálogo Adjuntar etiqueta, deja el campo “Attach to” (Adjuntar a) establecido en la “Table” (Tabla) y seleccione la “Demo Tag Template” (Plantilla de etiqueta de demostración) en su proyecto. Luego, inserta o selecciona los siguientes valores para cada atributo de etiqueta. Ten en cuenta que debes proporcionar un valor para el atributo “source” (fuente) requerido (cambia “2017” si es necesario para mostrar el año fuente de la tabla tlc_yellow_trips que copiaste en el conjunto de datos):
    1. source
      Copied from tlc_yellow_trips_2017
      
    2. num_rows
      113496874
      
    3. pii_type
      Select "NONE"
      
    4. has_pii
      Select "false"
      

    Haga clic en Save. Los atributos de la etiqueta se enumeran en la página Entry details (Detalles de entrada).

Comando de 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. EMAIL
    2. 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|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"
  }
EOF

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

Python

  1. Instala la biblioteca cliente
  2. Configura credenciales predeterminadas de la aplicación
  3. Ejecuta el código.
    # -------------------------------
    # Import required modules.
    # -------------------------------
    from google.cloud import datacatalog_v1
    
    # -------------------------------
    # Set your Google Cloud Platform project ID.
    # -------------------------------
    project_id = PROJECT
    
    # -------------------------------
    # Currently, Data Catalog stores metadata in the
    # us-central1 region.
    # -------------------------------
    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 = datacatalog_v1.DataCatalogClient()
    
    # -------------------------------
    # Create a Tag Template.
    # -------------------------------
    tag_template = datacatalog_v1.types.TagTemplate()
    
    tag_template.display_name = 'Demo Tag Template'
    
    tag_template.fields['source'].display_name = 'Source of data asset'
    tag_template.fields['source'].type.primitive_type = \
        datacatalog_v1.enums.FieldType.PrimitiveType.STRING.value
    
    tag_template.fields['num_rows'].display_name = 'Number of rows in data asset'
    tag_template.fields['num_rows'].type.primitive_type = \
        datacatalog_v1.enums.FieldType.PrimitiveType.DOUBLE.value
    
    tag_template.fields['has_pii'].display_name = 'Has PII'
    tag_template.fields['has_pii'].type.primitive_type = \
        datacatalog_v1.enums.FieldType.PrimitiveType.BOOL.value
    
    tag_template.fields['pii_type'].display_name = 'PII type'
    tag_template.fields['pii_type'].type.enum_type\
        .allowed_values.add().display_name = 'EMAIL'
    tag_template.fields['pii_type'].type.enum_type\
        .allowed_values.add().display_name = 'SOCIAL SECURITY NUMBER'
    tag_template.fields['pii_type'].type.enum_type\
        .allowed_values.add().display_name = 'NONE'
    
    expected_template_name = datacatalog_v1.DataCatalogClient\
        .tag_template_path(project_id, location, 'demo_tag_template')
    
    # Delete any pre-existing Template with the same name.
    try:
        datacatalog.delete_tag_template(name=expected_template_name, force=True)
        print('Deleted template: {}'.format(expected_template_name))
    except:
        print('Cannot delete template: {}'.format(expected_template_name))
    
    # Create the Tag Template.
    try:
        tag_template = datacatalog.create_tag_template(
            parent=datacatalog_v1.DataCatalogClient.location_path(
                project_id, location),
            tag_template_id='demo_tag_template',
            tag_template=tag_template)
        print('Created template: {}'.format(tag_template.name))
    except:
        print('Cannot create template: {}'.format(expected_template_name))
    
    # -------------------------------
    # Lookup Data Catalog's Entry referring to the table.
    # -------------------------------
    resource_name = '//bigquery.googleapis.com/projects/{}' \
                    '/datasets/demo_dataset/tables/trips'.format(project_id)
    table_entry = datacatalog.lookup_entry(linked_resource=resource_name)
    
    # -------------------------------
    # Attach a Tag to the table.
    # -------------------------------
    tag = datacatalog_v1.types.Tag()
    
    tag.template = tag_template.name
    
    tag.fields['source'].string_value = 'Copied from tlc_yellow_trips_2017'
    tag.fields['num_rows'].double_value = 113496874
    tag.fields['has_pii'].bool_value = False
    tag.fields['pii_type'].enum_value.display_name = 'NONE'
    
    tag = datacatalog.create_tag(parent=table_entry.name, tag=tag)
    print('Created tag: {}'.format(tag.name))
    

Java

  1. Instala la biblioteca cliente
  2. Configura credenciales predeterminadas de la aplicación
  3. Ejecuta el código.
    /*
    This application demonstrates how to perform core operations with the
    Data Catalog API.
    
    For more information, see the README.md and the official documentation at
    https://cloud.google.com/data-catalog/docs.
    */
    
    package com.example.datacatalog;
    
    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.DeleteTagTemplateRequest;
    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 com.google.cloud.datacatalog.v1.TagTemplateName;
    
    public class CreateTags {
    
      public static void createTags() {
        // 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) {
        // 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("demo_tag_template")
                  .setTagTemplate(tagTemplate)
                  .build();
    
          String expectedTemplateName =
              TagTemplateName.newBuilder()
                  .setProject(projectId)
                  .setLocation(location)
                  .setTagTemplate("demo_tag_template")
                  .build()
                  .toString();
    
          // Delete any pre-existing Template with the same name.
          try {
            dataCatalogClient.deleteTagTemplate(
                DeleteTagTemplateRequest.newBuilder()
                    .setName(expectedTemplateName)
                    .setForce(true)
                    .build());
    
            System.out.println(String.format("Deleted template: %s", expectedTemplateName));
          } catch (Exception e) {
            System.out.println(String.format("Cannot delete template: %s", expectedTemplateName));
          }
    
          // Create the Tag Template.
          tagTemplate = dataCatalogClient.createTagTemplate(createTagTemplateRequest);
          System.out.println(String.format("Template created with name: %s", tagTemplate.getName()));
    
          // -------------------------------
          // Lookup Data Catalog's Entry referring to the table.
          // -------------------------------
          String linkedResource =
              String.format(
                  "//bigquery.googleapis.com/projects/%s/datasets/demo_dataset/tables/trips",
                  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);
    
        } catch (Exception e) {
          System.out.print("Error during CreateTags:\n" + e.toString());
        }
      }
    }
    

Node.js

  1. Instala la biblioteca cliente
  2. Configura credenciales predeterminadas de la aplicación
  3. Ejecuta el código.
    async function main() {
        // -------------------------------
        // Import required modules.
        // -------------------------------
        const { DataCatalogClient } = require('@google-cloud/datacatalog').v1;
    
        // Common fields.
        let request;
        let responses;
    
        // -------------------------------
        // Set your Google Cloud Platform project ID.
        // -------------------------------
        const projectId = 'PROJECT_ID';
    
        // -------------------------------
        // Currently, Data Catalog stores metadata in the
        // us-central1 region.
        // -------------------------------
        const 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.
        // -------------------------------
        const datacatalog = new DataCatalogClient();
    
        // 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/demo_dataset/tables/trips`,
        });
        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}`);
    }
    
    main();
    

LÍNEA DE CMD Y REST

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 siguientes, 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"
            },
            {
              "displayName":"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"
            },
            {
              "displayName":"NONE"
            },
            {
              "displayName":"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 siguientes, 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 siguientes, 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?tagTemplateId=demo_tag_template

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

Limpia

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta guía de inicio rápido.

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 la página Administrar recursos

  2. En la lista de proyectos, selecciona el proyecto que deseas borrar y haz clic en Borrar .
  3. En el cuadro de diálogo, escribe el ID del proyecto y 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 Tag Template (Plantilla de etiqueta), haz clic en “Explore tag templates” (Explorar plantillas de etiqueta).

  2. Haz clic en “Demo Tag Template” (Plantilla de etiqueta de demostración).

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

Qué sigue