Guida per sviluppatori Python per Funzioni di Azure

Funzioni di Azure si aspetta che una funzione sia un metodo senza stato nello script di Python che elabora l'input e genera l'output. Per impostazione predefinita, il runtime si aspetta che il metodo venga implementato come metodo globale denominato main() nel file __init__.py. È anche possibile specificare un punto di ingresso alternativo.

I dati vengono associati alla funzione da trigger e associazioni tramite attributi del metodo che usano la proprietà name definita nel file function.json. Ad esempio, il file function.json seguente descrive una funzione semplice attivata da una richiesta HTTP denominata req:

{
    "scriptFile": "__init__.py",
    "bindings": [
        {
            "authLevel": "function",
            "type": "httpTrigger",
            "direction": "in",
            "name": "req",
            "methods": [
                "get",
                "post"
            ]
        },
        {
            "type": "http",
            "direction": "out",
            "name": "$return"
        }
    ]
}

In base a questa definizione, il file __init__.py che contiene il codice della funzione potrebbe essere simile all'esempio seguente:

def main(req):
    user = req.params.get('user')
    return f'Hello, {user}!'

È anche possibile dichiarare esplicitamente i tipi di attributi e il tipo restituito nella funzione usando le annotazioni di tipo di Python. In questo modo è possibile usare le funzionalità di IntelliSense e di completamento automatico fornite da molti editor di codice Python.

import azure.functions

def main(req: azure.functions.HttpRequest) -> str:
    user = req.params.get('user')
    return f'Hello, {user}!'

Usare le annotazioni Python incluse nel pacchetto azure.functions.* per associare input e output ai metodi dell'utente.

Funzioni di Azure si aspetta che una funzione sia un metodo senza stato nello script di Python che elabora l'input e genera l'output. Per impostazione predefinita, il runtime si aspetta che il metodo venga implementato come metodo globale nel file function_app.py.

I trigger e le associazioni possono essere dichiarati e usati in una funzione in un approccio basato su Decorator. Sono definiti nello stesso file function_app.py delle funzioni. Ad esempio, il file function_app.py seguente rappresenta un trigger di funzione da una richiesta HTTP.

@app.function_name(name="HttpTrigger1")
@app.route(route="req")
def main(req):
    user = req.params.get("user")
    return f"Hello, {user}!"

È anche possibile dichiarare esplicitamente i tipi di attributi e il tipo restituito nella funzione usando le annotazioni di tipo di Python. In questo modo è possibile usare le funzionalità di IntelliSense e di completamento automatico fornite da molti editor di codice Python.

import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="req")
def main(req: func.HttpRequest) -> str:
    user = req.params.get("user")
    return f"Hello, {user}!"

Per informazioni sulle limitazioni note con il modello v2 e le relative soluzioni alternative, vedere Risolvere gli errori Python in Funzioni di Azure.

È possibile cambiare il comportamento predefinito di una funzione specificando facoltativamente le proprietà scriptFile e entryPoint nel file function.json. Ad esempio, il file function.json seguente indica al runtime di usare il metodo customentry() nel file main.py come punto di ingresso per la funzione di Azure.

{
  "scriptFile": "main.py",
  "entryPoint": "customentry",
  "bindings": [
      ...
  ]
}

Il punto di ingresso si trova solo nel file function_app.py. Tuttavia, è possibile fare riferimento a funzioni all'interno del progetto in function_app.py usando progetti o importando.

La struttura di cartelle per consigliata per un progetto di Funzioni per Python è simile all'esempio seguente:

 <project_root>/
 | - .venv/
 | - .vscode/
 | - my_first_function/
 | | - __init__.py
 | | - function.json
 | | - example.py
 | - my_second_function/
 | | - __init__.py
 | | - function.json
 | - shared_code/
 | | - __init__.py
 | | - my_first_helper_function.py
 | | - my_second_helper_function.py
 | - tests/
 | | - test_my_second_function.py
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - requirements.txt
 | - Dockerfile

La cartella principale del progetto, <project_root>, può contenere i file seguenti:

