Utiliser des fonctions définies par l'utilisateur dans Python

Une fonction définie par l'utilisateur (UDF) Python vous permet d'implémenter une fonction scalaire en Python et de l'utiliser dans une requête SQL. Les UDF Python sont semblables aux UDF SQL et JavaScript, mais avec des fonctionnalités supplémentaires. Les UDF Python vous permettent d'installer des bibliothèques tierces à partir de l'index de packages Python (PyPI) et d'accéder à des services externes à l'aide d'une connexion à une ressource Cloud.

Les UDF Python sont créées et exécutées sur des ressources gérées par BigQuery.

Limites

python-3.11 est le seul environnement d'exécution compatible.
Vous ne pouvez pas créer d'UDF Python temporaire.
Vous ne pouvez pas utiliser de UDF Python avec une vue matérialisée.
Les résultats d'une requête qui appelle une UDF Python ne sont pas mis en cache, car la valeur renvoyée par une UDF Python est toujours considérée comme non déterministe.
Les réseaux VPC ne sont pas acceptés.
Les charges de travail assurées ne sont pas acceptées.
Les types de données suivants ne sont pas acceptés : JSON, RANGE, INTERVAL et GEOGRAPHY.
Les conteneurs qui exécutent des UDF Python ne peuvent être configurés qu'avec 4 processeurs virtuels et 16 Gio.
Les clés de chiffrement gérées par le client (CMEK) ne sont pas prises en charge.

Rôles requis

Les rôles IAM requis dépendent de votre statut (propriétaire ou utilisateur d'une UDF Python).

Propriétaires des UDF

Le propriétaire d'une UDF Python crée ou met à jour une UDF. Des rôles supplémentaires sont également requis si vous créez une UDF Python qui fait référence à une connexion à une ressource cloud. Cette connexion n'est requise que si votre UDF utilise la clause WITH CONNECTION pour accéder à un service externe.

Pour obtenir les autorisations nécessaires pour créer ou mettre à jour une UDF Python, demandez à votre administrateur de vous accorder les rôles IAM suivants :

Éditeur de données BigQuery (roles/bigquery.dataEditor) sur l'ensemble de données
Utilisateur de job BigQuery (roles/bigquery.jobUser) sur le projet
Administrateur de connexion BigQuery (roles/bigquery.connectionAdmin) sur le projet

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Ces rôles prédéfinis contiennent les autorisations requises pour créer ou mettre à jour une UDF Python. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour créer ou mettre à jour une UDF Python :

Créez une UDF Python à l'aide de l'instruction CREATE FUNCTION : bigquery.routines.create sur l'ensemble de données.
Mettez à jour une UDF Python à l'aide de l'instruction CREATE FUNCTION : bigquery.routines.update sur l'ensemble de données.
Exécutez une tâche de requête d'instruction CREATE FUNCTION : bigquery.jobs.create sur le projet
Créez une connexion à une ressource Cloud : bigquery.connections.create sur le projet
Utilisez une connexion dans l'instruction CREATE FUNCTION : bigquery.connections.delegate sur la connexion

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Pour en savoir plus sur les rôles dans BigQuery, consultez Rôles IAM prédéfinis.

Utilisateurs UDF

Un utilisateur d'UDF Python appelle une UDF créée par un autre utilisateur. Des rôles supplémentaires sont également requis si vous appelez une UDF Python qui fait référence à une connexion à une ressource Cloud.

Pour obtenir les autorisations nécessaires pour appeler une UDF Python créée par un autre utilisateur, demandez à votre administrateur de vous accorder les rôles IAM suivants :

Utilisateur BigQuery (roles/bigquery.user) sur le projet
Lecteur de données BigQuery (roles/bigquery.dataViewer) sur l'ensemble de données
Utilisateur de connexion BigQuery (roles/bigquery.connectionUser) sur la connexion

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Ces rôles prédéfinis contiennent les autorisations requises pour appeler une UDF Python créée par un autre utilisateur. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour appeler une UDF Python créée par un autre utilisateur :

Pour exécuter un job de requête qui fait référence à une UDF Python : bigquery.jobs.create sur le projet
Pour appeler une UDF Python créée par un autre utilisateur : bigquery.routines.get sur l'ensemble de données
Pour exécuter une UDF Python qui fait référence à une connexion de ressource Cloud : bigquery.connections.use sur la connexion

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Pour en savoir plus sur les rôles dans BigQuery, consultez Rôles IAM prédéfinis.

Appeler une UDF Python

Si vous êtes autorisé à appeler une UDF Python, vous pouvez l'appeler comme n'importe quelle autre fonction. Pour utiliser une fonction définie dans un autre projet, utilisez le nom complet de la fonction. Par exemple, pour appeler l'UDF Python cw_xml_extract définie comme UDF de la communauté bigquery-utils, procédez comme suit :

Console

Accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez l'exemple suivant :

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)
])

