Bekerja dengan fungsi yang ditentukan pengguna di Python

Fungsi yang ditentukan pengguna (UDF) Python memungkinkan Anda menerapkan fungsi skalar di Python dan menggunakannya dalam kueri SQL. UDF Python mirip dengan UDF SQL dan JavaScript, tetapi dengan kemampuan tambahan. UDF Python memungkinkan Anda menginstal library pihak ketiga dari Python Package Index (PyPI) dan memungkinkan Anda mengakses layanan eksternal menggunakan koneksi resource Cloud.

UDF Python dibuat dan dijalankan di resource yang dikelola BigQuery.

Batasan

• python-3.11 adalah satu-satunya runtime yang didukung.
• Anda tidak dapat membuat UDF Python sementara.
• Anda tidak dapat menggunakan UDF Python dengan tampilan terwujud.
• Hasil kueri yang memanggil UDF Python tidak di-cache karena nilai yang ditampilkan UDF Python selalu dianggap non-deterministik.
• Jaringan VPC tidak didukung.
• Assured Workloads tidak didukung.
• Jenis data ini tidak didukung: JSON, RANGE, INTERVAL, dan GEOGRAPHY.
• Container yang menjalankan UDF Python hanya dapat dikonfigurasi hingga 4 vCPU dan 16 GiB.
• Kunci enkripsi yang dikelola pelanggan (CMEK) tidak didukung.

Peran yang diperlukan

Peran IAM yang diperlukan didasarkan pada apakah Anda adalah pemilik UDF Python atau pengguna UDF Python.

Pemilik UDF

Pemilik UDF Python biasanya membuat atau memperbarui UDF. Peran tambahan juga diperlukan jika Anda membuat UDF Python yang mereferensikan koneksi resource Cloud. Koneksi ini hanya diperlukan jika UDF Anda menggunakan klausa WITH CONNECTION untuk mengakses layanan eksternal.

Untuk mendapatkan izin yang Anda perlukan untuk membuat atau memperbarui UDF Python, minta administrator untuk memberi Anda peran IAM berikut:

• BigQuery Data Editor (roles/bigquery.dataEditor) di set data
• BigQuery Job User (roles/bigquery.jobUser) di project
• BigQuery Connection Admin (roles/bigquery.connectionAdmin) di project

Untuk mengetahui informasi selengkapnya tentang pemberian peran, lihat Mengelola akses ke project, folder, dan organisasi.

Peran bawaan ini berisi izin yang diperlukan untuk membuat atau memperbarui UDF Python. Untuk melihat izin yang benar-benar diperlukan, perluas bagian Izin yang diperlukan:

Izin yang diperlukan

Izin berikut diperlukan untuk membuat atau memperbarui UDF Python:

• Buat UDF Python menggunakan pernyataan CREATE FUNCTION: bigquery.routines.create pada set data
• Perbarui UDF Python menggunakan pernyataan CREATE FUNCTION: bigquery.routines.update pada set data
• Menjalankan tugas kueri pernyataan CREATE FUNCTION: bigquery.jobs.create di project
• Buat koneksi resource Cloud baru: bigquery.connections.create di project
• Gunakan koneksi dalam pernyataan CREATE FUNCTION: bigquery.connections.delegate pada koneksi

Anda mungkin juga bisa mendapatkan izin ini dengan peran khusus atau peran bawaan lainnya.

Untuk mengetahui informasi selengkapnya tentang peran di BigQuery, lihat Peran IAM yang telah ditetapkan.

Pengguna UDF

Pengguna UDF Python memanggil UDF yang dibuat oleh orang lain. Peran tambahan juga diperlukan jika Anda memanggil UDF Python yang mereferensikan koneksi resource Cloud.

Untuk mendapatkan izin yang Anda perlukan untuk memanggil UDF Python yang dibuat oleh orang lain, minta administrator untuk memberi Anda peran IAM berikut:

• Pengguna BigQuery (roles/bigquery.user) di project
• BigQuery Data Viewer (roles/bigquery.dataViewer) pada set data
• BigQuery Connection User (roles/bigquery.connectionUser) pada koneksi

Untuk mengetahui informasi selengkapnya tentang pemberian peran, lihat Mengelola akses ke project, folder, dan organisasi.

Peran bawaan ini berisi izin yang diperlukan untuk memanggil UDF Python yang dibuat oleh orang lain. Untuk melihat izin yang benar-benar diperlukan, perluas bagian Izin yang diperlukan:

Izin yang diperlukan

Izin berikut diperlukan untuk memanggil UDF Python yang dibuat oleh orang lain:

• Untuk menjalankan tugas kueri yang mereferensikan UDF Python: bigquery.jobs.create di project
• Untuk memanggil UDF Python yang dibuat oleh orang lain: bigquery.routines.get pada set data
• Untuk menjalankan UDF Python yang mereferensikan koneksi resource Cloud: bigquery.connections.use pada koneksi

Anda mungkin juga bisa mendapatkan izin ini dengan peran khusus atau peran bawaan lainnya.

Untuk mengetahui informasi selengkapnya tentang peran di BigQuery, lihat Peran IAM yang telah ditetapkan.

Memanggil UDF Python

Jika memiliki izin untuk memanggil UDF Python, Anda dapat memanggilnya seperti fungsi lainnya. Untuk menggunakan fungsi yang ditentukan dalam project lain, gunakan nama fungsi yang sepenuhnya memenuhi syarat. Misalnya, untuk memanggil UDF Python cw_xml_extract yang ditentukan sebagai UDF komunitas bigquery-utils, ikuti langkah-langkah berikut:

Konsol

1. Buka halaman BigQuery.

   Buka BigQuery

2. Di editor kueri, masukkan contoh berikut:

   SELECT
     `bqutil`.`fn`.`cw_xml_extract`(xml, '//title/text()') AS `title`
   FROM UNNEST([
     STRUCT('''<book id="1">
       <title>The Great Gatsby</title>
       <author>F. Scott Fitzgerald</author>
     </book>''' AS xml),
     STRUCT('''<book id="2">
       <title>1984</title>
       <author>George Orwell</author>
     </book>''' AS xml),
     STRUCT('''<book id="3">
       <title>Brave New World</title>
       <author>Aldous Huxley</author>
     </book>''' AS xml)
   ])
   

3. Klik  Run.

   Contoh ini menghasilkan output berikut:

   +--------------------------+
   | title                    |
   +--------------------------+
   | The Great Gatsby         |
   | 1984                     |
   | Brave New World          |
   +--------------------------+
   

