Utilizzare le funzioni definite dall'utente in Python

Una funzione definita dall'utente (UDF) Python consente di implementare una funzione scalare in Python e utilizzarla in una query SQL. Le UDF Python sono simili alle UDF SQL e JavaScript, ma con funzionalità aggiuntive. Le UDF Python ti consentono di installare librerie di terze parti da Python Package Index (PyPI) e di accedere a servizi esterni utilizzando una connessione alle risorse cloud.

Le UDF Python vengono create ed eseguite su risorse gestite da BigQuery.

Limitazioni

python-3.11 è l'unico runtime supportato.
Non puoi creare una UDF Python temporanea.
Non puoi utilizzare una UDF Python con una vista materializzata.
I risultati di una query che chiama una funzione definita dall'utente Python non vengono memorizzati nella cache perché si presume sempre che il valore restituito di una funzione definita dall'utente Python non sia deterministico.
Le reti VPC non sono supportate.
Assured Workloads non è supportato.
Questi tipi di dati non sono supportati: JSON, RANGE, INTERVAL e GEOGRAPHY.
I container che eseguono UDF Python possono essere configurati solo fino a 4 vCPU e 16 GiB.
Le chiavi di crittografia gestite dal cliente (CMEK) non sono supportate.

Ruoli obbligatori

I ruoli IAM richiesti dipendono dal fatto che tu sia il proprietario o l'utente di una UDF Python.

Proprietari UDF

In genere, il proprietario di una funzione definita dall'utente Python crea o aggiorna una funzione definita dall'utente. Sono necessari anche ruoli aggiuntivi se crei una UDF Python che fa riferimento a una connessione alle risorse Cloud. Questa connessione è necessaria solo se la tua UDF utilizza la clausola WITH CONNECTION per accedere a un servizio esterno.

Per ottenere le autorizzazioni necessarie per creare o aggiornare una UDF Python, chiedi all'amministratore di concederti i seguenti ruoli IAM:

Editor dati BigQuery (roles/bigquery.dataEditor) sul set di dati
Utente job BigQuery (roles/bigquery.jobUser) sul progetto
BigQuery Connection Admin (roles/bigquery.connectionAdmin) sul progetto

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questi ruoli predefiniti contengono le autorizzazioni necessarie per creare o aggiornare una UDF Python. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare o aggiornare una UDF Python sono necessarie le seguenti autorizzazioni:

Crea una UDF Python utilizzando l'istruzione CREATE FUNCTION: bigquery.routines.create sul set di dati
Aggiorna una funzione definita dall'utente Python utilizzando l'istruzione CREATE FUNCTION: bigquery.routines.update sul set di dati
Esegui un job di query dell'istruzione CREATE FUNCTION: bigquery.jobs.create sul progetto
Crea una nuova connessione risorsa Cloud: bigquery.connections.create sul progetto
Utilizza una connessione nell'istruzione CREATE FUNCTION: bigquery.connections.delegate sulla connessione

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Per saperne di più sui ruoli in BigQuery, vedi Ruoli IAM predefiniti.

utenti UDF

Un utente UDF Python richiama una UDF creata da un altro utente. Sono necessari anche ruoli aggiuntivi se richiami una UDF Python che fa riferimento a una connessione a una risorsa cloud.

Per ottenere le autorizzazioni necessarie per richiamare una UDF Python creata da un altro utente, chiedi all'amministratore di concederti i seguenti ruoli IAM:

Utente BigQuery (roles/bigquery.user) sul progetto
Visualizzatore dati BigQuery (roles/bigquery.dataViewer) sul set di dati
BigQuery Connection User (roles/bigquery.connectionUser) sulla connessione

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questi ruoli predefiniti contengono le autorizzazioni necessarie per richiamare una UDF Python creata da un altro utente. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per richiamare una UDF Python creata da un altro utente sono necessarie le seguenti autorizzazioni:

Per eseguire un job di query che fa riferimento a una UDF Python: bigquery.jobs.create sul progetto
Per richiamare una UDF Python creata da un altro utente: bigquery.routines.get sul set di dati
Per eseguire una funzione definita dall'utente Python che fa riferimento a una connessione alle risorse Cloud: bigquery.connections.use sulla connessione

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Per saperne di più sui ruoli in BigQuery, vedi Ruoli IAM predefiniti.