Cliquez sur Exécuter.

Cet exemple génère la sortie suivante :

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

BigQuery DataFrames

L'exemple suivant utilise les méthodes BigQuery DataFrames sql_scalar, read_gbq_function et apply pour appeler une 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

Créer une UDF Python persistante

Lorsque vous créez une UDF Python, respectez les règles suivantes :

Le corps de l'UDF Python doit être une chaîne littérale entre guillemets représentant le code Python. Pour en savoir plus sur les littéraux de chaîne entre guillemets, consultez Formats des littéraux entre guillemets.
Le corps de la fonction Python définie par l'utilisateur doit inclure une fonction Python utilisée dans l'argument entry_point de la liste des options de la fonction Python définie par l'utilisateur.
Une version d'environnement d'exécution Python doit être spécifiée dans l'option runtime_version. La seule version d'exécution Python compatible est python-3.11. Pour obtenir la liste complète des options disponibles, consultez la liste des options de fonction pour l'instruction CREATE FUNCTION.

Pour créer une UDF Python persistante, utilisez l'instruction CREATE FUNCTION sans le mot clé TEMP ni TEMPORARY. Pour supprimer une UDF Python persistante, utilisez l'instruction DROP FUNCTION.

Lorsque vous créez une UDF Python à l'aide de l'instruction CREATE FUNCTION, BigQuery crée ou met à jour une image de conteneur basée sur une image de base. Le conteneur est créé sur l'image de base à l'aide de votre code et de toutes les dépendances de package spécifiées. La création du conteneur est un processus de longue durée. La première requête après l'exécution de l'instruction CREATE FUNCTION peut attendre automatiquement la fin de l'opération d'imagerie. Sans aucune dépendance externe, l'image de conteneur devrait généralement être créée en moins d'une minute.

Exemple

Pour voir un exemple de création d'une UDF Python persistante, choisissez l'une des options suivantes :

Console

L'exemple suivant crée une fonction Python persistante définie par l'utilisateur nommée multiplyInputs et appelle cette UDF à partir d'une instruction SELECT :

Accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez l'instruction CREATE FUNCTION suivante :

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;

Remplacez PROJECT_ID.DATASET_ID par l'ID de votre projet et l'ID de l'ensemble de données.

Cliquez sur Exécuter.

Cet exemple génère la sortie suivante :

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

BigQuery DataFrames

L'exemple suivant utilise BigQuery DataFrames pour transformer une fonction personnalisée en 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}")

Créer une UDF Python vectorisée

Vous pouvez implémenter votre UDF Python pour traiter un lot de lignes au lieu d'une seule ligne en utilisant la vectorisation. La vectorisation peut améliorer les performances des requêtes. Vous pouvez créer une UDF vectorisée à l'aide de Pandas ou d'Apache Arrow.

Pour contrôler le comportement de la mise en lot, spécifiez le nombre maximal de lignes dans chaque lot à l'aide de l'option max_batching_rows dans la liste d'options CREATE OR REPLACE FUNCTION. Si vous spécifiez max_batching_rows, BigQuery détermine le nombre de lignes d'un lot, dans la limite de max_batching_rows. Si max_batching_rows n'est pas spécifié, le nombre de lignes à regrouper est déterminé automatiquement.

Utiliser Pandas

Une UDF Python vectorisée comporte un seul argument pandas.DataFrame qui doit être annoté. L'argument pandas.DataFrame comporte le même nombre de colonnes que les paramètres UDF Python définis dans l'instruction CREATE FUNCTION. Les noms de colonnes de l'argument pandas.DataFrame sont identiques à ceux des paramètres de la UDF'utilisateur.

Votre fonction doit renvoyer un pandas.Series ou un pandas.DataFrame à une seule colonne avec le même nombre de lignes que l'entrée.

