Liaison de déclencheur Azure Database pour MySQL pour Azure Functions

Les liaisons de déclencheur Azure Database pour MySQL surveillent la table utilisateur pour les modifications (insertions et mises à jour) et appellent la fonction avec des données de ligne mises à jour.

Les liaisons de déclencheur Azure Database pour MySQL utilisent et utilisent az_func_updated_at des données de colonne pour surveiller la table utilisateur pour les modifications. Par conséquent, vous devez modifier la structure de table pour autoriser le suivi des modifications sur la table MySQL avant d’utiliser la prise en charge du déclencheur. Vous pouvez activer le suivi des modifications sur une table via la requête suivante. Par exemple, activez-la sur la Products table :

ALTER TABLE Products
ADD az_func_updated_at TIMESTAMP DEFAULT 
CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP;

La table des baux contient toutes les colonnes qui correspondent à la clé primaire de la table utilisateur et trois colonnes supplémentaires : az_func_AttemptCount, az_func_LeaseExpirationTimeet az_func_SyncCompletedTime. Si l’une des colonnes de clé primaire porte le même nom, le résultat est un message d’erreur qui répertorie les conflits. Dans ce cas, les colonnes de clé primaire répertoriées doivent être renommées pour que le déclencheur fonctionne.

Vue d’ensemble des fonctionnalités

Lorsque la fonction de déclencheur démarre, elle lance deux boucles distinctes : la boucle d’interrogation des modifications et la boucle de renouvellement du bail. Ces boucles s’exécutent en continu jusqu’à ce que la fonction soit arrêtée.

La liaison de déclencheur Azure Database pour MySQL utilise la boucle d’interrogation pour rechercher les modifications. La boucle d’interrogation déclenche la fonction utilisateur lorsqu’elle détecte les modifications. À un niveau élevé, la boucle ressemble à cet exemple :

while (true) {
    1. Get list of changes on table - up to a maximum number controlled by the MySql_Trigger_MaxBatchSize setting
    2. Trigger function with list of changes
    3. Wait for delay controlled by MySql_Trigger_PollingIntervalMs setting
}

Les modifications sont traitées dans l’ordre dans lequel elles sont apportées. Les modifications les plus anciennes sont traitées en premier. Tenez compte de ces points sur le traitement des modifications :

Si des modifications se produisent dans plusieurs lignes à la fois, l’ordre exact dans lequel ils sont envoyés à la fonction est basé sur l’ordre croissant des colonnes de az_func_updated_at colonne et de clé primaire.
Les modifications sont traitées par lots pour une ligne. Si plusieurs modifications se produisent dans une ligne entre chaque itération de la boucle, seule la dernière entrée de modification qui existe pour cette ligne est considérée.

Remarque

Actuellement, les identités managées ne sont pas prises en charge pour les connexions entre Azure Functions et Azure Database pour MySQL.

D’autres exemples pour le déclencheur Azure Database pour MySQL sont disponibles dans le référentiel GitHub.

Les exemples font référence à une classe Product et à une table de base de données correspondante :

namespace AzureMySqlSamples.Common
{
    public class Product
    {
        public int? ProductId { get; set; }

        public string Name { get; set; }

        public int Cost { get; set; }

        public override bool Equals(object obj)
        {
            if (obj is Product)
            {
                var that = obj as Product;
                return this.ProductId == that.ProductId && this.Name == that.Name && this.Cost == that.Cost;
            }
            return false;
        }
    }

DROP TABLE IF EXISTS Products;

CREATE TABLE Products (
  ProductId int PRIMARY KEY,
  Name varchar(100) NULL,
  Cost int NULL
);

Vous activez le suivi des modifications sur la base de données en ajoutant une colonne à la table :

ALTER TABLE <table name>  
ADD COLUMN az_func_updated_at TIMESTAMP 
DEFAULT CURRENT_TIMESTAMP 
ON UPDATE CURRENT_TIMESTAMP;

Le déclencheur Azure Database pour MySQL est lié à IReadOnlyList<MySqlChange<T>>, qui répertorie les MySqlChange objets. Chaque objet a deux propriétés :

Item: élément qui a été modifié. Le type de l’élément doit suivre le schéma de table, comme indiqué dans la ToDoItem classe.
Operation: valeur de l’énumération MySqlChangeOperation . La valeur possible est Update à la fois pour les insertions et les mises à jour.

L’exemple suivant montre une fonction C# appelée lorsque des modifications se produisent dans la Product table :

using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Extensions.MySql;
using Microsoft.Extensions.Logging;
using AzureMySqlSamples.Common;

namespace AzureMySqlSamples.TriggerBindingSamples
{
        private static readonly Action<ILogger, string, Exception> _loggerMessage = LoggerMessage.Define<string>(LogLevel.Information, eventId: new EventId(0, "INFO"), formatString: "{Message}");