BigQuery DataFrames

Contoh berikut menggunakan metode BigQuery DataFrames sql_scalar, read_gbq_function, dan apply untuk memanggil UDF Python:

import textwrap
from typing import Tuple

import bigframes.pandas as bpd
import pandas as pd
import pyarrow as pa


# Using partial ordering mode enables more efficient query optimizations.
bpd.options.bigquery.ordering_mode = "partial"


def call_python_udf(
    project_id: str, location: str,
) -> Tuple[pd.Series, bpd.Series]:
    # Set the billing project to use for queries. This step is optional, as the
    # project can be inferred from your environment in many cases.
    bpd.options.bigquery.project = project_id  # "your-project-id"

    # Since this example works with local data, set a processing location.
    bpd.options.bigquery.location = location  # "US"

    # Create a sample series.
    xml_series = pd.Series(
        [
            textwrap.dedent(
                """
                <book id="1">
                    <title>The Great Gatsby</title>
                    <author>F. Scott Fitzgerald</author>
                </book>
                """
            ),
            textwrap.dedent(
                """
                <book id="2">
                    <title>1984</title>
                    <author>George Orwell</author>
                </book>
                """
            ),
            textwrap.dedent(
                """
                <book id="3">
                    <title>Brave New World</title>
                    <author>Aldous Huxley</author>
                </book>
                """
            ),
        ],
        dtype=pd.ArrowDtype(pa.string()),
    )
    df = pd.DataFrame({"xml": xml_series})

    # Use the BigQuery Accessor, which is automatically registered on pandas
    # DataFrames when you import bigframes.  This example uses a function that
    # has been deployed to bigquery-utils for demonstration purposes. To use in
    # production, deploy the function at
    # https://github.com/GoogleCloudPlatform/bigquery-utils/blob/master/udfs/community/cw_xml_extract.sqlx
    # to your own project.
    titles_pandas = df.bigquery.sql_scalar(
        "`bqutil`.`fn`.cw_xml_extract({xml}, '//title/text()')",
    )

    # Alternatively, call read_gbq_function to get a pointer to the function
    # that can be applied on BigQuery DataFrames objects.
    cw_xml_extract = bpd.read_gbq_function("bqutil.fn.cw_xml_extract")
    xml_bigframes = bpd.read_pandas(xml_series)

    xpath_query = "//title/text()"
    titles_bigframes = xml_bigframes.apply(cw_xml_extract, args=(xpath_query,))
    return titles_pandas, titles_bigframes

Membuat UDF Python persisten

Ikuti aturan berikut saat Anda membuat UDF Python:

• Isi UDF Python harus berupa literal string yang dikutip yang merepresentasikan kode Python. Untuk mempelajari lebih lanjut literal string yang dikutip, lihat Format untuk literal yang dikutip.

• Isi UDF Python harus menyertakan fungsi Python yang digunakan dalam argumen entry_point dalam daftar opsi UDF Python.

• Versi runtime Python harus ditentukan dalam opsi runtime_version. Satu-satunya versi runtime Python yang didukung adalah python-3.11. Untuk daftar lengkap opsi yang tersedia, lihat Daftar opsi fungsi untuk pernyataan CREATE FUNCTION.

Untuk membuat UDF Python persisten, gunakan pernyataan CREATE FUNCTION tanpa kata kunci TEMP atau TEMPORARY. Untuk menghapus UDF Python persisten, gunakan pernyataan DROP FUNCTION.

Saat Anda membuat UDF Python menggunakan pernyataan CREATE FUNCTION, BigQuery akan membuat atau mengupdate image container yang didasarkan pada image dasar. Container dibangun di image dasar menggunakan kode Anda dan dependensi paket yang ditentukan. Pembuatan penampung adalah proses yang berjalan lama. Kueri pertama setelah Anda menjalankan pernyataan CREATE FUNCTION mungkin otomatis menunggu hingga gambar selesai. Tanpa dependensi eksternal, image container biasanya dibuat dalam waktu kurang dari satu menit.

Contoh

Untuk melihat contoh pembuatan UDF Python persisten, pilih salah satu opsi berikut:

Konsol

Contoh berikut membuat UDF Python persisten bernama multiplyInputs dan memanggil UDF dari dalam pernyataan SELECT:

1. Buka halaman BigQuery.

   Buka BigQuery

2. Di editor kueri, masukkan pernyataan CREATE FUNCTION berikut:

   CREATE FUNCTION `PROJECT_ID.DATASET_ID`.multiplyInputs(x FLOAT64, y FLOAT64)
   RETURNS FLOAT64
   LANGUAGE python
   OPTIONS(runtime_version="python-3.11", entry_point="multiply")
   AS r'''
   
   def multiply(x, y):
       return x * y
   
   ''';
   
   -- Call the Python UDF.
   WITH numbers AS
       (SELECT 1 AS x, 5 as y
       UNION ALL
       SELECT 2 AS x, 10 as y
       UNION ALL
       SELECT 3 as x, 15 as y)
   SELECT x, y,
   `PROJECT_ID.DATASET_ID`.multiplyInputs(x, y) AS product
   FROM numbers;

   Ganti PROJECT_ID.DATASET_ID dengan project ID dan ID set data Anda.

3. Klik  Run.

   Contoh ini menghasilkan output berikut:

   +-----+-----+--------------+
   | x   | y   | product      |
   +-----+-----+--------------+
   | 1   | 5   |  5.0         |
   | 2   | 10  | 20.0         |
   | 3   | 15  | 45.0         |
   +-----+-----+--------------+
   

BigQuery DataFrames

Contoh berikut menggunakan BigQuery DataFrames untuk mengubah fungsi kustom menjadi UDF Python:

import bigframes.pandas as bpd

# Set BigQuery DataFrames options
bpd.options.bigquery.project = your_gcp_project_id
bpd.options.bigquery.location = "US"

# BigQuery DataFrames gives you the ability to turn your custom functions
# into a BigQuery Python UDF. One can find more details about the usage and
# the requirements via `help` command.
help(bpd.udf)

# Read a table and inspect the column of interest.
df = bpd.read_gbq("bigquery-public-data.ml_datasets.penguins")
df["body_mass_g"].peek(10)