• local.settings.json: viene usato per archiviare le impostazioni dell'app e le stringhe di connessione durante l'esecuzione in locale. Questo file non viene pubblicato in Azure. Per altre informazioni, vedere local.settings.file.
• requirements.txt: contiene l'elenco dei pacchetti Python installati dal sistema durante la pubblicazione in Azure.
• host.json: contiene opzioni di configurazione che influiscono su tutte le funzioni in un'istanza dell'app per le funzioni. Questo file viene pubblicato in Azure. Non tutte le opzioni sono supportate durante l'esecuzione in locale. Per altre informazioni, vedere host.json.
• .vscode/: (facoltativo) contiene la configurazione di Visual Studio Code archiviata. Per altre informazioni, vedere Impostazioni di Visual Studio Code.
• .venv/: (facoltativo) contiene un ambiente virtuale Python usato dallo sviluppo locale.
• Dockerfile: (facoltativo) viene usato per la pubblicazione del progetto in un contenitore personalizzato.
• tests/: (facoltativo) contiene i test case dell'app per le funzioni.
• .funcignore: (facoltativo) dichiara i file che non devono essere pubblicati in Azure. In genere, questo file contiene .vscode/ per ignorare l'impostazione dell'editor, .venv/ per ignorare l'ambiente virtuale Python, tests/ per ignorare i test case e local.settings.json per impedire la pubblicazione delle impostazioni dell'app locale.

Ogni funzione ha il proprio file di codice e il file di configurazione delle associazioni, function.json.

La struttura di cartelle per consigliata per un progetto di Funzioni per Python è simile all'esempio seguente:

 <project_root>/
 | - .venv/
 | - .vscode/
 | - function_app.py
 | - additional_functions.py
 | - tests/
 | | - test_my_function.py
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - requirements.txt
 | - Dockerfile

La cartella principale del progetto, <project_root>, può contenere i file seguenti:

• .venv/: (facoltativo) contiene un ambiente virtuale Python usato dallo sviluppo locale.
• .vscode/: (facoltativo) contiene la configurazione di Visual Studio Code archiviata. Per altre informazioni, vedere Impostazioni di Visual Studio Code.
• function_app.py: percorso predefinito per tutte le funzioni e i relativi trigger e associazioni correlati.
• additional_functions.py: (facoltativo) qualsiasi altro file Python che contiene funzioni (in genere per il raggruppamento logico) a cui viene fatto riferimento in function_app.py tramite progetti.
• tests/: (facoltativo) contiene i test case dell'app per le funzioni.
• .funcignore: (facoltativo) dichiara i file che non devono essere pubblicati in Azure. In genere, questo file contiene .vscode/ per ignorare l'impostazione dell'editor, .venv/ per ignorare l'ambiente virtuale Python, tests/ per ignorare i test case e local.settings.json per impedire la pubblicazione delle impostazioni dell'app locale.
• host.json: contiene opzioni di configurazione che influiscono su tutte le funzioni in un'istanza dell'app per le funzioni. Questo file viene pubblicato in Azure. Non tutte le opzioni sono supportate durante l'esecuzione in locale. Per altre informazioni, vedere host.json.
• local.settings.json: usato per archiviare le impostazioni dell'app e le stringhe di connessione quando viene eseguito in locale. Questo file non viene pubblicato in Azure. Per altre informazioni, vedere local.settings.file.
• requirements.txt: contiene l'elenco dei pacchetti Python installati dal sistema durante la pubblicazione in Azure.
• Dockerfile: (facoltativo) viene usato per la pubblicazione del progetto in un contenitore personalizzato.

Blueprints

Il modello di programmazione Python v2 introduce il concetto di progetti. Un progetto è una nuova classe di cui viene creata un'istanza per registrare funzioni all'esterno dell'applicazione di funzione principale. Le funzioni registrate nelle istanze del progetto non vengono indicizzate direttamente dal runtime della funzione. Per ottenere l'indicizzazione di queste funzioni di progetto, l'app per le funzioni deve registrare le funzioni dalle istanze del progetto.

L'uso dei progetti offre i vantaggi seguenti:

• Consente di suddividere l'app per le funzioni in componenti modulari, al fine di definire funzioni in più file Python e di dividerle in componenti diversi per ogni file.
• Fornisce interfacce estendibili di app per le funzioni pubbliche per compilare e riutilizzare le proprie API.

