Membuat permintaan batch HTTP untuk Data Catalog

Setiap koneksi HTTP yang dibuat aplikasi Anda memerlukan sejumlah overhead tertentu. Permintaan Data Catalog API mendukung pengelompokan, dan memungkinkan Anda menggabungkan beberapa panggilan API menjadi satu permintaan HTTP. Jika Anda memiliki banyak permintaan kecil yang harus dibuat dan ingin meminimalkan overhead permintaan HTTP, sebaiknya gunakan pengelompokan HTTP.

Untuk informasi selengkapnya tentang penggunaan batch HTTP dengan Google Cloud, lihat dokumentasi klien Python Google API.

Membuat permintaan batch HTTP di Python

Untuk menggunakan permintaan batch guna membuat atau memanipulasi entri di Data Catalog, Anda harus menelusuri entri yang ingin diubah terlebih dahulu menggunakan catalog.search() atau entries.lookup().

Selanjutnya, ikuti langkah-langkah berikut untuk membuat permintaan batch HTTP menggunakan Google Python API:

  1. Buat objek BatchHttpRequest dengan memanggil new_batch_http_request() atau dengan konstruktor BatchHttpRequest(). Anda dapat meneruskan callback, yang akan dipanggil sebagai respons terhadap setiap permintaan.
  2. Panggil add() pada objek BatchHttpRequest untuk setiap permintaan yang ingin Anda jalankan. Jika Anda meneruskan callback saat membuat objek BatchHttpRequest, setiap add() dapat menyertakan parameter yang akan diteruskan ke callback.
  3. Setelah menambahkan permintaan, panggil execute() pada objek BatchHttpRequest untuk menjalankannya. Fungsi execute() diblokir hingga semua callback dipanggil.

Permintaan dalam BatchHttpRequest mungkin dijalankan secara paralel, dan bukan dalam urutan eksekusi. Artinya, permintaan dalam batch yang sama tidak boleh saling bergantung. Misalnya, Anda tidak boleh membuat EntryGroup dan Entry yang dimilikinya dalam permintaan yang sama, karena pembuatan Entry mungkin dijalankan sebelum pembuatan EntryGroup, sehingga menyebabkan eksekusi gagal.

Permintaan batch dengan endpoint regional

Saat menggunakan permintaan batch HTTP dengan endpoint API regional Katalog Data, semua permintaan API dalam batch harus berada di region yang sama. Saat menjalankan batch, Anda harus memanggil endpoint regional yang benar. Misalnya, jika resource Anda berada di us-central1, panggil https://us-central1-datacatalog.googleapis.com/batch.

API yang tidak bergantung pada wilayah

API yang tidak bergantung pada region, seperti catalog.lookup dan entries.search, dapat dikelompokkan satu sama lain, tetapi tidak boleh dikelompokkan dengan API yang bergantung pada region. Untuk API yang tidak bergantung pada wilayah, gunakan endpoint: https://datacatalog.googleapis.com/batch.

Contoh

Contoh aplikasi Python ini menunjukkan cara menggunakan permintaan batch HTTP untuk membuat beberapa tag dari template tag menggunakan Data Catalog API.

from googleapiclient.discovery import build
from googleapiclient.http import BatchHttpRequest
from oauth2client.service_account import ServiceAccountCredentials
import uuid

#-------------------------------------------------------------#
# 0. Helper and initialization logic
#-------------------------------------------------------------#

# Set the environment configuration.
service_key_file_location = '[SA_PATH]'

project_id = '[MY_PROJECT_ID]'

# Helper container to store results.
class DataContainer:
    def __init__(self):
        self.data = {}

    def callback(self, request_id, response, exception):
        if exception is not None:
            print('request_id: {}, exception: {}'.format(request_id, str(exception)))
            pass
        else:
            print(request_id)
            self.data[request_id] = response

# Helper function to build the Discovery Service config.
def get_service(api_name, api_version, scopes, key_file_location):
    """
    Get a service that communicates to a Google API.

    Args:
        api_name: The name of the API to connect to.
        api_version: The API version to connect to.
        scopes: A list auth scopes to authorize for the application.
        key_file_location: The path to a valid service account JSON key file.

    Returns:
        A service that is connected to the specified API.
    """
    credentials = ServiceAccountCredentials.from_json_keyfile_name(
        key_file_location, scopes=scopes)

    # Build the service object.
    service = build(api_name, api_version, credentials=credentials)

    return service

# Helper function to create a UUID for each request
def generated_uui():
    return str(uuid.uuid4())

def create_batch_request(callback):
    # For more info on supported regions
    # check: https://cloud.google.com/data-catalog/docs/concepts/regions

    region='us-datacatalog.googleapis.com'

    return BatchHttpRequest(batch_uri='https://{}/batch'.format(region), callback=callback)

container = DataContainer()

# Scope to set up the Discovery Service config.
scope = 'https://www.googleapis.com/auth/cloud-platform'

# Create service.
service = get_service(
    api_name='datacatalog',
    api_version='v1',
    scopes=[scope],
    key_file_location=service_key_file_location)

# Create the batch request config.
batch = create_batch_request(container.callback)

#-------------------------------------------------------------#
# 1. Start by fetching a list of entries using search call
#-------------------------------------------------------------#

# Create the search request body.
# This example searches for all BigQuery tables in a project.
search_request_body = {
  'query': 'type=TABLE system=BIGQUERY',
  'scope': {'includeProjectIds': [project_id]}
}

# Generated a unique ID for the request.
request_id = generated_uui()

# Add the request to the batch client.
batch.add(service.catalog().search(body=search_request_body), request_id=request_id)

# Execute the batch request.
batch.execute()

# Uncomment to verify the full response from search.
# print(container.data)

response = container.data[request_id]

results = response['results']

first_table = results[0]

# Verify that a first table is present.
print(first_table)

second_table = results[1]

# Verify that a second table is present
print(second_table)

#-------------------------------------------------------------------#
# 2. Send the batch request to attach tags over the entire result set
#-------------------------------------------------------------------#

# Create a new container
container = DataContainer()

# Create a new batch request
batch = create_batch_request(container.callback)

# Set the template name config
template_name = 'projects/[MY_PROJECT_ID]/locations/[MY-LOCATION]/tagTemplates/[MY-TEMPLATE-NAME]'

for result in results:
    # Generated a unique id for request.
    request_id = generated_uui()

    # Add the entry name as the tag parent.
    parent=result['relativeResourceName']

    # Create the tag request body.
    create_tag_request_body = {
      'template': template_name,
       # CHANGE for your template field values.
      'fields': {'etl_score': {'doubleValue': 0.5}}
    }

    # Add requests to the batch client.
    batch.add(service.projects().locations().
              entryGroups().entries().tags().
              create(body=create_tag_request_body,
                     parent=parent),
              request_id=request_id)

# Execute the batch request.

# Since the Batch Client works with regions
# If you receive [HttpError 400 errors]
# 1. Verify the region you used to create the Batch client
# 2. Verify the region where the Entry is located.
# 3. verify the region of the parent tag template used by the tag.

batch.execute()

# Uncomment to verify the full response from tag creation.
# print(container)