# Define a custom function, and specify the intent to turn it into a
# BigQuery Python UDF. Let's try a `pandas`-like use case in which we want
# to apply a user defined function to every value in a `Series`, more
# specifically bucketize the `body_mass_g` value of the penguins, which is a
# real number, into a category, which is a string.
@bpd.udf(
    dataset=your_bq_dataset_id,
    name=your_bq_routine_id,
)
def get_bucket(num: float) -> str:
    if not num:
        return "NA"
    boundary = 4000
    return "at_or_above_4000" if num >= boundary else "below_4000"

# Then we can apply the udf on the `Series` of interest via
# `apply` API and store the result in a new column in the DataFrame.
df = df.assign(body_mass_bucket=df["body_mass_g"].apply(get_bucket))

# This will add a new column `body_mass_bucket` in the DataFrame. You can
# preview the original value and the bucketized value side by side.
df[["body_mass_g", "body_mass_bucket"]].peek(10)

# The above operation was possible by doing all the computation on the
# cloud through an underlying BigQuery Python UDF that was created to
# support the user's operations in the Python code.

# The BigQuery Python UDF created to support the BigQuery DataFrames
# udf can be located via a property `bigframes_bigquery_function`
# set in the udf object.
print(f"Created BQ Python UDF: {get_bucket.bigframes_bigquery_function}")

# If you have already defined a custom function in BigQuery, either via the
# BigQuery Google Cloud Console or with the `udf` decorator,
# or otherwise, you may use it with BigQuery DataFrames with the
# `read_gbq_function` method. More details are available via the `help`
# command.
help(bpd.read_gbq_function)

existing_get_bucket_bq_udf = get_bucket.bigframes_bigquery_function

# Here is an example of using `read_gbq_function` to load an existing
# BigQuery Python UDF.
df = bpd.read_gbq("bigquery-public-data.ml_datasets.penguins")
get_bucket_function = bpd.read_gbq_function(existing_get_bucket_bq_udf)

df = df.assign(body_mass_bucket=df["body_mass_g"].apply(get_bucket_function))
df.peek(10)

# Let's continue trying other potential use cases of udf. Let's say we
# consider the `species`, `island` and `sex` of the penguins sensitive
# information and want to redact that by replacing with their hash code
# instead. Let's define another scalar custom function and decorate it
# as a udf. The custom function in this example has external package
# dependency, which can be specified via `packages` parameter.
@bpd.udf(
    dataset=your_bq_dataset_id,
    name=your_bq_routine_id,
    packages=["cryptography"],
)
def get_hash(input: str) -> str:
    from cryptography.fernet import Fernet

    # handle missing value
    if input is None:
        input = ""

    key = Fernet.generate_key()
    f = Fernet(key)
    return f.encrypt(input.encode()).decode()

# We can use this udf in another `pandas`-like API `map` that
# can be applied on a DataFrame
df_redacted = df[["species", "island", "sex"]].map(get_hash)
df_redacted.peek(10)

# If the BigQuery routine is no longer needed, we can clean it up
# to free up any cloud quota
session = bpd.get_global_session()
session.bqclient.delete_routine(f"{your_bq_dataset_id}.{your_bq_routine_id}")

Membuat UDF Python tervektorisasi

Anda dapat menerapkan UDF Python untuk memproses batch baris, bukan satu baris, dengan menggunakan vektorisasi. Vektorisasi dapat meningkatkan performa kueri. Anda dapat membuat UDF tervektor menggunakan Pandas atau Apache Arrow.

Untuk mengontrol perilaku batching, tentukan jumlah maksimum baris dalam setiap batch menggunakan opsi max_batching_rows dalam daftar opsi CREATE OR REPLACE FUNCTION. Jika Anda menentukan max_batching_rows, BigQuery akan menentukan jumlah baris dalam batch, hingga batas max_batching_rows. Jika max_batching_rows tidak ditentukan, jumlah baris yang akan di-batch akan ditentukan secara otomatis.

Menggunakan Pandas

UDF Python tervektorisasi memiliki satu argumen pandas.DataFrame yang harus dianotasi. Argumen pandas.DataFrame memiliki jumlah kolom yang sama dengan parameter UDF Python yang ditentukan dalam pernyataan CREATE FUNCTION. Nama kolom dalam argumen pandas.DataFrame memiliki nama yang sama dengan parameter UDF.

Fungsi Anda harus menampilkan pandas.Series atau pandas.DataFrame satu kolom dengan jumlah baris yang sama dengan input.

Contoh berikut membuat UDF Python tervektorisasi bernama multiplyInputs dengan dua parameter—x dan y:

1. Buka halaman BigQuery.

   Buka BigQuery

2. Di editor kueri, masukkan pernyataan CREATE FUNCTION berikut:

   CREATE FUNCTION `PROJECT_ID.DATASET_ID`.multiplyVectorized(x FLOAT64, y FLOAT64)
   RETURNS FLOAT64
   LANGUAGE python
   OPTIONS(runtime_version="python-3.11", entry_point="vectorized_multiply")
   AS r'''
   import pandas as pd
   
   def vectorized_multiply(df: pd.DataFrame):
     return df['x'] * df['y']
   
   ''';

   Ganti PROJECT_ID.DATASET_ID dengan project ID dan ID set data Anda.

   Memanggil UDF sama seperti pada contoh sebelumnya.

3. Klik  Run.

Menggunakan Apache Arrow

Contoh berikut menggunakan antarmuka RecordBatch Apache Arrow. Saat Anda menggunakan antarmuka RecordBatch, fungsi akan meneruskan kumpulan baris kolom dengan panjang yang sama ke titik entri. Contoh berikut menggunakan Apache Arrow untuk membuat UDF Python tervektorisasi bernama multiplyVectorizedArrow.

1. Buka halaman BigQuery.

   Buka BigQuery

2. Di editor kueri, masukkan pernyataan CREATE FUNCTION berikut:

   CREATE FUNCTION `PROJECT_ID.DATASET_ID`.multiplyVectorizedArrow(x FLOAT64, y FLOAT64)
   RETURNS FLOAT64
   LANGUAGE python
   OPTIONS(
     runtime_version="python-3.11",
     entry_point="vectorized_multiply_arrow"
   )
   AS r'''
   import pyarrow as pa
   import pyarrow.compute as pc
   
   def vectorized_multiply_arrow(batch: pa.RecordBatch):
       # Access columns directly from the Arrow RecordBatch
       x = batch.column('x')
       y = batch.column('y')
   
       # Use pyarrow.compute for vectorized operations
       return pc.multiply(x, y)
   ''';

   Ganti PROJECT_ID.DATASET_ID dengan project ID dan ID set data Anda.

   Memanggil UDF sama seperti pada contoh sebelumnya.