L'esempio seguente illustra come usare i progetti:

Prima di tutto, in un file http_blueprint.py viene definita una funzione attivata tramite HTTP e aggiunta a un oggetto progetto.

import logging 

import azure.functions as func 

bp = func.Blueprint() 

@bp.route(route="default_template") 
def default_template(req: func.HttpRequest) -> func.HttpResponse: 
    logging.info('Python HTTP trigger function processed a request.') 

    name = req.params.get('name') 
    if not name: 
        try: 
            req_body = req.get_json() 
        except ValueError: 
            pass 
        else: 
            name = req_body.get('name') 

    if name: 
        return func.HttpResponse( 
            f"Hello, {name}. This HTTP-triggered function " 
            f"executed successfully.") 
    else: 
        return func.HttpResponse( 
            "This HTTP-triggered function executed successfully. " 
            "Pass a name in the query string or in the request body for a" 
            " personalized response.", 
            status_code=200 
        ) 

Quindi, nel file function_app.py l'oggetto progetto viene importato e le relative funzioni vengono registrate nell'app per le funzioni.

import azure.functions as func 
from http_blueprint import bp

app = func.FunctionApp() 

app.register_functions(bp) 

Importare il comportamento

È possibile importare moduli nel codice della funzione usando riferimenti assoluti e relativi. In base alla struttura di cartelle descritta in precedenza, le importazioni seguenti funzionano dall'interno del file di funzione <project_root>\my_first_function\__init__.py:

from shared_code import my_first_helper_function #(absolute)

import shared_code.my_second_helper_function #(absolute)

from . import example #(relative)

L'importazione dell'__app__ seguente e degli elementi al di là del livello generale relativo è deprecata perché non è supportata dal correttore dei tipi statici e dai framework di test Python:

from __app__.shared_code import my_first_helper_function #(deprecated __app__ import)

from ..shared_code import my_first_helper_function #(deprecated beyond top-level relative import)

In Funzioni di Azure, gli input vengono suddivisi in due categorie, ovvero l'input del trigger e un altro input. Anche se sono diversi nel file function.json, l'utilizzo è identico nel codice Python. Le stringhe di connessione o i segreti per le origini di trigger e input vengono mappati ai valori del file local.settings.json durante l'esecuzione in locale e alle impostazioni dell'applicazione durante l'esecuzione in Azure.

Ad esempio, il codice seguente dimostra la differenza tra i due input:

// function.json
{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "authLevel": "anonymous",
      "route": "items/{id}"
    },
    {
      "name": "obj",
      "direction": "in",
      "type": "blob",
      "path": "samples/{id}",
      "connection": "STORAGE_CONNECTION_STRING"
    }
  ]
}

// local.settings.json
{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "STORAGE_CONNECTION_STRING": "<AZURE_STORAGE_CONNECTION_STRING>",
    "AzureWebJobsStorage": "<azure-storage-connection-string>"
  }
}

# __init__.py
import azure.functions as func
import logging

def main(req: func.HttpRequest, obj: func.InputStream):
    logging.info(f'Python HTTP-triggered function processed: {obj.read()}')

Quando viene richiamata questa funzione, la richiesta HTTP viene passata alla funzione come req. Verrà recuperata una voce dall'account Archiviazione BLOB di Azure in base all'ID nell'URL di route e verrà resa disponibile come obj nel corpo della funzione. In questo caso, l'account di archiviazione specificato è la stringa di connessione presente nell'impostazione dell'app CONNECTION_STRING.

In Funzioni di Azure, gli input vengono suddivisi in due categorie, ovvero l'input del trigger e un altro input. Anche se sono definiti usando elementi Decorator diversi, l'utilizzo è simile nel codice Python. Le stringhe di connessione o i segreti per le origini di trigger e input vengono mappati ai valori del file local.settings.json durante l'esecuzione in locale e alle impostazioni dell'applicazione durante l'esecuzione in Azure.

Ad esempio, il codice seguente illustra come definire un'associazione di input di archiviazione BLOB:

// local.settings.json
{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "STORAGE_CONNECTION_STRING": "<AZURE_STORAGE_CONNECTION_STRING>",
    "AzureWebJobsStorage": "<azure-storage-connection-string>"
  }
}

