Creare trigger e binding

3 minuti

I trigger sono causano l'esecuzione di una funzione. Un trigger definisce il modo in cui una funzione viene richiamata e una funzione deve avere esattamente un trigger. Ai trigger sono associati dati, che spesso vengono forniti come payload della funzione.

L’associazione di binding a una funzione rappresenta un modo dichiarativo per connettere un'altra risorsa alla funzione. I binding possono essere connessi come binding di input, binding di output o di entrambi i tipi. I dati dei binding vengono forniti alla funzione come parametri.

È possibile combinare binding diversi in base alle esigenze. I binding sono facoltativi e una funzione potrebbe avere uno o più binding di input e/o di output.

Trigger e binding consentono di evitare di impostare come hardcoded l'accesso ad altri servizi. La funzione riceve i dati, ad esempio il contenuto di un messaggio della coda, nei parametri della funzione. I dati vengono inviati, ad esempio per creare un messaggio della coda, usando il valore restituito della funzione.

Definizioni di trigger e binding

I trigger e i binding vengono definiti in modo diverso a seconda del linguaggio di sviluppo.

Lingua	La configurazione di trigger e binding avviene nei seguenti modi:
Libreria di classi C#	decorazione di metodi e parametri con attributi C#
Java	decorazione di metodi e parametri con annotazioni Java
JavaScript/PowerShell/Python/TypeScript	aggiornamento dello schema function.json

Per i linguaggi basati su function.json, il portale fornisce un'interfaccia utente che consente di aggiungere binding nella scheda Integrazione. È anche possibile modificare il file direttamente nel portale, nella scheda Codice e test della funzione.

In .NET e Java il tipo di parametro definisce il tipo di dati per i dati di input. Ad esempio, string consente di eseguire il binding al testo di un trigger di accodamento, una matrice di byte da leggere come binaria e un tipo personalizzato da de-serializzare in un oggetto. Poiché le funzioni della libreria di classi .NET e le funzioni Java non usano function.json per le definizioni dei binding, non è possibile crearle i modificarle nel portale. Il processo di modifica di C# nel portale è basato sullo script C#, che usa function.json anziché gli attributi.

Per i linguaggi tipizzati in modo dinamico, ad esempio JavaScript, usare la proprietà dataType nel file function.json. Ad esempio, per eseguire la lettura del contenuto di una richiesta HTTP in formato binario, impostare dataType su binary:

{
    "dataType": "binary",
    "type": "httpTrigger",
    "name": "req",
    "direction": "in"
}

Altre opzioni per dataType sono stream e string.

Direzione di binding

Per tutti i trigger e i binding, è disponibile una proprietà di direzione nel file function.json:

Per i trigger, la direzione è sempre in
Le associazioni di input e di output usano in e out
Alcune associazioni supportano una direzione speciale inout. Se si usa inout, solo l’editor avanzato risulterà disponibile dalla scheda Integrazione del portale.

Quando si usano attributi in una libreria di classi per configurare trigger e binding, la direzione viene specificata in un costruttore di attributi o dedotta dal tipo di parametro.

Esempio di trigger e binding di Funzioni di Azure

Si supponga di voler scrivere una nuova riga in Archiviazione tabelle di Azure ogni volta che viene visualizzato un nuovo messaggio in Archiviazione code di Azure. Questo scenario può essere implementato usando un trigger di Archiviazione code di Azure e un binding di output di Archiviazione tabelle di Azure.

Ecco un file function.json per questo scenario.

{
  "bindings": [
    {
      "type": "queueTrigger",
      "direction": "in",
      "name": "order",
      "queueName": "myqueue-items",
      "connection": "MY_STORAGE_ACCT_APP_SETTING"
    },
    {
      "type": "table",
      "direction": "out",
      "name": "$return",
      "tableName": "outTable",
      "connection": "MY_TABLE_STORAGE_ACCT_APP_SETTING"
    }
  ]
}

Il primo elemento nella matrice bindings è il trigger di archiviazione code. Le proprietà type e direction identificano il trigger. La proprietà name identifica il parametro della funzione che riceve il contenuto del messaggio della coda. Il nome della coda da monitorare si trova in queueName e la stringa di connessione si trova nell'impostazione app identificata da connection.

Il secondo elemento nella matrice bindings è l'associazione di output dell'archiviazione tabelle di Azure. Le proprietà type e direction identificano l'associazione. La proprietà name specifica in che modo la funzione fornisce la nuova riga di tabella, in questo caso usando il valore restituito della funzione. Il nome della tabella si trova in tableName e la stringa di connessione si trova nell'impostazione app identificata da connection.

Esempio di script C#

Il codice dell'esempio di script C# funziona con questo trigger e questo binding. Si noti che il nome del parametro che fornisce il contenuto del messaggio della coda è order. Questo nome è obbligatorio perché il valore della proprietà name nel file function.json è order.

#r "Newtonsoft.Json"

using Microsoft.Extensions.Logging;
using Newtonsoft.Json.Linq;

// From an incoming queue message that is a JSON object, add fields and write to Table storage
// The method return value creates a new row in Table Storage
public static Person Run(JObject order, ILogger log)
{
    return new Person() { 
            PartitionKey = "Orders", 
            RowKey = Guid.NewGuid().ToString(),  
            Name = order["Name"].ToString(),
            MobileNumber = order["MobileNumber"].ToString() };  
}

public class Person
{
    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public string Name { get; set; }
    public string MobileNumber { get; set; }
}

Esempio di JavaScript

Lo stesso file function.json può essere usato con una funzione JavaScript:

// From an incoming queue message that is a JSON object, add fields and write to Table Storage
module.exports = async function (context, order) {
    order.PartitionKey = "Orders";
    order.RowKey = generateRandomId(); 

    context.bindings.order = order;
};

function generateRandomId() {
    return Math.random().toString(36).substring(2, 15) +
        Math.random().toString(36).substring(2, 15);
}

Esempio di libreria di classi

In una libreria di classi le informazioni su trigger e binding uguali, ovvero nomi di code e tabelle, account di archiviazione, parametri di funzione per input e output, vengono specificate dagli attributi anziché da un file function.json. Ecco un esempio:

public static class QueueTriggerTableOutput
{
    [FunctionName("QueueTriggerTableOutput")]
    [return: Table("outTable", Connection = "MY_TABLE_STORAGE_ACCT_APP_SETTING")]
    public static Person Run(
        [QueueTrigger("myqueue-items", Connection = "MY_STORAGE_ACCT_APP_SETTING")]JObject order,
        ILogger log)
    {
        return new Person() {
                PartitionKey = "Orders",
                RowKey = Guid.NewGuid().ToString(),
                Name = order["Name"].ToString(),
                MobileNumber = order["MobileNumber"].ToString() };
    }
}

public class Person
{
    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public string Name { get; set; }
    public string MobileNumber { get; set; }
}

Risorse aggiuntive

Per esempi più dettagliati di trigger e binding, visitare:

Continua