3. Klik  Run.

Jenis data UDF Python yang didukung

Tabel berikut menentukan pemetaan antara jenis data BigQuery, jenis data Python, dan jenis data Pandas:

Jenis data BigQuery	Jenis data bawaan Python yang digunakan oleh UDF standar	Jenis data pandas yang digunakan oleh UDF tervektorisasi	Jenis data PyArrow yang digunakan untuk ARRAY dan STRUCT di UDF tervektorisasi
BOOL	bool	BooleanDtype	DataType(bool)
INT64	int	Int64Dtype	DataType(int64)
FLOAT64	float	FloatDtype	DataType(double)
STRING	str	StringDtype	DataType(string)
BYTES	bytes	binary[pyarrow]	DataType(binary)
TIMESTAMP	Parameter fungsi: datetime.datetime (dengan zona waktu UTC yang ditetapkan) Nilai yang ditampilkan fungsi: datetime.datetime (dengan setelan zona waktu apa pun)	Parameter fungsi: timestamp[us, tz=UTC][pyarrow] Nilai yang ditampilkan fungsi: timestamp[us, tz=*][pyarrow]\(any timezone\)	TimestampType(timestamp[us]), dengan zona waktu
DATE	datetime.date	date32[pyarrow]	DataType(date32[day])
TIME	datetime.time	time64[pyarrow]	Time64Type(time64[us])
DATETIME	datetime.datetime (tanpa zona waktu)	timestamp[us][pyarrow]	TimestampType(timestamp[us]), tanpa zona waktu
ARRAY	list	list<...>[pyarrow], dengan jenis data elemen adalah pandas.ArrowDtype	ListType
STRUCT	dict	struct<...>[pyarrow], dengan jenis data kolom adalah pandas.ArrowDtype	StructType

Versi runtime yang didukung

UDF Python BigQuery mendukung runtime python-3.11. Versi Python ini menyertakan beberapa paket bawaan tambahan. Untuk library sistem, periksa image dasar runtime.

Versi runtime	Versi Python	Mencakup
python-3.11	Python 3.11	numpy 1.26.3 pyarrow 14.0.2 pandas 2.1.4 python-dateutil 2.8.2 absl-py 2.0.0 pytz 2023.3.post1 tzdata 2023.4 six 1.16.0 grpcio 1.76.0 grpcio-protobuf 6.33.5tools 1.76.0 typing-extensions 4.15.0

Menggunakan paket pihak ketiga

Anda dapat menggunakan daftar opsi CREATE FUNCTION untuk menggunakan modul selain yang disediakan oleh library standar Python dan paket yang sudah diinstal. Anda dapat menginstal paket dari Python Package Index (PyPI), atau Anda dapat mengimpor file Python dari Cloud Storage.

Menginstal paket dari indeks paket Python

Saat menginstal paket, Anda harus memberikan nama paket, dan Anda dapat secara opsional memberikan versi paket menggunakan penentu versi paket Python.

Jika paket ada di runtime, paket tersebut akan digunakan kecuali jika versi tertentu ditentukan dalam daftar opsi CREATE FUNCTION. Jika versi paket tidak ditentukan, dan paket tidak ada di runtime, versi terbaru yang tersedia akan digunakan. Hanya paket dengan format biner roda yang didukung.

Contoh berikut menunjukkan cara membuat UDF Python yang menginstal paket scipy menggunakan daftar opsi CREATE OR REPLACE FUNCTION:

1. Buka halaman BigQuery.

   Buka BigQuery

2. Di editor kueri, masukkan pernyataan CREATE FUNCTION berikut:

   CREATE FUNCTION `PROJECT_ID.DATASET_ID`.area(radius FLOAT64)
   RETURNS FLOAT64 LANGUAGE python
   OPTIONS (entry_point='area_handler', runtime_version='python-3.11', packages=['scipy==1.15.3'])
   AS r"""
   import scipy
   
   def area_handler(radius):
     return scipy.constants.pi*radius*radius
   """;
   
   SELECT `PROJECT_ID.DATASET_ID`.area(4.5);

   Ganti PROJECT_ID.DATASET_ID dengan project ID dan ID set data Anda.

3. Klik  Run.

Mengimpor file Python tambahan sebagai library

Anda dapat memperluas UDF Python menggunakan daftar opsi Fungsi dengan mengimpor file Python dari Cloud Storage.

Catatan: Pengguna yang membuat UDF memerlukan izin storage.objects.get di bucket Cloud Storage.

Dalam kode Python UDF, Anda dapat mengimpor file Python dari Cloud Storage sebagai modul menggunakan pernyataan impor yang diikuti dengan jalur ke objek Cloud Storage. Misalnya, jika Anda mengimpor gs://BUCKET_NAME/path/to/lib1.py, pernyataan impor Anda adalah import path.to.lib1.

Nama file Python harus berupa ID Python. Setiap nama folder dalam nama objek (setelah /) harus berupa ID Python yang valid. Dalam rentang ASCII (U+0001..U+007F), karakter berikut dapat digunakan dalam ID:

• Huruf besar dan huruf kecil A hingga Z.
• Garis bawah.
• Angka nol hingga sembilan, tetapi angka tidak boleh muncul sebagai karakter pertama dalam ID.

Contoh berikut menunjukkan cara membuat UDF Python yang mengimpor paket library klien lib1.py dari bucket Cloud Storage bernama my_bucket:

1. Buka halaman BigQuery.

   Buka BigQuery

2. Di editor kueri, masukkan pernyataan CREATE FUNCTION berikut:

   CREATE FUNCTION `PROJECT_ID.DATASET_ID`.myFunc(a FLOAT64, b STRING)
   RETURNS STRING LANGUAGE python
   OPTIONS (
   entry_point='compute', runtime_version='python-3.11',
   library=['gs://my_bucket/path/to/lib1.py'])
   AS r"""
   import path.to.lib1 as lib1
   
   def compute(a, b):
     # doInterestingStuff is a function defined in
     # gs://my_bucket/path/to/lib1.py
     return lib1.doInterestingStuff(a, b);
   
   """;

   Ganti PROJECT_ID.DATASET_ID dengan project ID dan ID set data Anda.

3. Klik  Run.

Mengonfigurasi batas container untuk UDF Python

Anda dapat menggunakan opsi CREATE FUNCTION list untuk menentukan batas serentak permintaan CPU, memori, dan container untuk container yang menjalankan UDF Python.