# function_app.py
import azure.functions as func
import logging

app = func.FunctionApp()

@app.route(route="req")
@app.read_blob(arg_name="obj", path="samples/{id}", 
               connection="STORAGE_CONNECTION_STRING")
def main(req: func.HttpRequest, obj: func.InputStream):
    logging.info(f'Python HTTP-triggered function processed: {obj.read()}')

Quando viene richiamata questa funzione, la richiesta HTTP viene passata alla funzione come req. Verrà recuperata una voce dall'account Archiviazione BLOB di Azure in base all'ID nell'URL di route e verrà resa disponibile come obj nel corpo della funzione. In questo caso, l'account di archiviazione specificato è la stringa di connessione presente nell'impostazione dell'app STORAGE_CONNECTION_STRING.

Funzioni supporta le associazioni di tipi di Python SDK per l'Archiviazione BLOB di Azure, che consente di usare i dati BLOB tramite il tipo BlobClient sottostante.

Prerequisiti

• Runtime di Funzioni di Azure versione 4.34 o successiva.
• Python versione 3.9 o una successiva versione supportata.

Abilitare le associazioni dei tipi di SDK per l'estensione di archiviazione BLOB

1. Aggiungere il pacchetto di estensione azurefunctions-extensions-bindings-blob al file requirements.txt nel progetto, che deve includere almeno questi pacchetti:

   azure-functions
   azurefunctions-extensions-bindings-blob
   

2. Aggiungere questo codice al file function_app.py nel progetto, che importa le associazioni dei tipi SDK:

   import azurefunctions.extensions.bindings.blob as blob
   

Esempi di associazioni di tipi SDK

Questo esempio illustra come ottenere BlobClient da un trigger di archiviazione BLOB (blob_trigger) e dall'associazione di input in un trigger HTTP (blob_input):

import logging

import azure.functions as func
import azurefunctions.extensions.bindings.blob as blob

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.blob_trigger(
    arg_name="client", path="PATH/TO/BLOB", connection="AzureWebJobsStorage"
)
def blob_trigger(client: blob.BlobClient):
    logging.info(
        f"Python blob trigger function processed blob \n"
        f"Properties: {client.get_blob_properties()}\n"
        f"Blob content head: {client.download_blob().read(size=1)}"
    )


@app.route(route="file")
@app.blob_input(
    arg_name="client", path="PATH/TO/BLOB", connection="AzureWebJobsStorage"
)
def blob_input(req: func.HttpRequest, client: blob.BlobClient):
    logging.info(
        f"Python blob input function processed blob \n"
        f"Properties: {client.get_blob_properties()}\n"
        f"Blob content head: {client.download_blob().read(size=1)}"
    )
    return "ok"

È possibile visualizzare altri esempi di associazioni dei tipi di SDK per l'archiviazione BLOB nel repository delle estensioni Python:

• Tipo ContainerClient
• Tipo StorageStreamDownloader

Prerequisiti

• Runtime di Funzioni di Azure versione 4.34.1 o successiva.
• Python versione 3.8 o una successiva versione supportata.

Abilitare i flussi HTTP

I flussi HTTP sono disabilitati per impostazione predefinita. È necessario abilitare questa funzionalità nelle impostazioni dell'applicazione e aggiornare anche il codice per usare il pacchetto FastAPI. Si noti che quando si abilitano flussi HTTP, l'app per le funzioni usa per impostazione predefinita il flusso HTTP, mentre la funzionalità HTTP originale non funzionerà.

1. Aggiungere il pacchetto di estensione azurefunctions-extensions-http-fastapi al file requirements.txt nel progetto, che deve includere almeno questi pacchetti:

   azure-functions
   azurefunctions-extensions-http-fastapi
   

2. Aggiungere questo codice al file function_app.py nel progetto, che importa l'estensione FastAPI:

   from azurefunctions.extensions.http.fastapi import Request, StreamingResponse
   

3. Quando si esegue la distribuzione in Azure, aggiungere le impostazioni dell'applicazione seguenti nell'app per le funzioni:

   "PYTHON_ENABLE_INIT_INDEXING": "1"

   Se si esegue la distribuzione a consumo per Linux, aggiungere anche

   "PYTHON_ISOLATE_WORKER_DEPENDENCIES": "1"

   Quando si esegue localmente, è anche necessario aggiungere queste stesse impostazioni al file di progetto local.settings.json.