L'exemple suivant crée une UDF Python vectorisée nommée multiplyInputs avec deux paramètres : x et y :

Accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez l'instruction CREATE FUNCTION suivante :

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']

''';

Remplacez PROJECT_ID.DATASET_ID par l'ID de votre projet et l'ID de l'ensemble de données.

L'appel de l'UDF est identique à celui de l'exemple précédent.

Cliquez sur Exécuter.

Utiliser Apache Arrow

L'exemple suivant utilise l'interface RecordBatch Apache Arrow. Lorsque vous utilisez l'interface RecordBatch, la fonction transmet un lot de lignes de colonnes de même longueur au point d'entrée. L'exemple suivant utilise Apache Arrow pour créer une fonction Python vectorisée définie par l'utilisateur nommée multiplyVectorizedArrow.

Accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez l'instruction CREATE FUNCTION suivante :

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)
''';

Remplacez PROJECT_ID.DATASET_ID par l'ID de votre projet et l'ID de l'ensemble de données.

L'appel de l'UDF est identique à celui des exemples précédents.

Cliquez sur Exécuter.

Types de données compatibles avec les fonctions Python définies par l'utilisateur

Le tableau suivant définit la correspondance entre les types de données BigQuery, Python et Pandas :

Type de données BigQuery	Type de données Python intégré utilisé par les UDF standards	Type de données Pandas utilisé par l'UDF vectorisée	Type de données PyArrow utilisé pour ARRAY et STRUCT dans les UDF vectorisées
`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`	Paramètre de fonction : `datetime.datetime` (avec le fuseau horaire UTC défini) Valeur renvoyée par la fonction : `datetime.datetime` (avec n'importe quel fuseau horaire défini)	Paramètre de la fonction : `timestamp[us, tz=UTC][pyarrow]` Valeur renvoyée par la fonction : `timestamp[us, tz=*][pyarrow]\(any timezone\)`	`TimestampType(timestamp[us])`, avec fuseau horaire
`DATE`	`datetime.date`	`date32[pyarrow]`	`DataType(date32[day])`
`TIME`	`datetime.time`	`time64[pyarrow]`	`Time64Type(time64[us])`
`DATETIME`	`datetime.datetime` (sans fuseau horaire)	`timestamp[us][pyarrow]`	`TimestampType(timestamp[us])`, sans fuseau horaire
`ARRAY`	`list`	`list<...>[pyarrow]`, où le type de données de l'élément est `pandas.ArrowDtype`	`ListType`
`STRUCT`	`dict`	`struct<...>[pyarrow]`, où le type de données du champ est `pandas.ArrowDtype`	`StructType`

Versions d'exécution compatibles

Les UDF Python BigQuery sont compatibles avec l'environnement d'exécution python-3.11. Cette version de Python inclut des packages préinstallés supplémentaires. Pour les bibliothèques système, vérifiez l'image de base de l'environnement d'exécution.

Version d'exécution	Version Python	Inclut
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

Utiliser des packages tiers

Vous pouvez utiliser la liste d'options CREATE FUNCTION pour utiliser des modules autres que ceux fournis par la bibliothèque standard Python et les packages préinstallés. Vous pouvez installer des packages à partir de l'index de packages Python (PyPI) ou importer des fichiers Python depuis Cloud Storage.

Installer un package à partir de l'index de packages Python

Lorsque vous installez un package, vous devez fournir son nom et vous pouvez éventuellement fournir sa version à l'aide des spécificateurs de version de package Python.

Si le package se trouve dans l'environnement d'exécution, il est utilisé, sauf si une version spécifique est spécifiée dans la liste d'options CREATE FUNCTION. Si aucune version de package n'est spécifiée et que le package n'est pas dans l'environnement d'exécution, la dernière version disponible est utilisée. Seuls les packages au format binaire Wheel sont acceptés.

L'exemple suivant montre comment créer une UDF Python qui installe le package scipy à l'aide de la liste d'options CREATE OR REPLACE FUNCTION :

Accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez l'instruction CREATE FUNCTION suivante :

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);

Remplacez PROJECT_ID.DATASET_ID par l'ID de votre projet et l'ID de l'ensemble de données.

Cliquez sur Exécuter.

Importer des fichiers Python supplémentaires en tant que bibliothèques