        [Function(nameof(ProductsTrigger))]
        public static void Run(
            [MySqlTrigger("Products", "MySqlConnectionString")]
            IReadOnlyList<MySqlChange<Product>> changes, FunctionContext context)
        {
            ILogger logger = context.GetLogger("ProductsTrigger");
            // The output is used to inspect the trigger binding parameter in test methods.
            foreach (MySqlChange<Product> change in changes)
            {
                Product product = change.Item;
                _loggerMessage(logger, $"Change operation: {change.Operation}", null);
                _loggerMessage(logger, $"Product Id: {product.ProductId}, Name: {product.Name}, Cost: {product.Cost}", null);
            }
        }
}

D’autres exemples pour le déclencheur Azure Database pour MySQL sont disponibles dans le référentiel GitHub.

Les exemples font référence à une classe Product et à une table de base de données correspondante :

namespace AzureMySqlSamples.Common
{
    public class Product
    {
        public int? ProductId { get; set; }

        public string Name { get; set; }

        public int Cost { get; set; }

        public override bool Equals(object obj)
        {
            if (obj is Product)
            {
                var that = obj as Product;
                return this.ProductId == that.ProductId && this.Name == that.Name && this.Cost == that.Cost;
            }
            return false;
        }
    }

DROP TABLE IF EXISTS Products;

CREATE TABLE Products (
  ProductId int PRIMARY KEY,
  Name varchar(100) NULL,
  Cost int NULL
);

Vous activez le suivi des modifications sur la base de données en ajoutant une colonne à la table :

ALTER TABLE <table name>  
ADD COLUMN az_func_updated_at TIMESTAMP 
DEFAULT CURRENT_TIMESTAMP 
ON UPDATE CURRENT_TIMESTAMP;

Le déclencheur Azure Database pour MySQL est lié à IReadOnlyList<MySqlChange<T>>, qui répertorie les MySqlChange objets. Chaque objet a deux propriétés :

Item: élément qui a été modifié. Le type de l’élément doit suivre le schéma de table, comme indiqué dans la Product classe.
Operation: valeur de l’énumération MySqlChangeOperation . La valeur possible est Update à la fois pour les insertions et les mises à jour.

L’exemple suivant montre une fonction C# appelée lorsque des modifications se produisent dans la Products table :

using System.Collections.Generic;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.MySql;
using Microsoft.Extensions.Logging; 
using AzureMySqlSamples.Common; 

namespace AzureMySqlSamples.TriggerBindingSamples
{
    public static class ProductsTrigger
    {
        [FunctionName(nameof(ProductsTrigger))]
        public static void Run(
            [MySqlTrigger("Products", "MySqlConnectionString")]
            IReadOnlyList<MySqlChange<Product>> changes,
            ILogger logger)
        {
            // The output is used to inspect the trigger binding parameter in test methods.
            foreach (MySqlChange<Product> change in changes)
            {
                Product product = change.Item;
                logger.LogInformation($"Change operation: {change.Operation}");
                logger.LogInformation($"Product Id: {product.ProductId}, Name: {product.Name}, Cost: {product.Cost}");
            }
        }
    }
}

Exemple d’utilisation

D’autres exemples pour le déclencheur Azure Database pour MySQL sont disponibles dans le référentiel GitHub.

L’exemple fait référence à une Product classe, une MySqlChangeProduct classe, une MySqlChangeOperation énumération et une table de base de données correspondante.

Dans un fichier distinct nommé Product.java :

package com.function.Common;

import com.fasterxml.jackson.annotation.JsonProperty;

public class Product {
    @JsonProperty("ProductId")
    private int ProductId;
    @JsonProperty("Name")
    private String Name;
    @JsonProperty("Cost")
    private int Cost;

    public Product() {
    }

    public Product(int productId, String name, int cost) {
        ProductId = productId;
        Name = name;
        Cost = cost;
    }
}

Dans un fichier distinct nommé MySqlChangeProduct.java :

package com.function.Common;

public class MySqlChangeProduct {
    private MySqlChangeOperation Operation;
    private Product Item;