Secara default, container dialokasikan resource berikut:

• Memori yang dialokasikan adalah 512Mi.
• CPU yang dialokasikan adalah 1.0 vCPU.
• Batas serentak permintaan container adalah 80.

Catatan: Jika Anda menetapkan alokasi CPU ke kurang dari 1.0 vCPU, dan Anda tidak menetapkan batas konkurensi permintaan penampung, konkurensi permintaan penampung akan ditetapkan ke 1 saat runtime.

Contoh berikut membuat UDF Python menggunakan daftar opsi CREATE FUNCTION untuk menentukan batas container:

1. Buka halaman BigQuery.

   Buka BigQuery

2. Di editor kueri, masukkan pernyataan CREATE FUNCTION berikut:

   CREATE FUNCTION `PROJECT_ID.DATASET_ID`.resizeImage(image BYTES)
   RETURNS BYTES LANGUAGE python
   OPTIONS (entry_point='resize_image', runtime_version='python-3.11',
   packages=['Pillow==11.2.1'], container_memory='CONTAINER_MEMORY', container_cpu=CONTAINER_CPU,
   container_request_concurrency=CONTAINER_REQUEST_CONCURRENCY)
   AS r"""
   import io
   from PIL import Image
   
   def resize_image(image_bytes):
     img = Image.open(io.BytesIO(image_bytes))
   
     resized_img = img.resize((256, 256), Image.Resampling.LANCZOS)
     output_stream = io.BytesIO()
     resized_img.convert('RGB').save(output_stream, format='JPEG')
     return output_stream.getvalue()
   """;

   Ganti kode berikut:

   • PROJECT_ID.DATASET_ID: project ID dan ID set data Anda.
   • CONTAINER_MEMORY: nilai memori dalam format berikut: <integer_number><unit>. Unit harus berupa salah satu nilai berikut: Mi (MiB), M (MB), Gi (GiB), atau G (GB). Misalnya, 2Gi.
   • CONTAINER_CPU: nilai CPU. UDF Python mendukung nilai CPU fraksional antara 0.33 dan 1.0 serta nilai CPU non-fraksional 1, 2, dan 4.
   • CONTAINER_REQUEST_CONCURRENCY: jumlah maksimum permintaan serentak per instance container UDF Python. Nilai harus berupa bilangan bulat dari 1 hingga 1000.

3. Klik  Run.

Nilai CPU yang didukung

UDF Python mendukung nilai CPU fraksional antara 0.33 dan 1.0 serta nilai CPU non-fraksional 1, 2, dan 4. Container yang menjalankan UDF Python dapat dikonfigurasi hingga 4 vCPU. Nilai defaultnya adalah 1.0. Nilai input pecahan dibulatkan ke dua tempat desimal sebelum diterapkan ke penampung.

Nilai memori yang didukung

Penampung UDF Python mendukung nilai memori dalam format berikut: <integer_number><unit>. Unit harus berupa salah satu nilai berikut: Mi, M, Gi, G. Jumlah minimum memori yang dapat Anda konfigurasi adalah 256Mi. Jumlah memori maksimum yang dapat Anda konfigurasi adalah 16Gi.

Berdasarkan nilai memori yang Anda pilih, Anda juga harus menentukan jumlah CPU yang sesuai. Tabel berikut menunjukkan nilai CPU minimum dan maksimum untuk setiap nilai memori:

Memori	CPU minimum	CPU Maksimum
256Mi ke 512Mi	0.33	2
Lebih besar dari 512Mi dan kurang dari atau sama dengan 1Gi	0.5	2
Lebih besar dari 1Gi dan lebih kecil dari 2Gi	1	2
2Gi ke 4Gi	1	4
Lebih dari 4Gi dan hingga 8Gi	2	4
Lebih dari 8Gi dan hingga 16Gi	4	4

Atau, jika Anda telah menentukan jumlah CPU yang dialokasikan, Anda dapat menggunakan tabel berikut untuk menentukan rentang memori yang sesuai:

CPU	Memori minimum	Memori maksimum
Kurang dari 0.5	256Mi	512Mi
0.5 menjadi kurang dari 1	256Mi	1Gi
1	256Mi	4Gi
2	256Mi	8Gi
4	2Gi	16Gi

Memanggil Google Cloud atau layanan online dalam kode Python

UDF Python mengakses layanan atau layanan eksternal menggunakan akun layanan koneksi resource Cloud. Google Cloud Akun layanan koneksi harus diberi izin untuk mengakses layanan. Izin yang diperlukan bervariasi bergantung pada layanan yang diakses dan API yang dipanggil dari kode Python Anda.

Jika Anda membuat UDF Python tanpa menggunakan koneksi resource Cloud, fungsi akan dieksekusi di lingkungan yang memblokir akses jaringan. Jika UDF Anda mengakses layanan online, Anda harus membuat UDF dengan koneksi resource Cloud. Jika tidak, UDF akan diblokir untuk mengakses jaringan hingga batas waktu koneksi internal tercapai.

Contoh berikut menunjukkan cara mengakses layanan Cloud Translation dari UDF Python. Contoh ini memiliki dua project—project bernama my_query_project tempat Anda membuat UDF dan koneksi resource Cloud, serta project tempat Anda menjalankan Cloud Translation bernama my_translate_project.

Membuat koneksi resource Cloud

Pertama, Anda membuat koneksi resource Cloud di my_query_project. Untuk membuat koneksi resource cloud, ikuti langkah-langkah berikut.

Pilih salah satu opsi berikut:

Konsol

1. Buka halaman BigQuery.

   Buka BigQuery

2. Di panel kiri, klik Explorer:

   

   Jika Anda tidak melihat panel kiri, klik Luaskan panel kiri untuk membuka panel.

3. Di panel Explorer, luaskan nama project Anda, lalu klik Connections.

4. Di halaman Koneksi, klik Buat koneksi.

5. Untuk Connection type, pilih Vertex AI remote models, remote functions, BigLake and Spanner (Cloud Resource).

6. Di kolom Connection ID, masukkan nama untuk koneksi Anda.

7. Untuk Location type, pilih lokasi untuk koneksi Anda. Koneksi harus ditempatkan bersama resource Anda yang lain seperti set data.

8. Klik Create connection.

9. Klik Go to connection.

10. Di panel Connection info, salin ID akun layanan untuk digunakan pada langkah berikutnya.

SQL