Vous pouvez étendre vos fonctions Python définies par l'utilisateur à l'aide de la liste des options de fonction en important des fichiers Python depuis Cloud Storage.

Dans le code Python de votre UDF, vous pouvez importer les fichiers Python depuis Cloud Storage en tant que modules à l'aide de l'instruction import suivie du chemin d'accès à l'objet Cloud Storage. Par exemple, si vous importez gs://BUCKET_NAME/path/to/lib1.py, votre instruction d'importation sera import path.to.lib1.

Le nom de fichier Python doit être un identifiant Python. Chaque nom folder dans le nom de l'objet (après /) doit être un identifiant Python valide. Dans la plage ASCII (U+0001..U+007F), les caractères suivants peuvent être utilisés dans les identifiants :

Lettres majuscules et minuscules de A à Z.
Tirets du 8.
Les chiffres de zéro à neuf, mais un chiffre ne peut pas apparaître comme premier caractère de l'identifiant.

L'exemple suivant vous montre comment créer une UDF Python qui importe le package de bibliothèque cliente lib1.py à partir d'un bucket Cloud Storage nommé my_bucket :

Accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez l'instruction CREATE FUNCTION suivante :

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);

""";

Remplacez PROJECT_ID.DATASET_ID par l'ID de votre projet et l'ID de l'ensemble de données.

Cliquez sur Exécuter.

Configurer les limites de conteneur pour les UDF Python

Vous pouvez utiliser la liste d'options CREATE FUNCTION pour spécifier les limites de simultanéité des requêtes de processeur, de mémoire et de conteneur pour les conteneurs qui exécutent des UDF Python.

Par défaut, les conteneurs se voient attribuer les ressources suivantes :

La mémoire allouée est de 512Mi.
Le nombre de processeurs virtuels alloués est de 1.0.
La limite de simultanéité des requêtes de conteneur est de 80.

L'exemple suivant crée une fonction Python définie par l'utilisateur à l'aide de la liste d'options CREATE FUNCTION pour spécifier les limites du conteneur :

Accédez à la page BigQuery.

Accéder à BigQuery
Dans l'éditeur de requête, saisissez l'instruction CREATE FUNCTION suivante :
```
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()
""";
```
Remplacez les éléments suivants :
- PROJECT_ID.DATASET_ID : ID de votre projet et de votre ensemble de données.
- CONTAINER_MEMORY : valeur de la mémoire au format suivant : <integer_number><unit>. L'unité doit être l'une des valeurs suivantes : Mi (Mio), M (Mo), Gi (Gio) ou G (Go). Par exemple : 2Gi.
- CONTAINER_CPU : valeur du processeur. Les UDF Python acceptent les valeurs de CPU fractionnaires comprises entre 0.33 et 1.0, ainsi que les valeurs de CPU non fractionnaires de 1, 2 et 4.
- CONTAINER_REQUEST_CONCURRENCY : nombre maximal de requêtes simultanées par instance de conteneur UDF Python. La valeur doit être un nombre entier compris entre 1 et 1000.
Cliquez sur Exécuter.

Valeurs de processeur acceptées

Les UDF Python sont compatibles avec les valeurs de CPU fractionnaires comprises entre 0.33 et 1.0, ainsi qu'avec les valeurs de CPU non fractionnaires de 1, 2 et 4. Les conteneurs qui exécutent des UDF Python peuvent être configurés avec un maximum de 4 vCPU. La valeur par défaut est 1.0. Les valeurs d'entrée fractionnaires sont arrondies à deux décimales avant d'être appliquées au conteneur.

Valeurs de mémoire acceptées

Les conteneurs de fonctions Python définies par l'utilisateur acceptent les valeurs de mémoire au format suivant : <integer_number><unit>. L'unité doit être l'une des valeurs suivantes : Mi, M, Gi ou G. La quantité de mémoire minimale que vous pouvez configurer est de 256Mi. La quantité maximale de mémoire que vous pouvez configurer est de 16Gi.

En fonction de la valeur de mémoire que vous choisissez, vous devez également spécifier une quantité de processeur appropriée. Le tableau suivant indique les valeurs minimales et maximales du processeur pour chaque valeur de mémoire :

Mémoire	Processeur minimum	Processeur maximal
De `256Mi` à `512Mi`	`0.33`	`2`
Supérieur à `512Mi` et inférieur ou égal à `1Gi`	`0.5`	`2`
Supérieur à `1Gi` et inférieur à `2Gi`	`1`	`2`
De `2Gi` à `4Gi`	`1`	`4`
Supérieur à `4Gi` et inférieur ou égal à `8Gi`	`2`	`4`
Supérieur à `8Gi` et inférieur ou égal à `16Gi`	`4`	`4`

Si vous avez déterminé la quantité de processeur que vous allouez, vous pouvez utiliser le tableau suivant pour déterminer la plage de mémoire appropriée :

Processeur	Mémoire minimale	Taille maximale de la mémoire
Moins de `0.5`	`256Mi`	`512Mi`
`0.5` à moins de `1`	`256Mi`	`1Gi`
`1`	`256Mi`	`4Gi`
`2`	`256Mi`	`8Gi`
`4`	`2Gi`	`16Gi`

Appeler Google Cloud ou des services en ligne dans le code Python

Une UDF Python accède à un service Google Cloud ou à un service externe à l'aide du compte de service Connexion de ressource cloud. Le compte de service de la connexion doit disposer des autorisations nécessaires pour accéder au service. Les autorisations requises varient en fonction du service auquel vous accédez et des API appelées à partir de votre code Python.

Si vous créez une UDF Python sans utiliser de connexion à une ressource Cloud, la fonction est exécutée dans un environnement qui bloque l'accès au réseau. Si votre UDF accède à des services en ligne, vous devez la créer avec une connexion à une ressource Cloud. Sinon, la fonction définie par l'utilisateur ne pourra pas accéder au réseau tant qu'un délai de connexion interne ne sera pas atteint.

L'exemple suivant montre comment accéder au service Cloud Translation à partir d'une UDF Python. Cet exemple comporte deux projets : un projet nommé my_query_project dans lequel vous créez la fonction définie par l&#UDF et la connexion à la ressource Cloud, et un projet dans lequel vous exécutez Cloud Translation nommé my_translate_project.

Créer une connexion à une ressource cloud

Commencez par créer une connexion de ressource Cloud dans my_query_project. Pour créer la connexion à la ressource cloud, procédez comme suit.

Sélectionnez l'une des options suivantes :

Console

Accédez à la page BigQuery.

Accéder à BigQuery
Dans le volet de gauche, cliquez sur Explorateur :

Si le panneau de gauche n'apparaît pas, cliquez sur Développer le panneau de gauche pour l'ouvrir.
Dans le volet Explorateur, développez le nom de votre projet, puis cliquez sur Connexions.
Sur la page Connexions, cliquez sur Créer une connexion.
Pour Type de connexion, sélectionnez Modèles distants Vertex AI, fonctions à distance, BigLake et Spanner (ressource Cloud).
Dans le champ ID de connexion, saisissez un nom pour votre connexion.
Pour Type d'emplacement, sélectionnez un emplacement pour votre connexion. La connexion doit être colocalisée avec vos autres ressources, telles que les ensembles de données.
Cliquez sur Créer une connexion.
Cliquez sur Accéder à la connexion.
Dans le volet Informations de connexion, copiez l'ID du compte de service à utiliser à l'étape suivante.

SQL

Utilisez l'instruction CREATE CONNECTION :

Dans la console Google Cloud , accédez à la page BigQuery.

Accéder à BigQuery
Dans l'éditeur de requête, saisissez l'instruction suivante :
```
CREATE CONNECTION [IF NOT EXISTS] `CONNECTION_NAME`
OPTIONS (
  connection_type = "CLOUD_RESOURCE",
  friendly_name = "FRIENDLY_NAME",
  description = "DESCRIPTION"
  );