Esempi di flussi HTTP

Dopo aver abilitato la funzionalità di streaming HTTP, è possibile creare funzioni che eseguano lo streaming dei dati tramite HTTP.

Questo esempio è una funzione attivata da HTTP che trasmette i dati di risposta HTTP. È possibile usare queste funzionalità per supportare scenari come l'invio di dati degli eventi tramite una pipeline per la visualizzazione in tempo reale o il rilevamento di anomalie in grandi set di dati e l'invio di notifiche istantanee.

import time

import azure.functions as func
from azurefunctions.extensions.http.fastapi import Request, StreamingResponse

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)


def generate_sensor_data():
    """Generate real-time sensor data."""
    for i in range(10):
        # Simulate temperature and humidity readings
        temperature = 20 + i
        humidity = 50 + i
        yield f"data: {{'temperature': {temperature}, 'humidity': {humidity}}}\n\n"
        time.sleep(1)


@app.route(route="stream", methods=[func.HttpMethod.GET])
async def stream_sensor_data(req: Request) -> StreamingResponse:
    """Endpoint to stream real-time sensor data."""
    return StreamingResponse(generate_sensor_data(), media_type="text/event-stream")

Questo esempio è una funzione attivata da HTTP che riceve ed elabora i dati di streaming da un client in tempo reale. Illustra le funzionalità di caricamento in streaming che possono essere utili per scenari come l'elaborazione di flussi di dati continui e la gestione dei dati degli eventi dai dispositivi IoT.

import azure.functions as func
from azurefunctions.extensions.http.fastapi import JSONResponse, Request

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)


@app.route(route="streaming_upload", methods=[func.HttpMethod.POST])
async def streaming_upload(req: Request) -> JSONResponse:
    """Handle streaming upload requests."""
    # Process each chunk of data as it arrives
    async for chunk in req.stream():
        process_data_chunk(chunk)

    # Once all data is received, return a JSON response indicating successful processing
    return JSONResponse({"status": "Data uploaded and processed successfully"})


def process_data_chunk(chunk: bytes):
    """Process each data chunk."""
    # Add custom processing logic here
    pass

Chiamata di flussi HTTP

È necessario usare una libreria client HTTP per effettuare chiamate di streaming agli endpoint FastAPI di una funzione. Lo strumento client o il browser in uso potrebbero non supportare in modo nativo lo streaming o restituire solo il primo blocco di dati.

È possibile usare uno script client simile al seguente per inviare dati di streaming a un endpoint HTTP:

import httpx # Be sure to add 'httpx' to 'requirements.txt'
import asyncio

async def stream_generator(file_path):
    chunk_size = 2 * 1024  # Define your own chunk size
    with open(file_path, 'rb') as file:
        while chunk := file.read(chunk_size):
            yield chunk
            print(f"Sent chunk: {len(chunk)} bytes")

async def stream_to_server(url, file_path):
    timeout = httpx.Timeout(60.0, connect=60.0)
    async with httpx.AsyncClient(timeout=timeout) as client:
        response = await client.post(url, content=stream_generator(file_path))
        return response

async def stream_response(response):
    if response.status_code == 200:
        async for chunk in response.aiter_raw():
            print(f"Received chunk: {len(chunk)} bytes")
    else:
        print(f"Error: {response}")

async def main():
    print('helloworld')
    # Customize your streaming endpoint served from core tool in variable 'url' if different.
    url = 'http://localhost:7071/api/streaming_upload'
    file_path = r'<file path>'

    response = await stream_to_server(url, file_path)
    print(response)

if __name__ == "__main__":
    asyncio.run(main())

Gli output possono essere espressi sia nel valore restituito che nei parametri di output. Se è presente un solo output, è consigliabile usare il valore restituito. Per più output, è necessario usare i parametri di output.

Per usare il valore restituito di una funzione come valore di un'associazione di output, la proprietà name dell'associazione deve essere impostata su $return nel file function.json.