Richiamare una funzione definita dall'utente Python

Se hai l'autorizzazione per richiamare una funzione definita dall'utente Python, puoi chiamarla come qualsiasi altra funzione. Per utilizzare una funzione definita in un progetto diverso, utilizza il nome completo della funzione. Ad esempio, per chiamare la UDF Python cw_xml_extract definita come UDF della community bigquery-utils, segui questi passaggi:

Console

Vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor di query, inserisci il seguente esempio:

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

Fai clic su Esegui.

Questo esempio produce il seguente output:

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

BigQuery DataFrames

L'esempio seguente utilizza i metodi BigQuery DataFrames sql_scalar, read_gbq_function e apply per chiamare una 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

Crea una funzione definita dall'utente Python permanente

Segui queste regole quando crei una funzione definita dall'utente Python:

Il corpo della UDF Python deve essere un valore letterale stringa tra virgolette che rappresenta il codice Python. Per scoprire di più sui valori letterali stringa tra virgolette, consulta Formati per i valori letterali tra virgolette.
Il corpo della UDF Python deve includere una funzione Python utilizzata nell'argomento entry_point nell'elenco delle opzioni della UDF Python.
È necessario specificare una versione del runtime Python nell'opzione runtime_version. L'unica versione del runtime Python supportata è python-3.11. Per un elenco completo delle opzioni disponibili, consulta l'elenco delle opzioni di funzione per l'istruzione CREATE FUNCTION.

Per creare una UDF Python persistente, utilizza l'istruzione CREATE FUNCTION senza la parola chiave TEMP o TEMPORARY. Per eliminare una UDF Python permanente, utilizza l'istruzione DROP FUNCTION.

Quando crei una funzione definita dall'utente Python utilizzando l'istruzione CREATE FUNCTION, BigQuery crea o aggiorna un'immagine container basata su un'immagine di base. Il container viene creato sull'immagine di base utilizzando il tuo codice e le dipendenze dei pacchetti specificate. La creazione del contenitore è un processo a esecuzione prolungata. La prima query dopo l'esecuzione dell'istruzione CREATE FUNCTION potrebbe attendere automaticamente il completamento dell'immagine. Senza dipendenze esterne, l'immagine container dovrebbe in genere essere creata in meno di un minuto.

Esempio

Per visualizzare un esempio di creazione di una UDF Python persistente, scegli una delle seguenti opzioni:

Console

L'esempio seguente crea una funzione definita dall'utente Python permanente denominata multiplyInputs e la chiama da un'istruzione SELECT:

Vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor di query, inserisci la seguente istruzione CREATE FUNCTION:

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;

Sostituisci PROJECT_ID.DATASET_ID con l'ID progetto e l'ID set di dati.

Fai clic su Esegui.

Questo esempio produce il seguente output:

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

BigQuery DataFrames

L'esempio seguente utilizza BigQuery DataFrames per trasformare una funzione personalizzata in una 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}")

Crea una funzione definita dall'utente Python vettorizzata

Puoi implementare la tua funzione definita dall'utente Python per elaborare un batch di righe anziché una singola riga utilizzando la vettorizzazione. La vettorizzazione può migliorare le prestazioni delle query. Puoi creare una funzione definita dall'utente vettorizzata utilizzando Pandas o Apache Arrow.

Per controllare il comportamento del batch, specifica il numero massimo di righe in ogni batch utilizzando l'opzione max_batching_rows nell'elenco di opzioni CREATE OR REPLACE FUNCTION. Se specifichi max_batching_rows, BigQuery determina il numero di righe in un batch, fino al limite di max_batching_rows. Se max_batching_rows non è specificato, il numero di righe da raggruppare viene determinato automaticamente.

Utilizzare Pandas

Una UDF Python vettorizzata ha un singolo argomento pandas.DataFrame che deve essere annotato. L'argomento pandas.DataFrame ha lo stesso numero di colonne dei parametri UDF Python definiti nell'istruzione CREATE FUNCTION. I nomi delle colonne nell'argomento pandas.DataFrame hanno gli stessi nomi dei parametri della funzione definita dall'utente.