    public MySqlChangeProduct() {
    }

    public MySqlChangeProduct(MySqlChangeOperation operation, Product item) {
        this.Operation = operation;
        this.Item = item;
    }
}

Dans un fichier distinct nommé MySqlChangeOperation.java :

package com.function.Common;

import com.google.gson.annotations.SerializedName;

public enum MySqlChangeOperation {
    @SerializedName("0")
    Update
}

DROP TABLE IF EXISTS Products;

CREATE TABLE Products (
  ProductId int PRIMARY KEY,
  Name varchar(100) NULL,
  Cost int NULL
);

Vous activez le suivi des modifications sur la base de données en ajoutant la colonne suivante à la table :

ALTER TABLE <table name>  
ADD COLUMN az_func_updated_at TIMESTAMP 
DEFAULT CURRENT_TIMESTAMP 
ON UPDATE CURRENT_TIMESTAMP;

Le déclencheur Azure Database pour MySQL est lié à MySqlChangeProduct[]un tableau d’objets MySqlChangeProduct . Chaque objet a deux propriétés :

item: élément qui a été modifié. Le type de l’élément doit suivre le schéma de table, comme indiqué dans la Product classe.
operation: valeur de l’énumération MySqlChangeOperation . La valeur possible est Update à la fois pour les insertions et les mises à jour.

L’exemple suivant montre une fonction Java appelée lorsque des modifications se produisent dans la Product table :

/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See License.txt in the project root for
 * license information.
 */

package com.function;

import com.microsoft.azure.functions.ExecutionContext;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.mysql.annotation.MySqlTrigger;
import com.function.Common.MySqlChangeProduct;
import com.google.gson.Gson;

import java.util.logging.Level;

public class ProductsTrigger {
    @FunctionName("ProductsTrigger")
    public void run(
            @MySqlTrigger(
                name = "changes",
                tableName = "Products",
                connectionStringSetting = "MySqlConnectionString")
                MySqlChangeProduct[] changes,
            ExecutionContext context) {

        context.getLogger().log(Level.INFO, "MySql Changes: " + new Gson().toJson(changes));
    }
}

Exemple d’utilisation

D’autres exemples pour le déclencheur Azure Database pour MySQL sont disponibles dans le référentiel GitHub.

L’exemple fait référence à une table de base de données Product :

DROP TABLE IF EXISTS Products;

CREATE TABLE Products (
  ProductId int PRIMARY KEY,
  Name varchar(100) NULL,
  Cost int NULL
);

Vous activez le suivi des modifications sur la base de données en ajoutant une colonne à la table :

ALTER TABLE <table name>  
ADD COLUMN az_func_updated_at TIMESTAMP 
DEFAULT CURRENT_TIMESTAMP 
ON UPDATE CURRENT_TIMESTAMP;

Le déclencheur Azure Database pour MySQL est lié à Product, qui répertorie les objets. Chaque objet a deux propriétés :

item: élément qui a été modifié. La structure de l’élément suit le schéma de table.
operation: la valeur possible est Update à la fois pour les insertions et les mises à jour.

L’exemple suivant montre une fonction PowerShell appelée lorsque des modifications se produisent dans la Product table.

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "bindings": [
      {
        "name": "changes",
        "type": "mysqlTrigger",
        "direction": "in",
        "tableName": "Products",
        "connectionStringSetting": "MySqlConnectionString"
      }
    ],
    "disabled": false
  }

La section Configuration décrit ces propriétés.

L’exemple suivant est un exemple de code PowerShell pour la fonction dans le fichier run.ps1 :

using namespace System.Net

param($changes)
# The output is used to inspect the trigger binding parameter in test methods.
# Use -Compress to remove new lines and spaces for testing purposes.
$changesJson = $changes | ConvertTo-Json -Compress
Write-Host "MySql Changes: $changesJson"

Exemple d’utilisation

D’autres exemples pour le déclencheur Azure Database pour MySQL sont disponibles dans le référentiel GitHub.

L’exemple fait référence à une table de base de données Product :

DROP TABLE IF EXISTS Products;

CREATE TABLE Products (
  ProductId int PRIMARY KEY,
  Name varchar(100) NULL,
  Cost int NULL
);

Vous activez le suivi des modifications sur la base de données en ajoutant une colonne à la table :

ALTER TABLE <table name>  
ADD COLUMN az_func_updated_at TIMESTAMP 
DEFAULT CURRENT_TIMESTAMP 
ON UPDATE CURRENT_TIMESTAMP;

Le déclencheur Azure Database pour MySQL est lié à Changesun tableau d’objets. Chaque objet a deux propriétés :

item: élément qui a été modifié. La structure de l’élément suit le schéma de table.
operation: la valeur possible est Update à la fois pour les insertions et les mises à jour.

L’exemple suivant montre une fonction JavaScript appelée lorsque des modifications se produisent dans la Product table.

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "bindings": [
      {
        "name": "changes",
        "type": "mysqlTrigger",
        "direction": "in",
        "tableName": "Products",
        "connectionStringSetting": "MySqlConnectionString",
      }
    ],
    "disabled": false
  }