Gunakan pernyataan CREATE CONNECTION:

1. Di konsol Google Cloud , buka halaman BigQuery.

   Buka BigQuery

2. Di editor kueri, masukkan pernyataan berikut:

   CREATE CONNECTION [IF NOT EXISTS] `CONNECTION_NAME`
   OPTIONS (
     connection_type = "CLOUD_RESOURCE",
     friendly_name = "FRIENDLY_NAME",
     description = "DESCRIPTION"
     );

   Ganti kode berikut:

   • CONNECTION_NAME: nama koneksi dalam format PROJECT_ID.LOCATION.CONNECTION_ID, LOCATION.CONNECTION_ID, atau CONNECTION_ID. Jika project atau lokasi dihilangkan, maka project atau lokasi tersebut disimpulkan dari project dan lokasi tempat pernyataan dijalankan.
   • FRIENDLY_NAME (opsional): nama deskriptif untuk koneksi.
   • DESCRIPTION (opsional): deskripsi koneksi.

3. Klik Run.

Untuk mengetahui informasi selengkapnya tentang cara menjalankan kueri, lihat artikel Menjalankan kueri interaktif.

bq

1. Di lingkungan command line, buat koneksi:

   bq mk --connection --location=REGION --project_id=PROJECT_ID \
       --connection_type=CLOUD_RESOURCE CONNECTION_ID

   Parameter --project_id akan mengganti project default.

   Ganti kode berikut:

   • REGION: region koneksi Anda
   • PROJECT_ID: Project ID Google Cloud Anda
   • CONNECTION_ID: ID untuk koneksi Anda

   Saat Anda membuat resource koneksi, BigQuery akan membuat akun layanan sistem unik dan mengaitkannya dengan koneksi.

   Pemecahan masalah: Jika Anda mendapatkan error koneksi berikut, update Google Cloud SDK:

   Flags parsing error: flag --connection_type=CLOUD_RESOURCE: value should be one of...
   

2. Ambil dan salin ID akun layanan untuk digunakan pada langkah berikutnya:

   bq show --connection PROJECT_ID.REGION.CONNECTION_ID

   Outputnya mirip dengan hal berikut ini:

   name                          properties
   1234.REGION.CONNECTION_ID     {"serviceAccountId": "[e-mail]"}
   

Python

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Python di Panduan memulai BigQuery menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi BigQuery Python API.

Untuk melakukan autentikasi ke BigQuery, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien.

import google.api_core.exceptions
from google.cloud import bigquery_connection_v1

client = bigquery_connection_v1.ConnectionServiceClient()


def create_connection(
    project_id: str,
    location: str,
    connection_id: str,
):
    """Creates a BigQuery connection to a Cloud Resource.

    Cloud Resource connection creates a service account which can then be
    granted access to other Google Cloud resources for federated queries.

    Args:
        project_id: The Google Cloud project ID.
        location: The location of the connection (for example, "us-central1").
        connection_id: The ID of the connection to create.
    """

    parent = client.common_location_path(project_id, location)

    connection = bigquery_connection_v1.Connection(
        friendly_name="Example Connection",
        description="A sample connection for a Cloud Resource.",
        cloud_resource=bigquery_connection_v1.CloudResourceProperties(),
    )

    try:
        created_connection = client.create_connection(
            parent=parent, connection_id=connection_id, connection=connection
        )
        print(f"Successfully created connection: {created_connection.name}")
        print(f"Friendly name: {created_connection.friendly_name}")
        print(
            f"Service Account: {created_connection.cloud_resource.service_account_id}"
        )

    except google.api_core.exceptions.AlreadyExists:
        print(f"Connection with ID '{connection_id}' already exists.")
        print("Please use a different connection ID.")
    except Exception as e:
        print(f"An unexpected error occurred while creating the connection: {e}")

Node.js

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Node.js di Panduan memulai BigQuery menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi BigQuery Node.js API.

Untuk melakukan autentikasi ke BigQuery, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien.

const {ConnectionServiceClient} =
  require('@google-cloud/bigquery-connection').v1;
const {status} = require('@grpc/grpc-js');

const client = new ConnectionServiceClient();

/**
 * Creates a new BigQuery connection to a Cloud Resource.
 *
 * A Cloud Resource connection creates a service account that can be granted access
 * to other Google Cloud resources.
 *
 * @param {string} projectId The Google Cloud project ID. for example, 'example-project-id'
 * @param {string} location The location of the project to create the connection in. for example, 'us-central1'
 * @param {string} connectionId The ID of the connection to create. for example, 'example-connection-id'
 */
async function createConnection(projectId, location, connectionId) {
  const parent = client.locationPath(projectId, location);

  const connection = {
    friendlyName: 'Example Connection',
    description: 'A sample connection for a Cloud Resource',
    // The service account for this cloudResource will be created by the API.
    // Its ID will be available in the response.
    cloudResource: {},
  };

  const request = {
    parent,
    connectionId,
    connection,
  };

  try {
    const [response] = await client.createConnection(request);

    console.log(`Successfully created connection: ${response.name}`);
    console.log(`Friendly name: ${response.friendlyName}`);

    console.log(`Service Account: ${response.cloudResource.serviceAccountId}`);
  } catch (err) {
    if (err.code === status.ALREADY_EXISTS) {
      console.log(`Connection '${connectionId}' already exists.`);
    } else {
      console.error(`Error creating connection: ${err.message}`);
    }
  }
}

Terraform

Gunakan resource google_bigquery_connection.

Catatan: Untuk membuat objek BigQuery menggunakan Terraform, Anda harus mengaktifkan Cloud Resource Manager API.

Untuk melakukan autentikasi ke BigQuery, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien.

Contoh berikut membuat koneksi resource Cloud bernama my_cloud_resource_connection di region US:

# This queries the provider for project information.
data "google_project" "default" {}

# This creates a cloud resource connection in the US region named my_cloud_resource_connection.
# Note: The cloud resource nested object has only one output field - serviceAccountId.
resource "google_bigquery_connection" "default" {
  connection_id = "my_cloud_resource_connection"
  project       = data.google_project.default.project_id
  location      = "US"
  cloud_resource {}
}

Untuk menerapkan konfigurasi Terraform di project, selesaikan langkah-langkah di bagian berikut. Google Cloud

Menyiapkan Cloud Shell

1. Luncurkan Cloud Shell.