La funzione deve restituire un pandas.Series o un pandas.DataFrame a una sola colonna con lo stesso numero di righe dell'input.

Il seguente esempio crea una funzione definita dall'utente Python vettorizzata denominata multiplyInputs con due parametri: x e y:

Vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor di query, inserisci la seguente istruzione CREATE FUNCTION:

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

''';

Sostituisci PROJECT_ID.DATASET_ID con l'ID progetto e l'ID set di dati.

La chiamata alla UDF è la stessa dell'esempio precedente.

Fai clic su Esegui.

Utilizzare Apache Arrow

L'esempio seguente utilizza l'interfaccia RecordBatch Apache Arrow. Quando utilizzi l'interfaccia RecordBatch, la funzione passa un batch di righe di colonne di uguale lunghezza al punto di ingresso. L'esempio seguente utilizza Apache Arrow per creare una funzione definita dall'utente Python vettorizzata denominata multiplyVectorizedArrow.

Vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor di query, inserisci la seguente istruzione CREATE FUNCTION:

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

Sostituisci PROJECT_ID.DATASET_ID con l'ID progetto e l'ID set di dati.

La chiamata alla UDF è la stessa degli esempi precedenti.

Fai clic su Esegui.

Tipi di dati UDF Python supportati

La seguente tabella definisce il mapping tra i tipi di dati BigQuery, i tipi di dati Python e i tipi di dati Pandas:

Tipo di dati BigQuery	Tipo di dati integrato di Python utilizzato dalla funzione definita dall'utente standard	Tipo di dati Pandas utilizzato dalla funzione definita dall'utente vettorizzata	Tipo di dati PyArrow utilizzato per ARRAY e STRUCT nella UDF vettorizzata
`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`	Parametro della funzione: `datetime.datetime` (con fuso orario UTC impostato) Valore restituito dalla funzione: `datetime.datetime` (con qualsiasi fuso orario impostato)	Parametro della funzione: `timestamp[us, tz=UTC][pyarrow]` Valore restituito dalla funzione: `timestamp[us, tz=*][pyarrow]\(any timezone\)`	`TimestampType(timestamp[us])`, con fuso orario
`DATE`	`datetime.date`	`date32[pyarrow]`	`DataType(date32[day])`
`TIME`	`datetime.time`	`time64[pyarrow]`	`Time64Type(time64[us])`
`DATETIME`	`datetime.datetime` (senza fuso orario)	`timestamp[us][pyarrow]`	`TimestampType(timestamp[us])`, senza fuso orario
`ARRAY`	`list`	`list<...>[pyarrow]`, dove il tipo di dati dell'elemento è `pandas.ArrowDtype`	`ListType`
`STRUCT`	`dict`	`struct<...>[pyarrow]`, dove il tipo di dati del campo è `pandas.ArrowDtype`	`StructType`

Versioni di runtime supportate

Le UDF Python di BigQuery supportano il runtime python-3.11. Questa versione di Python include alcuni pacchetti preinstallati aggiuntivi. Per le librerie di sistema, controlla l'immagine di base del runtime.

Versione runtime	Versione Python	Include
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

Utilizzare pacchetti di terze parti

Puoi utilizzare l'elenco di opzioni CREATE FUNCTION per utilizzare moduli diversi da quelli forniti dalla libreria standard Python e dai pacchetti preinstallati. Puoi installare pacchetti da Python Package Index (PyPI) oppure importare file Python da Cloud Storage.

Installa un pacchetto dal Python Package Index

Quando installi un pacchetto, devi fornire il nome del pacchetto e, facoltativamente, puoi fornire la versione del pacchetto utilizzando gli specificatori di versione del pacchetto Python.

Se il pacchetto è nel runtime, viene utilizzato a meno che non venga specificata una versione particolare nell'elenco delle opzioni CREATE FUNCTION. Se non viene specificata una versione del pacchetto e il pacchetto non è nel runtime, viene utilizzata l'ultima versione disponibile. Sono supportati solo i pacchetti con il formato binario delle ruote.

L'esempio seguente mostra come creare una UDF Python che installa il pacchetto scipy utilizzando l'elenco di opzioni CREATE OR REPLACE FUNCTION:

Vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor di query, inserisci la seguente istruzione CREATE FUNCTION:

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

Sostituisci PROJECT_ID.DATASET_ID con l'ID progetto e l'ID set di dati.

Fai clic su Esegui.

Importa file Python aggiuntivi come librerie

Puoi estendere le tue UDF Python utilizzando l'elenco delle opzioni di funzione importando file Python da Cloud Storage.

Nel codice Python della UDF, puoi importare i file Python da Cloud Storage come moduli utilizzando l'istruzione import seguita dal percorso dell'oggetto Cloud Storage. Ad esempio, se importi gs://BUCKET_NAME/path/to/lib1.py, l'istruzione di importazione sarà import path.to.lib1.

Il nome file Python deve essere un identificatore Python. Ogni nome folder nel nome dell'oggetto (dopo /) deve essere un identificatore Python valido. All'interno dell'intervallo ASCII (U+0001..U+007F), è possibile utilizzare i seguenti caratteri negli identificatori:

Lettere maiuscole e minuscole dalla A alla Z.
Trattini bassi.
Le cifre da zero a nove, ma un numero non può essere il primo carattere dell'identificatore.

L'esempio seguente mostra come creare una UDF Python che importa il pacchetto della libreria client lib1.py da un bucket Cloud Storage denominato my_bucket:

Vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor di query, inserisci la seguente istruzione CREATE FUNCTION:

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

""";

Sostituisci PROJECT_ID.DATASET_ID con l'ID progetto e l'ID set di dati.

Fai clic su Esegui.

Configura i limiti dei container per le UDF Python

Puoi utilizzare l'elenco delle opzioni CREATE FUNCTION per specificare i limiti di concorrenza delle richieste di CPU, memoria e container per i container che eseguono UDF Python.

Per impostazione predefinita, ai container vengono allocate le seguenti risorse:

La memoria allocata è 512Mi.
La CPU allocata è 1.0 vCPU.
Il limite di concorrenza delle richieste del container è 80.

L'esempio seguente crea una UDF Python utilizzando l'elenco di opzioni CREATE FUNCTION per specificare i limiti del container:

Vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor di query, inserisci la seguente istruzione CREATE FUNCTION:

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

Sostituisci quanto segue:

PROJECT_ID.DATASET_ID: il tuo ID progetto e il tuo ID set di dati.
CONTAINER_MEMORY: il valore della memoria nel seguente formato: <integer_number><unit>. L'unità deve essere uno di questi valori: Mi (MiB), M (MB), Gi (GiB) o G (GB). Ad esempio, 2Gi.
CONTAINER_CPU: il valore della CPU. Le UDF Python supportano valori di CPU frazionari compresi tra 0.33 e 1.0 e valori di CPU non frazionari pari a 1, 2 e 4.
CONTAINER_REQUEST_CONCURRENCY: il numero massimo di richieste simultanee per istanza container UDF Python. Il valore deve essere un numero intero compreso tra 1 e 1000.

Fai clic su Esegui.

Valori della CPU supportati

Le UDF Python supportano valori di CPU frazionari compresi tra 0.33 e 1.0 e valori di CPU non frazionari di 1, 2 e 4. I container che eseguono UDF Python possono essere configurati fino a 4 vCPU. Il valore predefinito è 1.0. I valori di input frazionari vengono arrotondati a due cifre decimali prima di essere applicati al contenitore.

Valori di memoria supportati

I contenitori UDF Python supportano i valori di memoria nel seguente formato: <integer_number><unit>. L'unità deve essere uno di questi valori: Mi, M, Gi, G. La quantità minima di memoria che puoi configurare è 256Mi. La quantità massima di memoria che puoi configurare è 16Gi.

In base al valore di memoria che scegli, devi specificare anche una quantità di CPU appropriata. La tabella seguente mostra i valori minimi e massimi della CPU per ogni valore di memoria:

Memoria	CPU minima	CPU massima
Da `256Mi` a `512Mi`	`0.33`	`2`
Maggiore di `512Mi` e minore o uguale a `1Gi`	`0.5`	`2`
Maggiore di `1Gi` e inferiore a `2Gi`	`1`	`2`
Da `2Gi` a `4Gi`	`1`	`4`
Maggiore di `4Gi` e fino a `8Gi`	`2`	`4`
Maggiore di `8Gi` e fino a `16Gi`	`4`	`4`

In alternativa, se hai determinato la quantità di CPU da allocare, puoi utilizzare la tabella seguente per determinare l'intervallo di memoria appropriato:

CPU	Memoria minima	Memoria massima
Meno di `0.5`	`256Mi`	`512Mi`
`0.5` a meno di `1`	`256Mi`	`1Gi`
`1`	`256Mi`	`4Gi`
`2`	`256Mi`	`8Gi`
`4`	`2Gi`	`16Gi`

Chiama Google Cloud o servizi online nel codice Python

Una UDF Python accede a un Google Cloud servizio o a un servizio esterno utilizzando il account di servizio della connessione alle risorse cloud. Al account di servizio della connessione devono essere concesse le autorizzazioni per accedere al servizio. Le autorizzazioni richieste variano a seconda del servizio a cui si accede e delle API chiamate dal codice Python.

Se crei una funzione definita dall'utente Python senza utilizzare una connessione alle risorse Cloud, la funzione viene eseguita in un ambiente che blocca l'accesso alla rete. Se la tua UDF accede a servizi online, devi creare la UDF con una connessione a una risorsa cloud. In caso contrario, l'UDF non potrà accedere alla rete finché non viene raggiunto un timeout della connessione interna.

L'esempio seguente mostra come accedere al servizio Cloud Translation da una UDF Python. Questo esempio ha due progetti: un progetto denominato my_query_project in cui crei la UDF e la connessione alla risorsa cloud e un progetto in cui esegui Cloud Translation denominato my_translate_project.

Crea una connessione alle risorse Cloud

Innanzitutto, crea una connessione alle risorse Cloud in my_query_project. Per creare la connessione alla risorsa cloud, segui questi passaggi.

Seleziona una delle seguenti opzioni:

Console

Vai alla pagina BigQuery.

Vai a BigQuery
Nel riquadro a sinistra, fai clic su Explorer:

Se non vedi il riquadro a sinistra, fai clic su Espandi riquadro a sinistra per aprirlo.
Nel riquadro Explorer, espandi il nome del progetto e fai clic su Connessioni.
Nella pagina Connessioni, fai clic su Crea connessione.
Per Tipo di connessione, scegli Modelli remoti di Vertex AI, funzioni remote, BigLake e Spanner (risorsa Cloud).
Nel campo ID connessione, inserisci un nome per la connessione.
Per Tipo di località, seleziona una località per la connessione. La connessione deve essere collocata insieme alle altre risorse, ad esempio i set di dati.
Fai clic su Crea connessione.
Fai clic su Vai alla connessione.
Nel riquadro Informazioni sulla connessione, copia l'ID dell'account di servizio da utilizzare in un passaggio successivo.

SQL

Utilizza l'istruzione CREATE CONNECTION:

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery
Nell'editor di query, inserisci la seguente istruzione:
```
CREATE CONNECTION [IF NOT EXISTS] `CONNECTION_NAME`
OPTIONS (
  connection_type = "CLOUD_RESOURCE",
  friendly_name = "FRIENDLY_NAME",
  description = "DESCRIPTION"
  );
```
Sostituisci quanto segue:
- CONNECTION_NAME: il nome della connessione nel formato PROJECT_ID.LOCATION.CONNECTION_ID, LOCATION.CONNECTION_ID o CONNECTION_ID. Se il progetto o la località vengono omessi, vengono dedotti dal progetto e dalla località in cui viene eseguita l'istruzione.
- FRIENDLY_NAME (facoltativo): un nome descrittivo per la connessione.
- DESCRIPTION (facoltativo): una descrizione della connessione.
Fai clic su Esegui.

Per saperne di più su come eseguire le query, consulta Eseguire una query interattiva.

bq

In un ambiente a riga di comando, crea una connessione:
```
bq mk --connection --location=REGION --project_id=PROJECT_ID \
    --connection_type=CLOUD_RESOURCE CONNECTION_ID
```
Il parametro --project_id sostituisce il progetto predefinito.

Sostituisci quanto segue:
- REGION: la tua regione di connessione
- PROJECT_ID: il tuo Google Cloud ID progetto
- CONNECTION_ID: un ID per la connessione
Quando crei una risorsa di connessione, BigQuery crea un account di servizio di sistema univoco e lo associa alla connessione.

Risoluzione dei problemi: se viene visualizzato il seguente errore di connessione, aggiorna Google Cloud SDK:
```
Flags parsing error: flag --connection_type=CLOUD_RESOURCE: value should be one of...
```

Recupera e copia l'ID dell'account di servizio da utilizzare in un passaggio successivo:

bq show --connection PROJECT_ID.REGION.CONNECTION_ID

L'output è simile al seguente:

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

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Utilizza la risorsa google_bigquery_connection.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

L'esempio seguente crea una connessione alle risorse Cloud denominata my_cloud_resource_connection nella regione 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 {}
}

Per applicare la configurazione Terraform in un progetto Google Cloud , completa i passaggi nelle sezioni seguenti.

Prepara Cloud Shell

Avvia Cloud Shell.
Imposta il progetto Google Cloud predefinito in cui vuoi applicare le configurazioni Terraform.

Devi eseguire questo comando una sola volta per progetto e puoi eseguirlo in qualsiasi directory.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Le variabili di ambiente vengono sostituite se imposti valori espliciti nel file di configurazione Terraform.

Prepara la directory

Ogni file di configurazione Terraform deve avere la propria directory (chiamata anche modulo radice).

In Cloud Shell, crea una directory e un nuovo file al suo interno. Il nome file deve avere l'estensione .tf, ad esempio main.tf. In questo tutorial, il file è denominato main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
Se stai seguendo un tutorial, puoi copiare il codice campione in ogni sezione o passaggio.

Copia il codice campione nel main.tf appena creato.

(Facoltativo) Copia il codice da GitHub. Questa operazione è consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.
Rivedi e modifica i parametri di esempio da applicare al tuo ambiente.
Salva le modifiche.
Inizializza Terraform. Devi eseguire questa operazione una sola volta per directory.
```
terraform init
```
(Facoltativo) Per utilizzare l'ultima versione del provider Google, includi l'opzione -upgrade:
```
terraform init -upgrade
```

Applica le modifiche

Rivedi la configurazione e verifica che le risorse che Terraform creerà o aggiornerà corrispondano alle tue aspettative:
```
terraform plan
```
Apporta le correzioni necessarie alla configurazione.
Applica la configurazione Terraform eseguendo questo comando e inserendo yes al prompt:
```
terraform apply
```
Attendi che Terraform visualizzi il messaggio "Apply complete!".
Apri il tuo Google Cloud progetto per visualizzare i risultati. Nella console Google Cloud , vai alle risorse nell'interfaccia utente per assicurarti che Terraform le abbia create o aggiornate.

Concedi l'accesso al account di servizio della connessione

Quando configuri le autorizzazioni per la connessione, ti serve l'ID account di servizio che hai copiato in precedenza. Quando crei una risorsa di connessione, BigQuery crea un account di servizio di sistema univoco e lo associa alla connessione.

Per concedere al account di servizio connessione alle risorse Cloud l'accesso ai tuoi progetti, concedi al account di servizio il ruolo Utente servizio di utilizzo (roles/serviceusage.serviceUsageConsumer) in my_query_project e il ruolo Utente API Cloud Translation (roles/cloudtranslate.user) in my_translate_project.

Vai alla pagina IAM.

Vai a IAM
Verifica che my_query_project sia selezionato.
Fai clic su Concedi l'accesso.
Nel campo Nuove entità, inserisci l'ID account di servizio della connessione alle risorse Cloud che hai copiato in precedenza.
Nel campo Seleziona un ruolo, scegli Utilizzo del servizio, quindi seleziona Consumer utilizzo del servizio.
Fai clic su Salva.
Nel selettore dei progetti, scegli my_translate_project.
Vai alla pagina IAM.

Vai a IAM
Fai clic su Concedi l'accesso.
Nel campo Nuove entità, inserisci l'ID account di servizio della connessione alle risorse Cloud che hai copiato in precedenza.
Nel campo Seleziona un ruolo, scegli Cloud Translation e poi seleziona Utente API Cloud Translation.
Fai clic su Salva.

Crea una UDF Python che chiama il servizio Cloud Translation

In my_query_project, crea una UDF Python che chiami il servizio Cloud Translation utilizzando la connessione alla risorsa cloud.

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery

Inserisci la seguente istruzione CREATE FUNCTION nell'editor di query:

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;

Sostituisci quanto segue:

PROJECT_ID.DATASET_ID: il tuo ID progetto e l'ID set di dati
REGION.CONNECTION_ID: la regione e l'ID della connessione

Fai clic su Esegui.

L'output dovrebbe essere simile al seguente:

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

Best practice

Quando crei UDF Python, segui queste best practice:

Ottimizza la logica delle query per il batching. Strutture di query complesse possono disattivare il batching. Ciò forza l'elaborazione lenta riga per riga, il che aumenta significativamente la latenza su set di dati di grandi dimensioni.
Evita le UDF nelle espressioni condizionali.
Evita di utilizzare le UDF per incorporare direttamente i campi STRUCT.
Isola le UDF nelle proiezioni. Per garantire il batching, esegui la UDF in un'istruzione SELECT utilizzando un'espressione di tabella comune (CTE) o una sottoquery. Quindi, esegui filtri o unioni su quel risultato in un passaggio separato.
Ottimizza il payload di dati. Le dimensioni delle singole righe possono influire sull'efficienza della funzionalità di batch.
Riduci al minimo le dimensioni della riga. Mantieni ogni riga il più piccola possibile per massimizzare il numero di righe che possono essere elaborate in un singolo batch.
Configura i limiti dei container in modo efficiente. La scalabilità è una funzione di CPU, memoria e concorrenza delle richieste.
Quando utilizzi l'ottimizzazione iterativa, inizia con i valori predefiniti. Se le prestazioni non sono ottimali, analizza le metriche di monitoraggio per identificare colli di bottiglia specifici.
Scalare le risorse. Se le metriche di monitoraggio mostrano livelli di utilizzo elevati, aumenta la CPU e la memoria allocate.
Gestisci le dipendenze esterne e l'affidabilità. Le UDF che interagiscono con servizi esterni richiedono una connessione e autorizzazioni appropriate.
Implementa i timeout delle API. Quando la tua UDF Python accede a internet, imposta un timeout per la chiamata API per evitare comportamenti imprevisti. Un esempio di accesso a internet è la lettura da un bucket Cloud Storage.

Visualizza le metriche delle UDF Python

Le UDF Python esportano le metriche in Cloud Monitoring. Queste metriche ti aiutano a monitorare vari aspetti dell'integrità operativa e del consumo di risorse della tua UDF, fornendo approfondimenti sul rendimento e sul comportamento delle istanze UDF.

Tipo di risorsa di monitoraggio

Le metriche per le UDF Python vengono riportate nel seguente tipo di risorsa Cloud Monitoring:

Tipo: bigquery.googleapis.com/ManagedRoutineInvocation
Nome visualizzato: Chiamata della routine gestita BigQuery
Etichette:
- resource_container: l'ID del progetto in cui è stato eseguito il job di query.
- location: la località in cui è stato eseguito il job di query.
- query_job_id: l'ID del job di query che ha richiamato la UDF Python.
- routine_project_id: l'ID progetto in cui è archiviata la routine richiamata.
- routine_dataset_id: l'ID del set di dati in cui è archiviata la routine richiamata.
- routine_id: l'ID della routine richiamata.

Metriche

Per il tipo di risorsa bigquery.googleapis.com/ManagedRoutineInvocation sono disponibili le seguenti metriche:

Metrica	Descrizione	Unità	Tipo di valore
`bigquery.googleapis.com/managed_routine/python/cpu_utilizations`	Quando viene richiamata una UDF Python, questa metrica mostra la distribuzione dell'utilizzo della CPU in tutte le istanze UDF Python per il job di query.	10².%	`DISTRIBUTION`
`bigquery.googleapis.com/managed_routine/python/memory_utilizations`	Quando viene richiamata una UDF Python, questa metrica mostra la distribuzione dell'utilizzo della memoria in tutte le istanze UDF Python per il job di query.	10².%	`DISTRIBUTION`
`bigquery.googleapis.com/managed_routine/python/max_request_concurrencies`	Questa metrica mostra la distribuzione del numero massimo di richieste in parallelo pubblicate da ogni istanza di funzione definita dall'utente Python.	Conteggio	`DISTRIBUTION`

Visualizza metriche

Per visualizzare le metriche per le UDF Python, scegli una delle opzioni nelle sezioni seguenti.

Dettagli job

Per visualizzare le metriche delle UDF Python per un job di query specifico:

Vai alla pagina BigQuery.

Vai a BigQuery
Fai clic su Cronologia dei job.
Nella colonna ID job, fai clic sull'ID job della query.
Nella pagina Dettagli job di query, fai clic su Dashboard Cloud Monitoring. Questo link mostra una dashboard filtrata per visualizzare le metriche UDF Python per il job.

Esplora metriche

Per visualizzare le metriche delle UDF Python in Metrics Explorer, segui questi passaggi:

Vai alla pagina Esplora metriche di Cloud Monitoring.

Vai a Esplora metriche
Fai clic su Seleziona una metrica e, nel campo Filtro, digita BigQuery Managed Routine Invocation o bigquery.googleapis.com/ManagedRoutineInvocation.
Scegli Bigquery Managed Routine > Managed_routine.
Fai clic su una delle metriche disponibili, ad esempio:
- Utilizzo CPU istanza
- Utilizzo della memoria dell'istanza
- Numero max richieste in parallelo
Fai clic su Applica.

Per impostazione predefinita, le metriche vengono visualizzate in un grafico.
Puoi filtrare e raggruppare le metriche utilizzando le etichette definite in Tipi di risorse di monitoraggio. Per filtrare le metriche, segui questi passaggi:
1. Nel campo Filtro, scegli un tipo di risorsa come query_job_id o routine_id.
2. Nel campo Valore, inserisci l'ID job o l'ID routine oppure scegli un valore dall'elenco.

Dashboard di Cloud Monitoring

Per visualizzare le metriche delle UDF Python utilizzando le dashboard di monitoraggio, segui questi passaggi:

Vai alla pagina Dashboard di Cloud Monitoring.

Vai a Dashboard
Fai clic sulla dashboard Monitoraggio query della routine gestita BigQuery.

Questa dashboard fornisce una panoramica delle metriche chiave delle tue funzioni definite dall'utente.
Per filtrare questa dashboard:
1. Fai clic su Filtra.
2. Nell'elenco Filtra per risorsa, scegli un'opzione come ID progetto, posizione, ID routine o ID job.

Località supportate

Le UDF Python sono supportate in tutte le località regionali e multiregionali di BigQuery.

Prezzi

Le UDF Python sono offerte senza costi aggiuntivi.

Quando la fatturazione è abilitata, si applicano le seguenti condizioni:

I costi delle UDF Python vengono fatturati utilizzando lo SKU dei servizi BigQuery.
Gli addebiti sono proporzionali alla quantità di calcolo e memoria consumati quando viene richiamata la UDF Python.
Ai clienti delle funzioni definite dall'utente Python vengono addebitati anche i costi di creazione o ricreazione dell'immagine container della funzione definita dall'utente. Questo addebito è proporzionale alle risorse utilizzate per creare l'immagine con il codice e le dipendenze del cliente.
Se le UDF Python generano traffico in uscita dalla rete esterna o da internet, viene visualizzato anche un addebito per il traffico in uscita da internet del livello Premium da Cloud Networking.

Quote

Consulta Quote e limiti delle UDF.