Concetti di Trigger e associazioni di Funzioni di AzureAzure Functions triggers and bindings concepts

In questo articolo viene fornita una panoramica concettuale di trigger e associazioni in Funzioni di Azure.This article is a conceptual overview of triggers and bindings in Azure Functions. Le funzionalità comuni a tutte le associazioni e a tutti i linguaggi supportati sono descritte di seguito.Features that are common to all bindings and all supported languages are described here.

PanoramicaOverview

Un trigger definisce come viene richiamata una funzione.A trigger defines how a function is invoked. Una funzione deve avere esattamente un trigger.A function must have exactly one trigger. I trigger hanno dei dati associati, ovvero in genere il payload che ha attivato la funzione.Triggers have associated data, which is usually the payload that triggered the function.

Le associazioni di input e output forniscono una modalità dichiarativa per connettersi ai dati dall'interno del codice.Input and output bindings provide a declarative way to connect to data from within your code. Le associazioni sono facoltative e una funzione può avere più associazioni di input e output.Bindings are optional and a function can have multiple input and output bindings.

I trigger e le associazioni permettono di evitare di inserire dettagli hardcoded dei servizi usati.Triggers and bindings let you avoid hardcoding the details of the services that you're working with. La funzione riceve i dati, ad esempio il contenuto di un messaggio della coda, nei parametri della funzione.You function receives data (for example, the content of a queue message) in function parameters. I dati vengono inviati, ad esempio per creare un messaggio della coda, usando il valore restituito della funzione, un parametro out o un oggetto agente di raccolta.You send data (for example, to create a queue message) by using the return value of the function, an out parameter, or a collector object.

Quando si sviluppano funzioni tramite il portale di Azure, i trigger e le associazioni sono configurati in un file function.json.When you develop functions by using the Azure portal, triggers and bindings are configured in a function.json file. Il portale fornisce un'interfaccia utente per questa configurazione, ma è possibile modificare direttamente il file passando all'editor avanzato.The portal provides a UI for this configuration but you can edit the file directly by changing to the Advanced editor.

Se le funzioni vengono sviluppate in Visual Studio per creare una libreria di classi, i trigger e le associazioni vengono configurati tramite la decorazione di metodi e parametri con attributi.When you develop functions by using Visual Studio to create a class library, you configure triggers and bindings by decorating methods and parameters with attributes.

Binding supportatiSupported bindings

La tabella seguente mostra le associazioni supportate nelle due principali versioni del runtime di Funzioni di Azure.The following table shows the bindings that are supported in the two major versions of the Azure Functions runtime.

typeType 1.x1.x 2.x2.x TriggerTrigger InputInput OutputOutput
Archiviazione BLOBBlob Storage
Cosmos DBCosmos DB 11
Griglia di eventiEvent Grid
Hub eventiEvent Hubs
File esterno2External File2
Tabella esterna2External Table2
HTTPHTTP
Microsoft Graph
Tabelle di Excel
Microsoft Graph
Excel tables
11
Microsoft Graph
File di OneDrive
Microsoft Graph
OneDrive files
11
Microsoft Graph
Indirizzo e-mail Outlook
Microsoft Graph
Outlook email
11
Microsoft Graph
Eventi
Microsoft Graph
Events
11
Microsoft Graph
Token di autenticazione
Microsoft Graph
Auth tokens
11
App per dispositivi mobiliMobile Apps 11
Hub di notifica di AzureNotification Hubs
Archiviazione codeQueue storage
SendGridSendGrid 11
Bus di servizioService Bus 11
Archiviazione tabelleTable storage
TimerTimer
TwilioTwilio 11
WebhookWebhooks

1 Deve essere registrato come un'estensione di associazione nella versione 2. x.1 Must be registered as a binding extension in 2.x. Vedere Problemi noti nella versione 2.x.See Known issues in 2.x.

2 Sperimentale — Non supportato e potrebbe venire abbandonato in futuro.2 Experimental — not supported and might be abandoned in the future.

Per informazioni sulle associazioni in anteprima o approvate per l'uso in ambiente di produzione, vedere Linguaggi supportati .For information about which bindings are in preview or are approved for production use, see Supported languages.

Esempio: trigger di coda e tabella di associazione di outputExample: queue trigger and table output binding