Per generare più output, usare il metodo set() fornito dall'interfaccia azure.functions.Out per assegnare un valore al binding. Ad esempio, la funzione seguente può eseguire il push di un messaggio in una coda e anche restituire una risposta HTTP.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "authLevel": "anonymous"
    },
    {
      "name": "msg",
      "direction": "out",
      "type": "queue",
      "queueName": "outqueue",
      "connection": "STORAGE_CONNECTION_STRING"
    },
    {
      "name": "$return",
      "direction": "out",
      "type": "http"
    }
  ]
}

import azure.functions as func

def main(req: func.HttpRequest,
         msg: func.Out[func.QueueMessage]) -> str:

    message = req.params.get('body')
    msg.set(message)
    return message

Gli output possono essere espressi sia nel valore restituito che nei parametri di output. Se è presente un solo output, è consigliabile usare il valore restituito. Per più output, è necessario usare invece i parametri di output.

Per generare più output, usare il metodo set() fornito dall'interfaccia azure.functions.Out per assegnare un valore al binding. Ad esempio, la funzione seguente può eseguire il push di un messaggio in una coda e anche restituire una risposta HTTP.

# function_app.py
import azure.functions as func

app = func.FunctionApp()

@app.write_blob(arg_name="msg", path="output-container/{name}",
                connection="CONNECTION_STRING")
def test_function(req: func.HttpRequest,
                  msg: func.Out[str]) -> str:

    message = req.params.get('body')
    msg.set(message)
    return message

Il trigger HTTP è definito nel file function.json. Il valore name del binding deve corrispondere al parametro denominato nella funzione. Negli esempi precedenti viene usato il nome di binding req. Questo parametro è un oggetto HttpRequest e viene restituito un oggetto HttpResponse.

Dall'oggetto HttpRequest è possibile ottenere intestazioni di richieste, parametri di query, parametri di route e il corpo del messaggio.

L'esempio seguente fa riferimento al modello di trigger HTTP per Python.

def main(req: func.HttpRequest) -> func.HttpResponse:
    headers = {"my-http-header": "some-value"}

    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

    if name:
        return func.HttpResponse(f"Hello {name}!", headers=headers)
    else:
        return func.HttpResponse(
             "Please pass a name on the query string or in the request body",
             headers=headers, status_code=400
        )

In questa funzione il valore del parametro di query name si ottiene dal parametro params dell'oggetto HttpRequest. Il corpo del messaggio con codifica JSON viene letto usando il metodo get_json.

Allo stesso modo, è possibile impostare status_code e headers per il messaggio di risposta nell'oggetto HttpResponse restituito.

Il trigger HTTP viene definito come metodo che accetta un parametro di associazione denominato, che è un oggetto HttpRequest e restituisce un oggetto HttpResponse. Si applica il decorator function_name al metodo per definire il nome della funzione, mentre l'endpoint HTTP viene impostato applicando il decorator route.

Questo esempio proviene dal modello di trigger HTTP per il modello di programmazione Python v2, in cui il nome del parametro di associazione è req. Si tratta del codice di esempio fornito quando si crea una funzione tramite Azure Functions Core Tools o Visual Studio Code.

@app.function_name(name="HttpTrigger1")
@app.route(route="hello")
def test_function(req: func.HttpRequest) -> func.HttpResponse:
     logging.info('Python HTTP trigger function processed a request.')

     name = req.params.get('name')
     if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

     if name:
        return func.HttpResponse(f"Hello, {name}. This HTTP-triggered function executed successfully.")
     else:
        return func.HttpResponse(
             "This HTTP-triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.",
             status_code=200
        )

Dall'oggetto HttpRequest è possibile ottenere intestazioni di richieste, parametri di query, parametri di route e il corpo del messaggio. In questa funzione il valore del parametro di query name si ottiene dal parametro params dell'oggetto HttpRequest. Il corpo del messaggio con codifica JSON viene letto usando il metodo get_json.

Allo stesso modo, è possibile impostare status_code e headers per il messaggio di risposta nell'oggetto HttpResponse restituito.

Per passare un nome in questo esempio, incollare l'URL fornito quando si esegue la funzione e quindi aggiungerlo con "?name={name}".

È possibile usare framework compatibili con Web Server Gateway Interface (WSGI) e ASGI (Asynchronous Server Gateway Interface), ad esempio Flask e FastAPI, con le funzioni Python attivate da HTTP. Questa sezione illustra come modificare le funzioni per supportare questi framework.

Prima di tutto, il file function.json deve essere aggiornato per includere un route nel trigger HTTP, come illustrato nell'esempio seguente:

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
       "authLevel": "anonymous",
       "type": "httpTrigger",
       "direction": "in",
       "name": "req",
       "methods": [
           "get",
           "post"
       ],
       "route": "{*route}"
    },
    {
       "type": "http",
       "direction": "out",
       "name": "$return"
    }
  ]
}

Il file host.json deve essere aggiornato anche per includere un routePrefix HTTP, come illustrato nell'esempio seguente:

{
  "version": "2.0",
  "logging": 
  {
    "applicationInsights": 
    {
      "samplingSettings": 
      {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  },
  "extensionBundle": 
  {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[3.*, 4.0.0)"
  },
  "extensions": 
  {
    "http": 
    {
        "routePrefix": ""
    }
  }
}

Aggiornare il file di codice Python init.py, a seconda dell'interfaccia usata dal framework. L'esempio seguente illustra un approccio del gestore ASGI o un approccio wrapper WSGI per Flask:

app = fastapi.FastAPI()

@app.get("hello/{name}")
async def get_name(name: str):
  return {"name": name}

def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
    return func.AsgiMiddleware(app).handle(req, context)

app = Flask("Test")

@app.route("hello/<name>", methods=["GET"])
def hello(name: str):
    return f"hello {name}"

def main(req: func.HttpRequest, context) -> func.HttpResponse:
  logging.info("Python HTTP trigger function processed a request.")
  return func.WsgiMiddleware(app).handle(req, context)

È possibile usare framework compatibili con ASGI (Asynchronous Server Gateway Interface) e WSGI (Web Server Gateway Interface), ad esempio Flask e FastAPI, con le funzioni Python attivate da HTTP. È prima necessario aggiornare il file host.json per includere un routePrefix HTTP, come illustrato nell'esempio seguente:

{
  "version": "2.0",
  "logging": 
  {
    "applicationInsights": 
    {
      "samplingSettings": 
      {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  },
  "extensionBundle": 
  {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[2.*, 3.0.0)"
  },
  "extensions": 
  {
    "http": 
    {
        "routePrefix": ""
    }
  }
}

Il codice del framework è simile all'esempio seguente:

# function_app.py

import azure.functions as func 
from fastapi import FastAPI, Request, Response 

fast_app = FastAPI() 

@fast_app.get("/return_http_no_body") 
async def return_http_no_body(): 
    return Response(content="", media_type="text/plain") 

app = func.AsgiFunctionApp(app=fast_app, 
                           http_auth_level=func.AuthLevel.ANONYMOUS) 

# function_app.py

import azure.functions as func 
from flask import Flask, Response 

flask_app = Flask(__name__) 

@flask_app.get("/return_http") 
def return_http(): 
    return Response("<h1>Hello World™</h1>", mimetype="text/html") 

app = func.WsgiFunctionApp(app=flask_app.wsgi_app, 
                           http_auth_level=func.AuthLevel.ANONYMOUS) 

In Funzioni di Azure le impostazioni dell'applicazione, come le stringhe di connessione al servizio, vengono esposte come variabili di ambiente durante l'esecuzione. Esistono due modi principali per accedere a queste impostazioni nel codice.

Entrambi questi modi richiedono di dichiarare import os.

L'esempio seguente usa os.environ["myAppSetting"] per ottenere l'impostazione dell'applicazione, con la chiave denominata myAppSetting:

import logging
import os

import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:
  # Get the setting named 'myAppSetting'
  my_app_setting_value = os.environ["myAppSetting"]
  logging.info(f'My app setting value:{my_app_setting_value}')

Per lo sviluppo locale, le impostazioni dell'applicazione vengono mantenute nel file local.settings.json.

In Funzioni di Azure le impostazioni dell'applicazione, come le stringhe di connessione al servizio, vengono esposte come variabili di ambiente durante l'esecuzione. Esistono due modi principali per accedere a queste impostazioni nel codice.

Entrambi questi modi richiedono di dichiarare import os.

L'esempio seguente usa os.environ["myAppSetting"] per ottenere l'impostazione dell'applicazione, con la chiave denominata myAppSetting:

import logging
import os

import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="req")
def main(req: func.HttpRequest) -> func.HttpResponse:
  # Get the setting named 'myAppSetting'
  my_app_setting_value = os.environ["myAppSetting"]
  logging.info(f'My app setting value:{my_app_setting_value}')

Per lo sviluppo locale, le impostazioni dell'applicazione vengono mantenute nel file local.settings.json.

Creare prima di tutto un file <project_root>/my_second_function/function.json e quindi definire questa funzione come trigger HTTP.

{
  "scriptFile": "__init__.py",
  "entryPoint": "main",
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
  ]
}

Successivamente, è possibile implementare my_second_function e shared_code.my_second_helper_function.

# <project_root>/my_second_function/__init__.py
import azure.functions as func
import logging

# Use absolute import to resolve shared_code modules
from shared_code import my_second_helper_function

# Define an HTTP trigger that accepts the ?value=<int> query parameter
# Double the value and return the result in HttpResponse
def main(req: func.HttpRequest) -> func.HttpResponse:
  logging.info('Executing my_second_function.')

  initial_value: int = int(req.params.get('value'))
  doubled_value: int = my_second_helper_function.double(initial_value)

  return func.HttpResponse(
    body=f"{initial_value} * 2 = {doubled_value}",
    status_code=200
    )

# <project_root>/shared_code/__init__.py
# Empty __init__.py file marks shared_code folder as a Python package

# <project_root>/shared_code/my_second_helper_function.py

def double(value: int) -> int:
  return value * 2

È possibile iniziare a scrivere test case per il trigger HTTP.

# <project_root>/tests/test_my_second_function.py
import unittest

import azure.functions as func
from my_second_function import main

class TestFunction(unittest.TestCase):
  def test_my_second_function(self):
    # Construct a mock HTTP request.
    req = func.HttpRequest(method='GET',
                           body=None,
                           url='/api/my_second_function',
                           params={'value': '21'})
    # Call the function.
    resp = main(req)

    # Check the output.
    self.assertEqual(resp.get_body(), b'21 * 2 = 42',)

All'interno della cartella dell'ambiente virtuale Python .venv installare il framework di test Python preferito, ad esempio pip install pytest. Eseguire quindi pytest tests per controllare il risultato del test.

Creare prima di tutto il file <project_root>/function_app.py e implementare la funzione my_second_function come trigger HTTP e shared_code.my_second_helper_function.

# <project_root>/function_app.py
import azure.functions as func
import logging

# Use absolute import to resolve shared_code modules
from shared_code import my_second_helper_function

app = func.FunctionApp()

# Define the HTTP trigger that accepts the ?value=<int> query parameter
# Double the value and return the result in HttpResponse
@app.function_name(name="my_second_function")
@app.route(route="hello")
def main(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Executing my_second_function.')

    initial_value: int = int(req.params.get('value'))
    doubled_value: int = my_second_helper_function.double(initial_value)

    return func.HttpResponse(
        body=f"{initial_value} * 2 = {doubled_value}",
        status_code=200
    )

# <project_root>/shared_code/__init__.py
# Empty __init__.py file marks shared_code folder as a Python package

# <project_root>/shared_code/my_second_helper_function.py

def double(value: int) -> int:
  return value * 2

È possibile iniziare a scrivere test case per il trigger HTTP.

# <project_root>/tests/test_my_second_function.py
import unittest
import azure.functions as func

from function_app import main

class TestFunction(unittest.TestCase):
  def test_my_second_function(self):
    # Construct a mock HTTP request.
    req = func.HttpRequest(method='GET',
                           body=None,
                           url='/api/my_second_function',
                           params={'value': '21'})
    # Call the function.
    func_call = main.build().get_user_function()
    resp = func_call(req)
    # Check the output.
    self.assertEqual(
        resp.get_body(),
        b'21 * 2 = 42',
    )

All'interno della cartella dell'ambiente virtuale Python .venv installare il framework di test Python preferito, ad esempio pip install pytest. Eseguire quindi pytest tests per controllare il risultato del test.