La section Configuration décrit ces propriétés.

L’exemple suivant est un exemple de code JavaScript pour la fonction dans le index.js fichier :

module.exports = async function (context, changes) {
    context.log(`MySql Changes: ${JSON.stringify(changes)}`)
}

Exemple d’utilisation

D’autres exemples pour le déclencheur Azure Database pour MySQL sont disponibles dans le référentiel GitHub.

L’exemple fait référence à une table de base de données Product :

DROP TABLE IF EXISTS Products;

CREATE TABLE Products (
  ProductId int PRIMARY KEY,
  Name varchar(100) NULL,
  Cost int NULL
);

Vous activez le suivi des modifications sur la base de données en ajoutant une colonne à la table :

ALTER TABLE <table name>  
ADD COLUMN az_func_updated_at TIMESTAMP 
DEFAULT CURRENT_TIMESTAMP 
ON UPDATE CURRENT_TIMESTAMP;

Remarque

Vous devez utiliser Azure Functions version 1.22.0b4 pour Python.

Le déclencheur Azure Database pour MySQL est lié à une variable nommée Product, qui répertorie les objets. Chaque objet a deux propriétés :

item: élément qui a été modifié. La structure de l’élément suit le schéma de table.
operation: la valeur possible est Update à la fois pour les insertions et les mises à jour.

L’exemple suivant montre une fonction Python appelée lorsque des modifications se produisent dans la Product table.

L’exemple suivant est un exemple de code Python pour le fichier function_app.py :

import json
import logging
import azure.functions as func

app = func.FunctionApp()

# The function is triggered when a change (insert, update)
# is made to the Products table.
@app.function_name(name="ProductsTrigger")
@app.mysql_trigger(arg_name="products",
table_name="Products",
connection_string_setting="MySqlConnectionString")

def products_trigger(products: str) -> None:
logging.info("MySQL Changes: %s", json.loads(products))

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "bindings": [
      {
        "name": "changes",
        "type": "mysqlTrigger",
        "direction": "in",
        "tableName": "Products",
        "connectionStringSetting": "MySqlConnectionString"
      }
    ],
    "disabled": false
  }

La section Configuration décrit ces propriétés.

L’exemple suivant est un exemple de code Python pour la fonction dans le fichier init.py :

import json
import logging

def main(changes):
    logging.info("MySql Changes: %s", json.loads(changes))

Attributs

Propriété d’attribut	Descriptif
`TableName`	Obligatoire. Nom de la table que le déclencheur surveille.
`ConnectionStringSetting`	Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données qui contient la table surveillée pour les modifications. Le nom du paramètre de chaîne de connexion correspond au paramètre d’application (dans local.settings.json pour le développement local) qui contient la chaîne de connexion à Azure Database pour MySQL.
`LeasesTableName`	Optionnel. Nom de la table pour le stockage des baux. S’il n’est pas spécifié, le nom est `Leases_{FunctionId}_{TableId}`.

Commentaires

Dans la bibliothèque d’exécution de fonctions Java, utilisez l’annotation sur les paramètres dont les @MySQLTrigger valeurs proviennent d’Azure Database pour MySQL. Cette annotation prend en charge les éléments suivants :

Élément	Descriptif
`name`	Obligatoire. Nom du paramètre auquel le déclencheur est lié.
`tableName`	Obligatoire. Nom de la table que le déclencheur surveille.
`connectionStringSetting`	Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données qui contient la table surveillée pour les modifications. Le nom du paramètre de chaîne de connexion correspond au paramètre d’application (dans local.settings.json pour le développement local) qui contient la chaîne de connexion à Azure Database pour MySQL.
`LeasesTableName`	Optionnel. Nom de la table pour le stockage des baux. S’il n’est pas spécifié, le nom est `Leases_{FunctionId}_{TableId}`.