Si supponga di voler scrivere una nuova riga in archiviazione tabelle di Azure ogni volta che viene visualizzato un messaggio nuovo in archiviazione code di Azure.Suppose you want to write a new row to Azure Table storage whenever a new message appears in Azure Queue storage. Questo scenario può essere implementato tramite un trigger di archiviazione code di Azure e un'associazione di output di archiviazione tabelle di Azure.This scenario can be implemented using an Azure Queue storage trigger and an Azure Table storage output binding.

Ecco un file function.json per questo scenario.Here's a function.json file for this scenario.

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

Il primo elemento nella matrice bindings è il trigger di archiviazione code.The first element in the bindings array is the Queue storage trigger. Le proprietà type e direction identificano il trigger.The type and direction properties identify the trigger. La proprietà name identifica il parametro di funzione che riceverà il contenuto del messaggio della coda.The name property identifies the function parameter that will receive the queue message content. Il nome della coda da monitorare si trova in queueName e la stringa di connessione si trova nell'impostazione app identificata da connection.The name of the queue to monitor is in queueName, and the connection string is in the app setting identified by connection.

Il secondo elemento nella matrice bindings è l'associazione di output dell'archiviazione tabelle di Azure.The second element in the bindings array is the Azure Table Storage output binding. Le proprietà type e direction identificano l'associazione.The type and direction properties identify the binding. La proprietà name specifica in che modo la funzionalità fornirà la nuova riga della tabella, in questo caso usando il valore restituito della funzione.The name property specifies how the function will provide the new table row, in this case by using the function return value. Il nome della tabella si trova in tableName e la stringa di connessione si trova nell'impostazione app identificata da connection.The name of the table is in tableName, and the connection string is in the app setting identified by connection.

Per visualizzare e modificare i contenuti della funzione .json nel portale di Azure, fare clic sull'opzione Editor avanzato nella scheda Integrazione della funzione.To view and edit the contents of function.json in the Azure portal, click the Advanced editor option on the Integrate tab of your function.

Nota

Il valore di connection corrisponde al nome di un'impostazione app che contiene la stringa di connessione e non alla stringa di connessione stessa.The value of connection is the name of an app setting that contains the connection string, not the connection string itself. Le associazioni usano stringhe di connessione archiviate nelle impostazioni app per imporre la procedura consigliata che prevede che il file function.json non contenga i segreti del servizio.Bindings use connection strings stored in app settings to enforce the best practice that function.json does not contain service secrets.

Ecco il codice dello script C# per questo trigger e questa associazione.Here's C# script code that works with this trigger and 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 è orderNotice that the name of the parameter that provides the queue message content is order; this name is required because the name property value in function.json is order

#r "Newtonsoft.Json"

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, TraceWriter 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; }
}

Lo stesso file function.json può essere usato con una funzione JavaScript:The same function.json file can be used with a JavaScript function:

// From an incoming queue message that is a JSON object, add fields and write to Table Storage
// The second parameter to context.done is used as the value for the new row
module.exports = function (context, order) {
    order.PartitionKey = "Orders";
    order.RowKey = generateRandomId(); 

    context.done(null, order);
};

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

In una libreria di classi, le stesse informazioni per il trigger e l'associazione, ovvero nomi di coda e tabella, account di archiviazione, parametri di funzione per input e output, sono forniti dagli attributi:In a class library, the same trigger and binding information — queue and table names, storage accounts, function parameters for input and output — is provided by attributes:

 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, 
         TraceWriter 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; }
 }

Direzione dell'associazioneBinding direction

Tutti i trigger e le associazioni hanno una proprietà direction nel file function.json:All triggers and bindings have a direction property in the function.json file:

  • Per i trigger, la direzione è sempre inFor triggers, the direction is always in
  • Le associazioni di input e di output usano in e outInput and output bindings use in and out
  • Alcune associazioni supportano una direzione speciale inout.Some bindings support a special direction inout. Se si usa inout, solo l'Editor avanzato è disponibile nelle scheda Integrazione.If you use inout, only the Advanced editor is available in the Integrate tab.

Quando si usano gli attributi in una libreria di classi per configurare i trigger e le associazioni, la direzione viene specificata in un costruttore di attributo o dedotta dal tipo di parametro.When you use attributes in a class library to configure triggers and bindings, the direction is provided in an attribute constructor or inferred from the parameter type.

Uso del tipo restituito della funzione per restituire un singolo outputUsing the function return type to return a single output