2. Tetapkan project Google Cloud default tempat Anda ingin menerapkan konfigurasi Terraform.

   Anda hanya perlu menjalankan perintah ini sekali per project, dan dapat dijalankan di direktori mana pun.

   export GOOGLE_CLOUD_PROJECT=PROJECT_ID

   Variabel lingkungan akan diganti jika Anda menetapkan nilai eksplisit dalam file konfigurasi Terraform.

Menyiapkan direktori

Setiap file konfigurasi Terraform harus memiliki direktorinya sendiri (juga disebut modul root).

1. Di Cloud Shell, buat direktori dan file baru di dalam direktori tersebut. Nama file harus memiliki ekstensi .tf—misalnya main.tf. Dalam tutorial ini, file ini disebut sebagai main.tf.

   mkdir DIRECTORY && cd DIRECTORY && touch main.tf

2. Jika mengikuti tutorial, Anda dapat menyalin kode contoh di setiap bagian atau langkah.

   Salin kode contoh ke dalam main.tf yang baru dibuat.

   Atau, salin kode dari GitHub. Tindakan ini direkomendasikan jika cuplikan Terraform adalah bagian dari solusi menyeluruh.

3. Tinjau dan ubah contoh parameter untuk diterapkan pada lingkungan Anda.
4. Simpan perubahan Anda.
5. Lakukan inisialisasi Terraform. Anda hanya perlu melakukan ini sekali per direktori.

   terraform init

   Secara opsional, untuk menggunakan versi penyedia Google terbaru, sertakan opsi -upgrade:

   terraform init -upgrade

Menerapkan perubahan

1. Tinjau konfigurasi dan pastikan resource yang akan dibuat atau diupdate oleh Terraform sesuai yang Anda inginkan:

   terraform plan

   Koreksi konfigurasi jika diperlukan.

2. Terapkan konfigurasi Terraform dengan menjalankan perintah berikut dan memasukkan yes pada prompt:

   terraform apply

   Tunggu hingga Terraform menampilkan pesan "Apply complete!".

3. Buka Google Cloud project Anda untuk melihat hasilnya. Di konsol Google Cloud , buka resource Anda di UI untuk memastikan bahwa Terraform telah membuat atau mengupdatenya.

Catatan: Contoh Terraform biasanya mengasumsikan bahwa API yang diperlukan sudah diaktifkan di project Google Cloud Anda.

Memberikan akses ke akun layanan koneksi

Anda memerlukan ID akun layanan yang Anda salin sebelumnya saat mengonfigurasi izin untuk koneksi. Saat Anda membuat resource koneksi, BigQuery akan membuat akun layanan sistem unik dan mengaitkannya dengan koneksi.

Untuk memberikan akses akun layanan koneksi resource Cloud ke project Anda, berikan peran Service Usage Consumer (roles/serviceusage.serviceUsageConsumer) di my_query_project dan peran pengguna Cloud Translation API (roles/cloudtranslate.user) di my_translate_project kepada akun layanan tersebut.

1. Buka halaman IAM.

   Buka IAM

2. Pastikan my_query_project dipilih.

3. Klik Berikan Akses.

4. Di kolom New principals, masukkan ID akun layanan koneksi resource Cloud yang Anda salin sebelumnya.

5. Di kolom Select a role, pilih Service usage, lalu pilih Service usage consumer.

6. Klik Simpan.

7. Di pemilih project, pilih my_translate_project.

8. Buka halaman IAM.

   Buka IAM

9. Klik Berikan Akses.

10. Di kolom New principals, masukkan ID akun layanan koneksi resource Cloud yang Anda salin sebelumnya.

11. Di kolom Pilih peran, pilih Cloud Translation, lalu pilih Pengguna Cloud Translation API.

12. Klik Simpan.

Membuat UDF Python yang memanggil layanan Cloud Translation

Di my_query_project, buat UDF Python yang memanggil layanan Cloud Translation menggunakan koneksi resource Cloud Anda.

1. Di konsol Google Cloud , buka halaman BigQuery.

   Buka BigQuery

2. Masukkan pernyataan CREATE FUNCTION berikut di editor kueri:

   CREATE FUNCTION `PROJECT_ID.DATASET_ID`.translate_to_es(x STRING)
   RETURNS STRING LANGUAGE python
   WITH CONNECTION `PROJECT_ID.REGION.CONNECTION_ID`
   OPTIONS (entry_point='do_translate', runtime_version='python-3.11', packages=['google-cloud-translate>=3.11', 'google-api-core'])
   AS r"""
   
   from google.api_core.retry import Retry
   from google.cloud import translate
   
   project = "my_translate_project"
   translate_client = translate.TranslationServiceClient()
   
   def do_translate(x : str) -> str:
   
       response = translate_client.translate_text(
           request={
               "parent": f"projects/{project}/locations/us-central1",
               "contents": [x],
               "target_language_code": "es",
               "mime_type": "text/plain",
           },
           retry=Retry(),
       )
       return response.translations[0].translated_text
   
   """;
   
   -- Call the UDF.
   WITH text_table AS
     (SELECT "Hello" AS text
     UNION ALL
     SELECT "Good morning" AS text
     UNION ALL
     SELECT "Goodbye" AS text)
   SELECT text,
   `PROJECT_ID.DATASET_ID`.translate_to_es(text) AS translated_text
   FROM text_table;

   Ganti kode berikut:

   • PROJECT_ID.DATASET_ID: project ID dan ID set data Anda
   • REGION.CONNECTION_ID: region dan ID koneksi Anda

3. Klik  Run.

   Outputnya akan terlihat seperti berikut ini:

   +--------------------------+-------------------------------+
   | text                     | translated_text               |
   +--------------------------+-------------------------------+
   | Hello                    | Hola                          |
   | Good morning             | Buen dia                      |
   | Goodbye                  | Adios                         |
   +--------------------------+-------------------------------+
   

Praktik terbaik

Saat membuat UDF Python, ikuti praktik terbaik berikut:

• Optimalkan logika kueri Anda untuk pengelompokan. Struktur kueri yang kompleks dapat menonaktifkan batching. Hal ini memaksa pemrosesan baris demi baris yang lambat, yang secara signifikan meningkatkan latensi pada set data besar.
• Hindari UDF dalam ekspresi bersyarat.
• Hindari penggunaan UDF untuk menyematkan kolom STRUCT secara langsung.
• Mengisolasi UDF dalam proyeksi. Untuk memastikan pengelompokan, jalankan UDF dalam pernyataan SELECT dengan menggunakan Common Table Expression (CTE) atau subkueri. Kemudian, lakukan pemfilteran atau penggabungan pada hasil tersebut dalam langkah terpisah.
• Mengoptimalkan payload data. Ukuran setiap baris dapat memengaruhi efisiensi fitur pengelompokan.
• Minimalkan ukuran baris. Buat setiap baris sekecil mungkin untuk memaksimalkan jumlah baris yang dapat diproses dalam satu batch.
• Konfigurasi batas container secara efisien. Skalabilitas adalah fungsi CPU, memori, dan konkurensi permintaan.
• Saat menggunakan penyesuaian iteratif, mulailah dengan nilai default. Jika performa tidak optimal, analisis metrik pemantauan untuk mengidentifikasi bottleneck tertentu.
• Menskalakan resource Anda. Jika metrik pemantauan menunjukkan tingkat pemakaian yang tinggi, tingkatkan CPU dan memori yang dialokasikan.
• Mengelola dependensi dan keandalan eksternal. UDF yang berinteraksi dengan layanan eksternal memerlukan koneksi dan izin yang sesuai.
• Terapkan waktu tunggu API. Saat UDF Python Anda mengakses internet, tetapkan waktu tunggu pada panggilan API untuk menghindari perilaku yang tidak terduga. Contoh akses internet adalah membaca dari bucket Cloud Storage.

Melihat metrik UDF Python

UDF Python mengekspor metrik ke Cloud Monitoring. Metrik ini membantu Anda memantau berbagai aspek kondisi operasional dan konsumsi resource UDF, sehingga memberikan insight tentang performa dan perilaku instance UDF Anda.

Jenis resource pemantauan

Metrik untuk UDF Python dilaporkan dalam jenis resource Cloud Monitoring berikut:

• Jenis: bigquery.googleapis.com/ManagedRoutineInvocation
• Nama Tampilan: Pemanggilan Rutin Terkelola BigQuery
• Label:
  • resource_container: ID project tempat tugas kueri dijalankan.
  • location: lokasi tempat tugas kueri dijalankan.
  • query_job_id: ID tugas kueri yang memanggil UDF Python.
  • routine_project_id: project ID tempat rutin yang dipanggil disimpan.
  • routine_dataset_id: ID set data tempat rutinitas yang dipanggil disimpan.
  • routine_id: ID rutinitas yang dipanggil.

Metrik

Metrik berikut tersedia untuk jenis resource bigquery.googleapis.com/ManagedRoutineInvocation:

Metrik	Deskripsi	Unit	Jenis nilai
bigquery.googleapis.com/managed_routine/python/cpu_utilizations	Saat UDF Python dipanggil, metrik ini menunjukkan distribusi pemakaian CPU di semua instance UDF Python untuk tugas kueri.	10^2.%	DISTRIBUTION
bigquery.googleapis.com/managed_routine/python/memory_utilizations	Saat UDF Python dipanggil, metrik ini menunjukkan distribusi penggunaan memori di semua instance UDF Python untuk tugas kueri.	10^2.%	DISTRIBUTION
bigquery.googleapis.com/managed_routine/python/max_request_concurrencies	Metrik ini menunjukkan distribusi jumlah maksimum permintaan serentak yang ditayangkan oleh setiap instance UDF Python.	Jumlah	DISTRIBUTION

Lihat metrik

Untuk melihat metrik UDF Python, pilih salah satu opsi di bagian berikut.

Detail tugas

Untuk melihat metrik UDF Python untuk tugas kueri tertentu, ikuti langkah-langkah berikut:

1. Buka halaman BigQuery.

   Buka BigQuery

2. Klik Histori tugas.

3. Di kolom Job ID, klik ID tugas kueri.

4. Di halaman Query job details, klik Cloud Monitoring dashboard. Link ini menampilkan dasbor yang difilter untuk menampilkan metrik UDF Python untuk tugas.

Metrics Explorer

Untuk melihat metrik UDF Python di Metrics Explorer, ikuti langkah-langkah berikut:

1. Buka halaman Metrics explorer Cloud Monitoring.

   Buka Metrics explorer

2. Klik Select a metric, lalu di kolom Filter, ketik BigQuery Managed Routine Invocation atau bigquery.googleapis.com/ManagedRoutineInvocation.

3. Pilih Bigquery Managed Routine > Managed_routine.

4. Klik salah satu metrik yang tersedia seperti berikut:

   • Penggunaan CPU instance
   • Penggunaan memori instance
   • Permintaan serentak maksimum

5. Klik Terapkan.

   Secara default, metrik ditampilkan dalam diagram.

6. Anda dapat memfilter dan mengelompokkan metrik menggunakan label yang ditentukan dalam jenis resource Monitoring. Untuk memfilter metrik, ikuti langkah-langkah berikut:

   1. Di kolom Filter, pilih jenis resource seperti query_job_id atau routine_id.

   2. Di kolom Nilai, masukkan ID tugas atau ID rutin, atau pilih salah satu dari daftar.

Dasbor Cloud Monitoring

Untuk melihat metrik UDF Python menggunakan dasbor pemantauan, ikuti langkah-langkah berikut:

1. Buka halaman Dasbor Cloud Monitoring.

   Buka Dasbor

2. Klik dasbor BigQuery Managed Routine Query Monitoring.

   Dasbor ini memberikan ringkasan metrik utama di seluruh UDF Anda.

3. Untuk memfilter dasbor ini, ikuti langkah-langkah berikut:

   1. Klik Filter.

   2. Di daftar Filter menurut resource, pilih opsi seperti ID project, lokasi, ID rutinitas, atau ID tugas.

Lokasi yang didukung

UDF Python didukung di semua lokasi multi-region dan regional BigQuery.

Harga

UDF Python ditawarkan tanpa biaya tambahan.

Jika penagihan diaktifkan, hal berikut akan berlaku:

• Biaya UDF Python ditagih menggunakan SKU Layanan BigQuery.
• Biaya sebanding dengan jumlah komputasi dan memori yang digunakan saat UDF Python dipanggil.
• Pelanggan UDF Python juga dikenai biaya untuk pembuatan atau pembuatan ulang image container UDF. Biaya ini sebanding dengan resource yang digunakan untuk membangun image dengan kode dan dependensi pelanggan.
• Jika UDF Python menghasilkan traffic keluar jaringan eksternal atau internet, Anda juga akan melihat biaya traffic keluar internet Tingkat Premium dari Cloud Networking.

Kuota

Lihat Kuota dan batas UDF.