```
Remplacez les éléments suivants :
- CONNECTION_NAME : nom de la connexion au format PROJECT_ID.LOCATION.CONNECTION_ID, LOCATION.CONNECTION_ID ou CONNECTION_ID. Si le projet ou l'emplacement sont omis, ils sont déduits du projet et de l'emplacement où l'instruction est exécutée.
- FRIENDLY_NAME (facultatif) : nom descriptif de la connexion.
- DESCRIPTION (facultatif) : description de la connexion.
Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez Exécuter une requête interactive.

bq

Dans un environnement de ligne de commande, créez une connexion :
```
bq mk --connection --location=REGION --project_id=PROJECT_ID \
    --connection_type=CLOUD_RESOURCE CONNECTION_ID
```
Le paramètre --project_id remplace le projet par défaut.

Remplacez les éléments suivants :
- REGION : votre région de connexion
- PROJECT_ID : ID de votre projet Google Cloud
- CONNECTION_ID : ID de votre connexion
Lorsque vous créez une ressource de connexion, BigQuery crée un compte de service système unique et l'associe à la connexion.

Dépannage : Si vous obtenez l'erreur de connexion suivante, mettez à jour le Google Cloud SDK :
```
Flags parsing error: flag --connection_type=CLOUD_RESOURCE: value should be one of...
```

Récupérez et copiez l'ID du compte de service pour l'utiliser lors d'une prochaine étape :

bq show --connection PROJECT_ID.REGION.CONNECTION_ID

Le résultat ressemble à ce qui suit :

name                          properties
1234.REGION.CONNECTION_ID     {"serviceAccountId": "connection-1234-9u56h9@gcp-sa-bigquery-condel.iam.gserviceaccount.com"}

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Python.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Node.js.

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

Utilisez la ressource google_bigquery_connection.

L'exemple suivant crée une connexion de ressources Cloud nommée my_cloud_resource_connection dans la région 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 {}
}

Pour appliquer votre configuration Terraform dans un projet Google Cloud , suivez les procédures des sections suivantes.

Préparer Cloud Shell

Lancez Cloud Shell.
Définissez le projet Google Cloud par défaut dans lequel vous souhaitez appliquer vos configurations Terraform.

Vous n'avez besoin d'exécuter cette commande qu'une seule fois par projet et vous pouvez l'exécuter dans n'importe quel répertoire.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Les variables d'environnement sont remplacées si vous définissez des valeurs explicites dans le fichier de configuration Terraform.

Préparer le répertoire

Chaque fichier de configuration Terraform doit avoir son propre répertoire (également appelé module racine).

Dans Cloud Shell, créez un répertoire et un nouveau fichier dans ce répertoire. Le nom du fichier doit comporter l'extension .tf, par exemple main.tf. Dans ce tutoriel, le fichier est appelé main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
Si vous suivez un tutoriel, vous pouvez copier l'exemple de code dans chaque section ou étape.

Copiez l'exemple de code dans le fichier main.tf que vous venez de créer.

Vous pouvez également copier le code depuis GitHub. Cela est recommandé lorsque l'extrait Terraform fait partie d'une solution de bout en bout.
Examinez et modifiez les exemples de paramètres à appliquer à votre environnement.
Enregistrez les modifications.
Initialisez Terraform. Cette opération n'est à effectuer qu'une seule fois par répertoire.
```
terraform init
```
Vous pouvez également utiliser la dernière version du fournisseur Google en incluant l'option -upgrade :
```
terraform init -upgrade
```

Appliquer les modifications

Examinez la configuration et vérifiez que les ressources que Terraform va créer ou mettre à jour correspondent à vos attentes :
```
terraform plan
```
Corrigez les modifications de la configuration si nécessaire.
Appliquez la configuration Terraform en exécutant la commande suivante et en saisissant yes lorsque vous y êtes invité :
```
terraform apply
```
Attendez que Terraform affiche le message "Apply completed!" (Application terminée).
Ouvrez votre projet Google Cloud pour afficher les résultats. Dans la console Google Cloud , accédez à vos ressources dans l'interface utilisateur pour vous assurer que Terraform les a créées ou mises à jour.

Accorder l'accès au compte de service de la connexion

Vous aurez besoin de l'ID du compte de service que vous avez copié précédemment lorsque vous configurerez les autorisations pour la connexion. Lorsque vous créez une ressource de connexion, BigQuery crée un compte de service système unique et l'associe à la connexion.

Pour accorder au compte de service de connexion aux ressources Cloud l'accès à vos projets, attribuez-lui le rôle d'utilisateur du service d'utilisation des services (roles/serviceusage.serviceUsageConsumer) dans my_query_project et le rôle d'utilisateur de l'API Cloud Translation (roles/cloudtranslate.user) dans my_translate_project.

Accédez à la page IAM.

Accéder à IAM
Vérifiez que my_query_project est sélectionné.
Cliquez sur Accorder l'accès.
Dans le champ Nouveaux comptes principaux, saisissez l'ID du compte de service de la connexion à la ressource cloud que vous avez copié précédemment.
Dans le champ Sélectionner un rôle, choisissez Utilisation du service, puis sélectionnez Consommateur d'utilisation du service.
Cliquez sur Enregistrer.
Dans le sélecteur de projets, choisissez my_translate_project.
Accédez à la page IAM.

Accéder à IAM
Cliquez sur Accorder l'accès.
Dans le champ Nouveaux comptes principaux, saisissez l'ID du compte de service de la connexion à la ressource cloud que vous avez copié précédemment.
Dans le champ Sélectionner un rôle, sélectionnez Cloud Translation, puis Utilisateur de l'API Cloud Translation.
Cliquez sur Enregistrer.

Créer une UDF Python qui appelle le service Cloud Translation

Dans my_query_project, créez une UDF Python qui appelle le service Cloud Translation à l'aide de votre connexion de ressource cloud.

Dans la console Google Cloud , accédez à la page BigQuery.

Accéder à BigQuery

Saisissez l'instruction CREATE FUNCTION suivante dans l'éditeur de requête :

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;

Remplacez les éléments suivants :

PROJECT_ID.DATASET_ID : ID de votre projet et de votre ensemble de données
REGION.CONNECTION_ID : région et ID de votre connexion

Cliquez sur Exécuter.

Le résultat doit se présenter sous la forme suivante :

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

Bonnes pratiques

Lorsque vous créez des UDF Python, suivez ces bonnes pratiques :

Optimisez la logique de vos requêtes pour le traitement par lot. Les structures de requêtes complexes peuvent désactiver le traitement par lot. Cela force un traitement lent, ligne par ligne, ce qui augmente considérablement la latence sur les grands ensembles de données.
Évitez les UDF dans les expressions conditionnelles.
Évitez d'utiliser des UDF pour intégrer directement des champs STRUCT.
Isoler les UDF dans les projections. Pour garantir le traitement par lot, exécutez l'UDF dans une instruction SELECT à l'aide d'une expression de table commune (CTE) ou d'une sous-requête. Ensuite, appliquez des filtres ou des jointures à ce résultat dans une étape distincte.
Optimisez la charge utile des données. La taille des lignes individuelles peut avoir un impact sur l'efficacité de la fonctionnalité de traitement par lot.
Réduisez la taille des lignes. Réduisez la taille de chaque ligne au maximum pour maximiser le nombre de lignes pouvant être traitées dans un même lot.
Configurez efficacement les limites des conteneurs. La scalabilité dépend du processeur, de la mémoire et de la simultanéité des requêtes.
Lorsque vous utilisez le réglage itératif, commencez par les valeurs par défaut. Si les performances ne sont pas optimales, analysez les métriques de surveillance pour identifier les goulots d'étranglement spécifiques.
Faites évoluer vos ressources. Si les métriques de surveillance indiquent des niveaux d'utilisation élevés, augmentez le processeur et la mémoire alloués.
Gérez les dépendances externes et la fiabilité. Les UDF qui interagissent avec des services externes nécessitent une connexion et des autorisations appropriées.
Implémentez des délais d'attente pour les API. Lorsque votre UDF Python accède à Internet, définissez un délai avant expiration pour l'appel d'API afin d'éviter tout comportement inattendu. La lecture à partir d'un bucket Cloud Storage est un exemple d'accès à Internet.

Afficher les métriques des UDF Python

Les UDF Python exportent des métriques vers Cloud Monitoring. Ces métriques vous aident à surveiller différents aspects de l'état opérationnel et de la consommation de ressources de vos UDF. Elles vous fournissent des informations sur les performances et le comportement de vos instances UDF.

Type de ressource de surveillance

Les métriques pour les UDF Python sont signalées sous le type de ressource Cloud Monitoring suivant :

Type : bigquery.googleapis.com/ManagedRoutineInvocation
Nom à afficher : Appel de routine gérée BigQuery
Libellés :
- resource_container : ID du projet dans lequel le job de requête a été exécuté.
- location : emplacement où le job de requête a été exécuté.
- query_job_id : ID du job de requête qui a appelé l'UDF Python.
- routine_project_id : ID du projet dans lequel la routine appelée est stockée.
- routine_dataset_id : ID de l'ensemble de données dans lequel la routine appelée est stockée.
- routine_id : ID de la routine appelée.

Métriques

Les métriques suivantes sont disponibles pour le type de ressource bigquery.googleapis.com/ManagedRoutineInvocation :

Métrique	Description	Unité	Type de valeur
`bigquery.googleapis.com/managed_routine/python/cpu_utilizations`	Lorsqu'une UDF Python est appelée, cette métrique affiche la distribution de l'utilisation du processeur sur toutes les instances d'UDF Python pour le job de requête.	10².%	`DISTRIBUTION`
`bigquery.googleapis.com/managed_routine/python/memory_utilizations`	Lorsqu'une UDF Python est appelée, cette métrique affiche la distribution de l'utilisation de la mémoire sur toutes les instances d'UDF Python pour le job de requête.	10².%	`DISTRIBUTION`
`bigquery.googleapis.com/managed_routine/python/max_request_concurrencies`	Cette métrique indique la répartition du nombre maximal de requêtes simultanées traitées par chaque instance de fonction définie par l'utilisateur Python.	Nombre	`DISTRIBUTION`

Afficher les métriques

Pour afficher les métriques de vos UDF Python, choisissez l'une des options des sections suivantes.

Informations sur le job

Pour afficher les métriques des UDF Python pour un job de requête spécifique, procédez comme suit :

Accédez à la page BigQuery.

Accéder à BigQuery
Cliquez sur Historique des tâches.
Dans la colonne ID du job, cliquez sur l'ID du job de requête.
Sur la page Détails du job de requête, cliquez sur Tableau de bord Cloud Monitoring. Ce lien affiche un tableau de bord filtré pour afficher les métriques des UDF Python pour le job.

Explorateur de métriques

Pour afficher les métriques des UDF Python dans l'explorateur de métriques, procédez comme suit :

Accédez à la page Explorateur de métriques de Cloud Monitoring.

Accéder à l'explorateur de métriques
Cliquez sur Sélectionner une métrique, puis saisissez BigQuery Managed Routine Invocation ou bigquery.googleapis.com/ManagedRoutineInvocation dans le champ Filtre.
Choisissez Routine gérée BigQuery > managed_routine.
Cliquez sur l'une des métriques disponibles, par exemple :
- Utilisation du processeur de l'instance
- Utilisation de la mémoire de l'instance
- Nombre maximal de requêtes simultanées
Cliquez sur Appliquer.

Par défaut, les métriques sont affichées dans un graphique.
Vous pouvez filtrer et regrouper les métriques à l'aide des libellés définis dans les types de ressources Monitoring. Pour filtrer les métriques, procédez comme suit :
1. Dans le champ Filtre, sélectionnez un type de ressource tel que query_job_id ou routine_id.
2. Dans le champ Valeur, saisissez l'ID de la tâche ou de la routine, ou sélectionnez-en un dans la liste.

Tableaux de bord Cloud Monitoring

Pour afficher les métriques des UDF Python à l'aide des tableaux de bord de surveillance, procédez comme suit :

Accédez à la page Tableaux de bord de Cloud Monitoring.

Accéder à la page "Tableaux de bord"
Cliquez sur le tableau de bord Surveillance des requêtes de routine gérée BigQuery.

Ce tableau de bord fournit un aperçu des métriques clés de vos fonctions définies par l'utilisateur.
Pour filtrer ce tableau de bord, procédez comme suit :
1. Cliquez sur Filtrer.
2. Dans la liste Filtrer par ressource, sélectionnez une option telle que l'ID du projet, l'emplacement, l'ID de routine ou l'ID de job.

Pays acceptés

Les UDF Python sont compatibles avec tous les emplacements BigQuery multirégionaux et régionaux.

Tarifs

Les UDF Python sont proposées sans frais supplémentaires.

Lorsque la facturation est activée, les conditions suivantes s'appliquent :

Les frais liés aux UDF Python sont facturés à l'aide du SKU BigQuery Services.
Les frais sont proportionnels à la quantité de calcul et de mémoire consommée lorsque l'UDF Python est appelée.
Les clients des UDF Python sont également facturés pour le coût de création ou de recréation de l'image de conteneur UDF. Ces frais sont proportionnels aux ressources utilisées pour créer l'image avec le code et les dépendances du client.
Si les UDF Python entraînent une sortie réseau externe ou Internet, vous verrez également des frais de sortie Internet Premium de Cloud Networking.

Quotas

Consultez la section Quotas et limites des UDF.