L'esempio precedente illustra come usare il valore restituito della funzione per fornire l'output a un'associazione, che viene specificato nel file function.json usando il valore speciale $return per la proprietà name.The preceding example shows how to use the function return value to provide output to a binding, which is specified in function.json by using the special value $return for the name property. Questa opzione è supportata solo nei linguaggi che presentano un valore restituito, ad esempio script C#, JavaScript e F#. Se una funzione dispone di più associazioni di output, usare $return per una sola delle associazioni di output.(This is only supported in languages that have a return value, such as C# script, JavaScript, and F#.) If a function has multiple output bindings, use $return for only one of the output bindings.

// excerpt of function.json
{
    "name": "$return",
    "type": "blob",
    "direction": "out",
    "path": "output-container/{id}"
}

Gli esempi seguenti mostrano come vengono usati i tipi restituiti con le associazioni di output nello script C#, in JavaScript e F#.The examples below show how return types are used with output bindings in C# script, JavaScript, and F#.

// C# example: use method return value for output binding
public static string Run(WorkItem input, TraceWriter log)
{
    string json = string.Format("{{ \"id\": \"{0}\" }}", input.Id);
    log.Info($"C# script processed queue message. Item={json}");
    return json;
}
// C# example: async method, using return value for output binding
public static Task<string> Run(WorkItem input, TraceWriter log)
{
    string json = string.Format("{{ \"id\": \"{0}\" }}", input.Id);
    log.Info($"C# script processed queue message. Item={json}");
    return Task.FromResult(json);
}
// JavaScript: return a value in the second parameter to context.done
module.exports = function (context, input) {
    var json = JSON.stringify(input);
    context.log('Node.js script processed queue message', json);
    context.done(null, json);
}
// F# example: use return value for output binding
let Run(input: WorkItem, log: TraceWriter) =
    let json = String.Format("{{ \"id\": \"{0}\" }}", input.Id)   
    log.Info(sprintf "F# script processed queue message '%s'" json)
    json

Proprietà Binding dataTypeBinding dataType property

In .NET usare il tipo di parametro per definire il tipo di dati per i dati di input.In .NET, use the parameter type to define the data type for input data. Usare ad esempio string da associare al testo di un trigger di coda, una matrice di byte da leggere in formato binario e un tipo personalizzato per deserializzare un oggetto POCO.For instance, use string to bind to the text of a queue trigger, a byte array to read as binary and a custom type to deserialize to a POCO object.

Per i linguaggi tipizzati in modo dinamico, ad esempio JavaScript, usare la proprietà dataType nel file function.json.For languages that are dynamically typed such as JavaScript, use the dataType property in the function.json file. Ad esempio, per eseguire la lettura del contenuto di una richiesta HTTP in formato binario, impostare dataType su binary:For example, to read the content of an HTTP request in binary format, set dataType to binary:

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

Altre opzioni per dataType sono stream e string.Other options for dataType are stream and string.

Risoluzione di impostazioni appResolving app settings

Come procedura consigliata, i segreti e le stringhe di connessione devono essere gestiti tramite le impostazioni dell'app, invece dei file di configurazione.As a best practice, secrets and connection strings should be managed using app settings, rather than configuration files. Ciò limita l'accesso a questi segreti e rende sicuro archiviare function.json in un repository di controllo sorgente pubblico.This limits access to these secrets and makes it safe to store function.json in a public source control repository.

Le impostazioni dell'app sono utili anche ogni volta che si desidera modificare la configurazione in base all'ambiente.App settings are also useful whenever you want to change configuration based on the environment. Ad esempio, in un ambiente di test, si potrebbe voler monitorare un contenitore di archiviazione BLOB o di coda diverso.For example, in a test environment, you may want to monitor a different queue or blob storage container.

Le impostazioni dell'app vengono risolte ogni volta che un valore è racchiuso tra simboli di percentuale, ad esempio %MyAppSetting%.App settings are resolved whenever a value is enclosed in percent signs, such as %MyAppSetting%. Si noti che la proprietà connection di trigger e associazioni è un caso speciale e risolve automaticamente i valori come impostazioni dell'app.Note that the connection property of triggers and bindings is a special case and automatically resolves values as app settings.

L'esempio seguente è un trigger di archiviazione code di Azure che usa un'impostazione dell'app %input-queue-name% per definire la coda di trigger.The following example is an Azure Queue Storage trigger that uses an app setting %input-queue-name% to define the queue to trigger on.