Paramétrage

Le tableau suivant décrit les propriétés de configuration de liaison que vous avez définies dans le fichier function.json :

Propriété	Descriptif
`name`	Obligatoire. Nom du paramètre auquel le déclencheur est lié.
`type`	Obligatoire. Cette propriété doit être définie sur `MysqlTrigger`.
`direction`	Obligatoire. Cette propriété doit être définie sur `in`.
`tableName`	Obligatoire. Nom de la table que le déclencheur surveille.
`connectionStringSetting`	Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données qui contient la table surveillée pour les modifications. Le nom du paramètre de chaîne de connexion correspond au paramètre d’application (dans local.settings.json pour le développement local) qui contient la chaîne de connexion à Azure Database pour MySQL.
`LeasesTableName`	Optionnel. Nom de la table pour le stockage des baux. S’il n’est pas spécifié, le nom est `Leases_{FunctionId}_{TableId}`.

Configuration facultative

Vous pouvez configurer les paramètres facultatifs suivants pour le déclencheur Azure Database pour MySQL pour le développement local ou pour les déploiements cloud.

host.json

Cette section décrit les paramètres de configuration disponibles pour cette liaison dans la version 2.x et les versions ultérieures. Les paramètres dans le fichier host.json s’appliquent à toutes les fonctions dans une instance de l’application de fonction. Pour plus d’informations sur les paramètres de configuration des applications de fonction, consultez host.json référence pour Azure Functions.

Réglage	Par défaut	Descriptif
`MaxBatchSize`	`100`	Nombre maximal de modifications traitées avec chaque itération de la boucle de déclencheur avant qu’elles ne soient envoyées à la fonction déclenchée.
`PollingIntervalMs`	`1000`	Délai en millisecondes entre le traitement de chaque lot de changements. (1 000 ms est de 1 seconde.)
`MaxChangesPerWorker`	`1000`	Limite supérieure du nombre de modifications en attente dans la table utilisateur autorisées par worker d’application. Si le nombre de modifications dépasse cette limite, cela peut entraîner un scale-out. Le paramètre s’applique uniquement aux applications de fonction Azure avec la mise à l’échelle pilotée par le runtime activée.

Exemple de fichier host.json

Voici un exemple de fichier host.json avec les paramètres facultatifs :

{
  "version": "2.0",
  "extensions": {
      "MySql": {
        "MaxBatchSize": 300,
        "PollingIntervalMs": 1000,
        "MaxChangesPerWorker": 100
      }
  },
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    },
    "logLevel": {
      "default": "Trace"
    }
  }
}

local.setting.json

Le fichier local.settings.json stocke les paramètres d’application et les paramètres utilisés par les outils de développement locaux. Les paramètres dans le fichier local.settings.json sont uniquement utilisés lorsque vous exécutez votre projet localement. Lorsque vous publiez votre projet sur Azure, veillez également à ajouter tous les paramètres requis aux paramètres de l’application pour l’application de fonction.

Important

Étant donné que le fichier local.settings.json peut contenir des secrets, tels que des chaînes de connexion, vous ne devez jamais le stocker dans un référentiel distant. Les outils qui prennent en charge Azure Functions permettent de synchroniser les paramètres dans le fichier local.settings.json avec les paramètres d’application dans l’application de fonction sur laquelle votre projet est déployé.

Réglage	Par défaut	Descriptif
`MySql_Trigger_BatchSize`	`100`	Nombre maximal de modifications traitées avec chaque itération de la boucle de déclencheur avant qu’elles ne soient envoyées à la fonction déclenchée.
`MySql_Trigger_PollingIntervalMs`	`1000`	Délai en millisecondes entre le traitement de chaque lot de changements. (1 000 ms est de 1 seconde.)
`MySql_Trigger_MaxChangesPerWorker`	`1000`	Limite supérieure du nombre de modifications en attente dans la table utilisateur autorisées par worker d’application. Si le nombre de modifications dépasse cette limite, cela peut entraîner un scale-out. Le paramètre s’applique uniquement aux applications de fonction Azure avec la mise à l’échelle pilotée par le runtime activée.

Exemple de fichier local.settings.json