{
  "bindings": [
    {
      "name": "order",
      "type": "queueTrigger",
      "direction": "in",
      "queueName": "%input-queue-name%",
      "connection": "MY_STORAGE_ACCT_APP_SETTING"
    }
  ]
}

È possibile usare lo stesso approccio nelle librerie di classi:You can use the same approach in class libraries:

[FunctionName("QueueTrigger")]
public static void Run(
    [QueueTrigger("%input-queue-name%")]string myQueueItem, 
    TraceWriter log)
{
    log.Info($"C# Queue trigger function processed: {myQueueItem}");
}

Proprietà dei metadati di triggerTrigger metadata properties

Oltre al payload dei dati offerto da un trigger (ad esempio, il messaggio di coda che ha attivato una funzione), molti trigger forniscono i valori dei metadati aggiuntivi.In addition to the data payload provided by a trigger (such as the queue message that triggered a function), many triggers provide additional metadata values. Questi valori possono essere usati come parametri di input in C# e F# o come proprietà nell'oggetto context.bindings in JavaScript.These values can be used as input parameters in C# and F# or properties on the context.bindings object in JavaScript.

Un trigger di archiviazione code di Azure, ad esempio, supporta le proprietà seguenti:For example, an Azure Queue storage trigger supports the following properties:

  • QueueTrigge: attivazione del contenuto del messaggio, se una stringa validaQueueTrigger - triggering message content if a valid string
  • DequeueCountDequeueCount
  • ExpirationTimeExpirationTime
  • IDId
  • InsertionTimeInsertionTime
  • NextVisibleTimeNextVisibleTime
  • PopReceiptPopReceipt

I valori di questi metadati sono accessibili nelle proprietà del file function.json.These metadata values are accessible in function.json file properties. Si supponga, ad esempio, di usare un trigger di accodamento e che il messaggio della coda contenga il nome di un BLOB di cui si vuole eseguire la lettura.For example, suppose you use a queue trigger and the queue message contains the name of a blob you want to read. Nel file function.json è possibile usare la proprietà dei metadati queueTrigger nella proprietà path del BLOB come mostrato nell'esempio seguente:In the function.json file, you can use queueTrigger metadata property in the blob path property, as shown in the following example:

  "bindings": [
    {
      "name": "myQueueItem",
      "type": "queueTrigger",
      "queueName": "myqueue-items",
      "connection": "MyStorageConnection",
    },
    {
      "name": "myInputBlob",
      "type": "blob",
      "path": "samples-workitems/{queueTrigger}",
      "direction": "in",
      "connection": "MyStorageConnection"
    }
  ]

I dettagli delle proprietà dei metadati per ogni trigger sono descritti nell'articolo di riferimento corrispondente.Details of metadata properties for each trigger are described in the corresponding reference article. Per un esempio, vedere metadati dei trigger per le code.For an example, see queue trigger metadata. La documentazione è disponibile anche nella scheda Integrazione del portale nella sezione Documentazione sotto l'area di configurazione dell'associazione.Documentation is also available in the Integrate tab of the portal, in the Documentation section below the binding configuration area.

Modelli ed espressioni di associazioneBinding expressions and patterns

Una delle funzionalità più potenti di trigger e associazioni sono le espressioni di associazione.One of the most powerful features of triggers and bindings is binding expressions. Nella configurazione per un'associazione è possibile definire espressioni di criteri che possono quindi essere usate in altre associazioni o nel codice.In the configuration for a binding, you can define pattern expressions which can then be used in other bindings or your code. I metadati dei trigger possono essere usati anche nelle espressioni di associazione, come illustrato nell'esempio della sezione precedente.Trigger metadata can also be used in binding expressions, as shown in the preceding section.

Ad esempio, si supponga di voler ridimensionare le immagini in un contenitore di archiviazione BLOB specifico, simile al modello di ridimensionamento immagine nella pagina Nuova funzione del portale di Azure (vedere lo scenario Esempi).For example, suppose you want to resize images in a particular blob storage container, similar to the Image Resizer template in the New Function page of the Azure portal (see the Samples scenario).

Ecco la definizione di function.json:Here is the function.json definition:

{
  "bindings": [
    {
      "name": "image",
      "type": "blobTrigger",
      "path": "sample-images/{filename}",
      "direction": "in",
      "connection": "MyStorageConnection"
    },
    {
      "name": "imageSmall",
      "type": "blob",
      "path": "sample-images-sm/{filename}",
      "direction": "out",
      "connection": "MyStorageConnection"
    }
  ],
}