Voici un exemple de fichier local.settings.json avec les paramètres facultatifs :

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "dotnet",
    "MySqlConnectionString": "",
    "MySql_Trigger_MaxBatchSize": 300,
    "MySql_Trigger_PollingIntervalMs": 1000,
    "MySql_Trigger_MaxChangesPerWorker": 100
  }
}

Configurer le suivi des changements (obligatoire)

La configuration du suivi des modifications à utiliser avec le déclencheur Azure Database pour MySQL nécessite l’ajout d’une colonne dans une table à l’aide d’une fonction. Vous pouvez effectuer ces étapes à partir de n’importe quel outil MySQL qui prend en charge l’exécution de requêtes, notamment Visual Studio Code ou Azure Data Studio.

ALTER TABLE Products;
ADD az_func_updated_at 
TIMESTAMP DEFAULT CURRENT_TIMESTAMP 
ON UPDATE CURRENT_TIMESTAMP;

La table des baux contient toutes les colonnes qui correspondent à la clé primaire de la table utilisateur et deux colonnes supplémentaires : az_func_AttemptCount et az_func_LeaseExpirationTime. Si l’une des colonnes de clé primaire porte le même nom, le résultat est un message d’erreur qui répertorie les conflits. Dans ce cas, les colonnes de clé primaire répertoriées doivent être renommées pour que le déclencheur fonctionne.

Activer la mise à l’échelle pilotée par le runtime

Éventuellement, vos fonctions peuvent être mises à l’échelle automatiquement en fonction du nombre de modifications en attente de traitement dans la table utilisateur. Pour permettre à vos fonctions de s’adapter correctement au plan Premium lorsque vous utilisez des déclencheurs Azure Database pour MySQL, vous devez activer la supervision de l’échelle du runtime.

portail Azure
Azure CLI

Dans le portail Azure, dans votre application de fonction, sélectionnez Configuration.
Sous l’onglet Paramètres du runtime de fonction , pour l’analyse de l’échelle du runtime, sélectionnez Activé.

Utilisez la commande Azure CLI suivante pour activer la surveillance de l’échelle du runtime :

az resource update -g <RESOURCE_GROUP> -n <FUNCTION_APP_NAME>/config/web --set properties.functionsRuntimeScaleMonitoringEnabled=1 --resource-type Microsoft.Web/sites

Prise en charge des nouvelles tentatives

Nouvelles tentatives de démarrage

Si une exception se produit au démarrage, le runtime hôte tente automatiquement de redémarrer l’écouteur de déclencheur avec une stratégie d’interruption exponentielle. Ces nouvelles tentatives se poursuivent jusqu’à ce que l’écouteur soit correctement démarré ou que le démarrage soit annulé.

Nouvelles tentatives d’exception de fonction

Si une exception se produit dans la fonction utilisateur pendant le traitement des modifications, le lot de lignes en cours de traitement est retenté en 60 secondes. D’autres modifications sont traitées normalement pendant cette période, mais les lignes du lot à l’origine de l’exception sont ignorées jusqu’à ce que le délai d’attente s’écoule.

Si l’exécution de la fonction échoue cinq fois consécutives pour une ligne particulière, cette ligne est ignorée pour toutes les modifications futures. Étant donné que les lignes d’un lot ne sont pas déterministes, les lignes d’un lot ayant échoué peuvent se retrouver dans des lots différents dans les appels suivants. Ce comportement signifie que toutes les lignes du lot ayant échoué ne sont pas nécessairement ignorées. Si d’autres lignes du lot ont provoqué l’exception, les lignes « bonnes » peuvent se retrouver dans un autre lot qui ne échoue pas dans les appels futurs.

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-10-03

Partager via

Liaison de déclencheur Azure Database pour MySQL pour Azure Functions

Vue d’ensemble des fonctionnalités

Exemple d’utilisation

Exemple d’utilisation

Exemple d’utilisation

Exemple d’utilisation

Exemple d’utilisation

Attributs

Commentaires

Paramétrage

Configuration facultative

host.json

Exemple de fichier host.json

local.setting.json

Exemple de fichier local.settings.json

Configurer le suivi des changements (obligatoire)

Activer la mise à l’échelle pilotée par le runtime

Prise en charge des nouvelles tentatives

Nouvelles tentatives de démarrage

Nouvelles tentatives d’exception de fonction

Contenu connexe

Rétroaction

Ressources additionnelles