Si noti che il parametro filename viene usato nella definizione del trigger del BLOB e anche nell'associazione di output del BLOB.Notice that the filename parameter is used in both the blob trigger definition and the blob output binding. Questo parametro può essere usato anche nel codice della funzione.This parameter can also be used in function code.

// C# example of binding to {filename}
public static void Run(Stream image, string filename, Stream imageSmall, TraceWriter log)  
{
    log.Info($"Blob trigger processing: {filename}");
    // ...
} 

La stessa possibilità di usare criteri ed espressioni di associazione si applica agli attributi nelle librerie di classi.The same ability to use binding expressions and patterns applies to attributes in class libraries. Ad esempio, ecco una funzione di ridimensionamento immagini in una libreria di classi:For example, here is a image resizing function in a class library:

[FunctionName("ResizeImage")]
[StorageAccount("AzureWebJobsStorage")]
public static void Run(
    [BlobTrigger("sample-images/{name}")] Stream image, 
    [Blob("sample-images-sm/{name}", FileAccess.Write)] Stream imageSmall, 
    [Blob("sample-images-md/{name}", FileAccess.Write)] Stream imageMedium)
{
    var imageBuilder = ImageResizer.ImageBuilder.Current;
    var size = imageDimensionsTable[ImageSize.Small];

    imageBuilder.Build(image, imageSmall,
        new ResizeSettings(size.Item1, size.Item2, FitMode.Max, null), false);

    image.Position = 0;
    size = imageDimensionsTable[ImageSize.Medium];

    imageBuilder.Build(image, imageMedium,
        new ResizeSettings(size.Item1, size.Item2, FitMode.Max, null), false);
}

public enum ImageSize { ExtraSmall, Small, Medium }

private static Dictionary<ImageSize, (int, int)> imageDimensionsTable = new Dictionary<ImageSize, (int, int)>() {
    { ImageSize.ExtraSmall, (320, 200) },
    { ImageSize.Small,      (640, 400) },
    { ImageSize.Medium,     (800, 600) }
};

Crea GUIDCreate GUIDs

L'espressione di associazione {rand-guid} crea un GUID.The {rand-guid} binding expression creates a GUID. Nell'esempio seguente viene usato un GUID per creare un nome BLOB univoco:The following example uses a GUID to create a unique blob name:

{
  "type": "blob",
  "name": "blobOutput",
  "direction": "out",
  "path": "my-output-container/{rand-guid}"
}

Ora correnteCurrent time

L'espressione di associazione DateTime viene risolta in DateTime.UtcNow.The binding expression DateTime resolves to DateTime.UtcNow.

{
  "type": "blob",
  "name": "blobOutput",
  "direction": "out",
  "path": "my-output-container/{DateTime}"
}

Eseguire l'associazione a proprietà di input personalizzateBind to custom input properties

Le espressioni di associazione possono anche fare riferimento alle proprietà definite nel payload del trigger stesso.Binding expressions can also reference properties that are defined in the trigger payload itself. Ad esempio, si potrebbe voler associare in modo dinamico ad un file di archiviazione BLOB un filename fornito da un webhook.For example, you may want to dynamically bind to a blob storage file from a filename provided in a webhook.

Ad esempio, la seguente function.json usa una proprietà denominata BlobName dal payload del trigger:For example, the following function.json uses a property called BlobName from the trigger payload:

{
  "bindings": [
    {
      "name": "info",
      "type": "httpTrigger",
      "direction": "in",
      "webHookType": "genericJson"
    },
    {
      "name": "blobContents",
      "type": "blob",
      "direction": "in",
      "path": "strings/{BlobName}",
      "connection": "AzureWebJobsStorage"
    },
    {
      "name": "res",
      "type": "http",
      "direction": "out"
    }
  ]
}

A tale scopo in C# e F #, è necessario definire un POCO che definisce i campi che saranno deserializzati nel payload del trigger.To accomplish this in C# and F#, you must define a POCO that defines the fields that will be deserialized in the trigger payload.

using System.Net;

public class BlobInfo
{
    public string BlobName { get; set; }
}

public static HttpResponseMessage Run(HttpRequestMessage req, BlobInfo info, string blobContents)
{
    if (blobContents == null) {
        return req.CreateResponse(HttpStatusCode.NotFound);
    } 

    return req.CreateResponse(HttpStatusCode.OK, new {
        data = $"{blobContents}"
    });
}

In JavaScript, viene eseguita automaticamente la deserializzazione di JSON ed è possibile usare direttamente le proprietà.In JavaScript, JSON deserialization is automatically performed and you can use the properties directly.

module.exports = function (context, info) {
    if ('BlobName' in info) {
        context.res = {
            body: { 'data': context.bindings.blobContents }
        }
    }
    else {
        context.res = {
            status: 404
        };
    }
    context.done();
}

Configurazione dell'associazione di dati in fase di runtimeConfiguring binding data at runtime

In C# e altri linguaggi .NET, è possibile usare criteri di associazione imperativa, rispetto alle associazioni dichiarative nel file function.json e negli attributi.In C# and other .NET languages, you can use an imperative binding pattern, as opposed to the declarative bindings in function.json and attributes. L'associazione imperativa è utile quando i parametri di associazione devono essere calcolati in fase di runtime invece che in fase di progettazione.Imperative binding is useful when binding parameters need to be computed at runtime rather than design time. Per altre informazioni, vedere Associazione in fase di runtime tramite le associazioni imperative nel riferimento per sviluppatori C#.To learn more, see Binding at runtime via imperative bindings in the C# developer reference.

Schema del file function.jsonfunction.json file schema

Lo schema del file function.json è disponibile all'indirizzo http://json.schemastore.org/function.The function.json file schema is available at http://json.schemastore.org/function.

Gestione degli errori di associazioneHandling binding errors

Trigger e associazioni di Funzioni di Azure comunicano con diversi servizi di Azure.Azure Functions triggers and bindings communicate with various Azure services. In caso di integrazione con questi servizi, possono venire generati errori originati dalle API dei servizi di Azure sottostanti.When integrating with these services, you may have errors raised that originate from the APIs of the underlying Azure services. Possono verificarsi errori anche quando si prova a comunicare con altri servizi dal codice della funzione usando librerie client o REST.Errors can also occur when you try to communicate with other services from your function code by using REST or client libraries. Per evitare la perdita di dati e garantire un comportamento corretto delle funzioni, è importante gestire gli errori da entrambe le origini.To avoid loss of data and ensure good behavior of your functions, it is important to handle errors from either source.

Per la maggior parte dei trigger, non è disponibile un meccanismo predefinito di ripetizione dei tentativi quando si verificano errori durante l'esecuzione della funzione.For most triggers, there is no built-in retry when errors occur during function execution. I due trigger che offrono supporto per la ripetizione dei tentativi sono Archiviazione code di Azure e Archiviazione BLOB di Azure.The two triggers that have retry support are Azure Queue storage and Azure Blob storage. Per impostazione predefinita, per questi trigger vengono eseguiti fino a cinque nuovi tentativi.By default, these triggers are retried up to five times. Dopo il quinto tentativo, entrambi i trigger scrivono un messaggio in una speciale coda non elaborabile.After the fifth retry, both triggers write a message to a special poison queue.

Per evitare perdite di informazioni dei trigger in caso di errore nella funzione, è consigliabile usare blocchi Try-Catch nel codice della funzione per intercettare gli errori.To prevent loss of trigger information should an error occur in your function, we recommend that you use try-catch blocks in your function code to catch any errors. Quando si verifica un errore, scrivere le informazioni passate alla funzione dal trigger in una speciale coda "non elaborabile".When an error occurs, write the information passed into the function by the trigger to a special "poison" message queue. Questo approccio corrisponde a quello usato dal trigger di archiviazione BLOB.This approach is the same one used by the Blob storage trigger.

In questo modo, è possibile acquisire gli eventi di trigger che potrebbero andare persi a causa di errori ed eseguire un nuovo tentativo in un secondo momento usando un'altra funzione per elaborare i messaggi dalla coda non elaborabile usando le informazioni archiviate.In this way, you can capture trigger events that could be lost due to errors and retry them at a later time using another function to process messages from the poison queue using the stored information.

Per i collegamenti a tutti gli argomenti relativi agli errori pertinenti per i diversi servizi supportati da Funzioni, vedere la sezione Binding error codes (Codici degli errori di associazione) dell'argomento introduttivo Azure Functions error handling (Gestione degli errori di Funzioni di Azure).For links to all relevant error topics for the various services supported by Functions, see the Binding error codes section of the Azure Functions error handling overview topic.

Passaggi successiviNext steps

Per altre informazioni su questi elementi, vedere gli articoli indicati di seguito:For more information on a specific binding, see the following articles: