Azure Database for MySQL-eseményindító kötése az Azure Functionshez

Az Azure Database for MySQL triggerkötései figyelik a felhasználói táblát a módosítások (beszúrások és frissítések) után, és frissített soradatokkal meghívják a függvényt.

Az Azure Database for MySQL-eseményindító kötései és oszlopadatai a felhasználói tábla változásainak figyelésére használhatók az_func_updated_at . Ezért módosítania kell a táblastruktúrát, hogy lehetővé tegye a változáskövetést a MySQL-táblán az eseményindító támogatásának használata előtt. A tábla változáskövetését az alábbi lekérdezéssel engedélyezheti. Engedélyezze például a Products táblában:

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

A bérletek táblája tartalmazza a felhasználói tábla elsődleges kulcsának megfelelő összes oszlopot, valamint további három oszlopot: az_func_AttemptCount, az_func_LeaseExpirationTimeés az_func_SyncCompletedTime. Ha az elsődleges kulcsoszlopok bármelyikének ugyanaz a neve, az eredmény egy ütközéseket listázó hibaüzenet. Ebben az esetben a felsorolt elsődleges kulcsoszlopokat át kell nevezni az eseményindító működéséhez.

A funkciók áttekintése

Az eseményindító függvény indításakor két különálló ciklust indít el: a változás lekérdezési ciklusát és a bérlet megújítási ciklusát. Ezek a hurkok folyamatosan futnak, amíg a függvény le nem áll.

Az Azure Database for MySQL-eseményindító kötése a lekérdezési ciklus használatával ellenőrzi a módosításokat. A lekérdezési ciklus aktiválja a felhasználói függvényt, amikor változásokat észlel. Magas szinten a hurok az alábbi példához hasonlóan néz ki:

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
}

A módosítások feldolgozása a végrehajtott sorrendben történik. A rendszer először a legrégebbi módosításokat dolgozza fel. Fontolja meg az alábbi szempontokat a változásfeldolgozással kapcsolatban:

• Ha a módosítások egyszerre több sorban történnek, a függvénynek küldött pontos sorrend az oszlop és az az_func_updated_at elsődleges kulcsoszlopok növekvő sorrendjén alapul.
• A módosítások kötegelve vannak egy sorhoz. Ha a ciklus egyes iterációi között több módosítás is történik, a rendszer csak az adott sorhoz tartozó legújabb módosítási bejegyzést veszi figyelembe.

Feljegyzés

A felügyelt identitások jelenleg nem támogatottak az Azure Functions és az Azure Database for MySQL közötti kapcsolatokhoz.

Példa használatra

Izolált feldolgozói modell

Az Azure Database for MySQL-eseményindítóhoz további minták érhetők el a GitHub-adattárban.

A példa egy Product osztályra és egy megfelelő adatbázistáblára hivatkozik:

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

A változáskövetést úgy engedélyezheti az adatbázisban, hogy egy oszlopot ad hozzá a táblához:

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

Az Azure Database for MySQL-eseményindító az objektumokat IReadOnlyList<MySqlChange<T>>listázóhoz MySqlChange kapcsolódik. Mindegyik objektum két tulajdonsággal rendelkezik:

• Item: A módosított elem. Az elem típusának a táblázat sémáját kell követnie, ahogy az az ToDoItem osztályban látható.
• Operation: Az enumerálásból származó MySqlChangeOperation érték. A lehetséges érték mind a beszúrások, mind a Update frissítések esetében.

Az alábbi példa egy C#-függvényt mutat be, amely akkor lesz meghívva, amikor változások történnek a Product táblában:

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

Folyamaton belüli modell

Az Azure Database for MySQL-eseményindítóhoz további minták érhetők el a GitHub-adattárban.

A példa egy Product osztályra és egy megfelelő adatbázistáblára hivatkozik:

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

A változáskövetést úgy engedélyezheti az adatbázisban, hogy egy oszlopot ad hozzá a táblához:

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

Az Azure Database for MySQL-eseményindító az objektumokat IReadOnlyList<MySqlChange<T>>listázóhoz MySqlChange kapcsolódik. Mindegyik objektum két tulajdonsággal rendelkezik:

• Item: A módosított elem. Az elem típusának a táblázat sémáját kell követnie, ahogy az az Product osztályban látható.
• Operation: Az enumerálásból származó MySqlChangeOperation érték. A lehetséges érték mind a beszúrások, mind a Update frissítések esetében.

Az alábbi példa egy C#-függvényt mutat be, amely akkor lesz meghívva, amikor változások történnek a Products táblában:

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

Példa használatra

Az Azure Database for MySQL-eseményindítóhoz további minták érhetők el a GitHub-adattárban.

A példa egy Product osztályra, egy osztályra MySqlChangeProduct , egy enumerálásra MySqlChangeOperation és egy megfelelő adatbázistáblára hivatkozik.

Egy Product.java nevű külön fájlban:

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

Egy MySqlChangeProduct.java nevű külön fájlban:

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

Egy MySqlChangeOperation.java nevű külön fájlban:

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

A változáskövetést úgy engedélyezheti az adatbázisban, hogy hozzáadja a következő oszlopot a táblához:

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

Az Azure Database for MySQL-eseményindító objektumtömbhöz MySqlChangeProduct[] kapcsolódikMySqlChangeProduct. Mindegyik objektum két tulajdonsággal rendelkezik:

• item: A módosított elem. Az elem típusának a táblázat sémáját kell követnie, ahogy az az Product osztályban látható.
• operation: Az enumerálásból származó MySqlChangeOperation érték. A lehetséges érték mind a beszúrások, mind a Update frissítések esetében.

Az alábbi példa egy Java-függvényt mutat be, amely akkor lesz meghívva, amikor változások történnek a Product táblában:

/**
 * 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));
    }
}

Példa használatra

Az Azure Database for MySQL-eseményindítóhoz további minták érhetők el a GitHub-adattárban.

A példa egy Product adatbázistáblára hivatkozik:

DROP TABLE IF EXISTS Products;

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

A változáskövetést úgy engedélyezheti az adatbázisban, hogy egy oszlopot ad hozzá a táblához:

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

Az Azure Database for MySQL-eseményindító az objektumokat Productlistázóhoz kapcsolódik. Mindegyik objektum két tulajdonsággal rendelkezik:

• item: A módosított elem. Az elem struktúrája a táblázatsémát követi.
• operation: A lehetséges érték mind a beszúrások, mind a Update frissítések esetében.

Az alábbi példa egy PowerShell-függvényt mutat be, amely akkor lesz meghívva, amikor változások történnek a Product táblában.

A következő példa a kötési adatok a function.json fájlban:

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

A Konfiguráció szakasz ezeket a tulajdonságokat ismerteti.

Az alábbi példa a run.ps1 fájlban található függvény PowerShell-kódjának mintája:

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"

Példa használatra

Az Azure Database for MySQL-eseményindítóhoz további minták érhetők el a GitHub-adattárban.

A példa egy Product adatbázistáblára hivatkozik:

DROP TABLE IF EXISTS Products;

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

A változáskövetést úgy engedélyezheti az adatbázisban, hogy egy oszlopot ad hozzá a táblához:

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

Az Azure Database for MySQL-eseményindító objektumtömbhöz kapcsolódik Changes. Mindegyik objektum két tulajdonsággal rendelkezik:

• item: A módosított elem. Az elem struktúrája a táblázatsémát követi.
• operation: A lehetséges érték mind a beszúrások, mind a Update frissítések esetében.

Az alábbi példa egy JavaScript-függvényt mutat be, amely akkor lesz meghívva, amikor változások történnek a Product táblában.

A következő példa a kötési adatok a function.json fájlban:

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

A Konfiguráció szakasz ezeket a tulajdonságokat ismerteti.

Az alábbi példa a fájlban lévő index.js függvényhez tartozó JavaScript-mintakód:

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

Példa használatra

Az Azure Database for MySQL-eseményindítóhoz további minták érhetők el a GitHub-adattárban.

A példa egy Product adatbázistáblára hivatkozik:

DROP TABLE IF EXISTS Products;

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

A változáskövetést úgy engedélyezheti az adatbázisban, hogy egy oszlopot ad hozzá a táblához:

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

Feljegyzés

A Pythonhoz az Azure Functions 1.22.0b4-es verzióját kell használnia.

Az Azure Database for MySQL-eseményindító egy objektumokat listázó nevű változóhoz Productkapcsolódik. Mindegyik objektum két tulajdonsággal rendelkezik:

• item: A módosított elem. Az elem struktúrája a táblázatsémát követi.
• operation: A lehetséges érték mind a beszúrások, mind a Update frissítések esetében.

Az alábbi példa egy Python-függvényt mutat be, amely akkor lesz meghívva, amikor változások történnek a Product táblában.

v2

Az alábbi példa a function_app.py fájlhoz tartozó Python-mintakód:

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

v1

A következő példa a kötési adatok a function.json fájlban:

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

A Konfiguráció szakasz ezeket a tulajdonságokat ismerteti.

Az alábbi példa a init.py fájlban lévő függvényhez tartozó Python-mintakód:

import json
import logging

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

Attribútumok

Attribútumtulajdonság	Leírás
TableName	Szükséges. Annak a táblának a neve, amelyet az eseményindító figyel.
ConnectionStringSetting	Szükséges. Annak az alkalmazásbeállításnak a neve, amely a módosításokat figyelő táblát tartalmazó adatbázis kapcsolati sztringét tartalmazza. A kapcsolati sztring-beállítás neve megegyezik az Azure Database for MySQL-hez tartozó kapcsolati sztringet tartalmazó alkalmazásbeállítással (a helyi fejlesztéshez local.settings.json).
LeasesTableName	Opcionális. A bérletek tárolására szolgáló tábla neve. Ha nincs megadva, a név .Leases_{FunctionId}_{TableId}

Jegyzetek

A Java-függvények futtatókörnyezeti kódtárában használja a széljegyzetet azon @MySQLTrigger paramétereken, amelyek értékei az Azure Database for MySQL-ből származnának. Ez a széljegyzet a következő elemeket támogatja:

Elem	Leírás
name	Szükséges. Annak a paraméternek a neve, amelyhez az eseményindító kapcsolódik.
tableName	Szükséges. Annak a táblának a neve, amelyet az eseményindító figyel.
connectionStringSetting	Szükséges. Annak az alkalmazásbeállításnak a neve, amely a módosításokat figyelő táblát tartalmazó adatbázis kapcsolati sztringét tartalmazza. A kapcsolati sztring-beállítás neve megegyezik az Azure Database for MySQL-hez tartozó kapcsolati sztringet tartalmazó alkalmazásbeállítással (a helyi fejlesztéshez local.settings.json).
LeasesTableName	Opcionális. A bérletek tárolására szolgáló tábla neve. Ha nincs megadva, a név .Leases_{FunctionId}_{TableId}

Konfiguráció

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti:

Ingatlan	Leírás
name	Szükséges. Annak a paraméternek a neve, amelyhez az eseményindító kapcsolódik.
type	Szükséges. A beállításnak a MysqlTriggerkövetkezőnek kell lennie: .
direction	Szükséges. A beállításnak a inkövetkezőnek kell lennie: .
tableName	Szükséges. Annak a táblának a neve, amelyet az eseményindító figyel.
connectionStringSetting	Szükséges. Annak az alkalmazásbeállításnak a neve, amely a módosításokat figyelő táblát tartalmazó adatbázis kapcsolati sztringét tartalmazza. A kapcsolati sztring-beállítás neve megegyezik az Azure Database for MySQL-hez tartozó kapcsolati sztringet tartalmazó alkalmazásbeállítással (a helyi fejlesztéshez local.settings.json).
LeasesTableName	Opcionális. A bérletek tárolására szolgáló tábla neve. Ha nincs megadva, a név .Leases_{FunctionId}_{TableId}

Választható konfiguráció

A következő választható beállításokat konfigurálhatja az Azure Database for MySQL-eseményindítóhoz helyi fejlesztéshez vagy felhőbeli üzemelő példányokhoz.

host.json

Ez a szakasz a kötéshez elérhető konfigurációs beállításokat ismerteti a 2.x és újabb verzióban. A host.json fájl beállításai a függvényalkalmazás-példány összes függvényére vonatkoznak. A függvényalkalmazás konfigurációs beállításaival kapcsolatos további információkért lásd host.json Azure Functionsre vonatkozó referenciát.

Beállítás	Alapértelmezett	Leírás
MaxBatchSize	100	Az eseményindító ciklus minden iterációjával feldolgozott módosítások maximális száma, mielőtt elküldené őket az aktivált függvénynek.
PollingIntervalMs	1000	A módosítások egyes kötegeinek feldolgozása közötti ezredmásodpercben bekövetkező késés. (1000 ms 1 másodperc.)
MaxChangesPerWorker	1000	Az alkalmazás-feldolgozónként engedélyezett függőben lévő módosítások számának felső korlátja a felhasználói táblában. Ha a módosítások száma meghaladja ezt a korlátot, az vertikális felskálázást eredményezhet. A beállítás csak olyan Azure-függvényalkalmazásokra vonatkozik, amelyekben engedélyezve van a futásidejű skálázás.

Példa host.json fájlra

Íme egy példa host.json fájlra az opcionális beállításokkal:

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

local.setting.json

A local.settings.json fájl tárolja a helyi fejlesztési eszközök által használt alkalmazásbeállításokat és beállításokat. A local.settings.json fájl beállításait csak akkor használja a rendszer, ha helyileg futtatja a projektet. Amikor közzéteszi a projektet az Azure-ban, mindenképpen adja hozzá a szükséges beállításokat a függvényalkalmazás alkalmazásbeállításaihoz.

Fontos

Mivel a local.settings.json fájl titkos kódokat, például kapcsolati sztringeket tartalmazhat, soha ne tárolja távoli adattárban. Az Azure Functionst támogató eszközök lehetővé teszik a local.settings.json fájl beállításainak szinkronizálását abban a függvényalkalmazásban, amelyre a projektet üzembe helyezték.

Beállítás	Alapértelmezett	Leírás
MySql_Trigger_BatchSize	100	Az eseményindító ciklus minden iterációjával feldolgozott módosítások maximális száma, mielőtt elküldené őket az aktivált függvénynek.
MySql_Trigger_PollingIntervalMs	1000	A módosítások egyes kötegeinek feldolgozása közötti ezredmásodpercben bekövetkező késés. (1000 ms 1 másodperc.)
MySql_Trigger_MaxChangesPerWorker	1000	Az alkalmazás-feldolgozónként engedélyezett függőben lévő módosítások számának felső korlátja a felhasználói táblában. Ha a módosítások száma meghaladja ezt a korlátot, az vertikális felskálázást eredményezhet. A beállítás csak olyan Azure-függvényalkalmazásokra vonatkozik, amelyekben engedélyezve van a futásidejű skálázás.

Példa local.settings.json fájlra

Íme egy példa local.settings.json fájlra az opcionális beállításokkal:

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

Változáskövetés beállítása (kötelező)

Az Azure Database for MySQL-eseményindítóval való használatra történő változáskövetés beállításához egy oszlopot kell hozzáadnia egy táblához egy függvény használatával. Ezeket a lépéseket bármely olyan MySQL-eszközből elvégezheti, amely támogatja a lekérdezések futtatását, beleértve a Visual Studio Code-ot vagy az Azure Data Studiót.

Az Azure Database for MySQL-eseményindító kötései és oszlopadatai a felhasználói tábla változásainak figyelésére használhatók az_func_updated_at . Ezért módosítania kell a táblastruktúrát, hogy lehetővé tegye a változáskövetést a MySQL-táblán az eseményindító támogatásának használata előtt. A tábla változáskövetését az alábbi lekérdezéssel engedélyezheti. Engedélyezze például a Products táblában:

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

A bérletek táblája tartalmazza a felhasználói tábla elsődleges kulcsának megfelelő összes oszlopot, valamint két további oszlopot: az_func_AttemptCount és az_func_LeaseExpirationTime. Ha az elsődleges kulcsoszlopok bármelyikének ugyanaz a neve, az eredmény egy ütközéseket listázó hibaüzenet. Ebben az esetben a felsorolt elsődleges kulcsoszlopokat át kell nevezni az eseményindító működéséhez.

Futtatókörnyezet-alapú skálázás engedélyezése

Opcionálisan a függvények automatikusan skálázhatók a felhasználói táblában feldolgozandó módosítások száma alapján. Ahhoz, hogy a függvények megfelelően skálázhatók legyenek a Prémium csomagban az Azure Database for MySQL-eseményindítók használatakor, engedélyeznie kell a futtatókörnyezeti skálázás monitorozását.

Azure Portal

1. Az Azure Portal függvényalkalmazásában válassza a Konfiguráció lehetőséget.

2. A Függvény futtatókörnyezet beállításai lapon válassza a Futtatókörnyezet skálázásának monitorozásalehetőséget.

   

Azure CLI

A futtatókörnyezeti skálázás monitorozásának engedélyezéséhez használja a következő Azure CLI-parancsot:

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

Újrapróbálkozás támogatása

Újrapróbálkozás indítása

Ha az indítás során kivétel történik, a gazdagép futtatókörnyezete automatikusan megkísérli újraindítani az eseményindító-figyelőt exponenciális háttérstratégiával. Ezek az újrapróbálkozások mindaddig folytatódnak, amíg a figyelő sikeresen el nem indul, vagy az indítás megszakad.

Függvénykivétel újrapróbálkozásai

Ha a módosítás feldolgozása során kivétel történik a felhasználói függvényben, a jelenleg feldolgozott sorok kötegét 60 másodperc múlva újrapróbálja a rendszer. Ez idő alatt a többi módosítás a szokásos módon lesz feldolgozva, de a kivételt okozó köteg sorait a rendszer figyelmen kívül hagyja mindaddig, amíg az időtúllépési időszak el nem telik.

Ha egy adott sor esetében a függvény végrehajtása öt egymást követő alkalommal meghiúsul, a rendszer figyelmen kívül hagyja ezt a sort az összes jövőbeli módosításnál. Mivel a köteg sorai nem determinisztikusak, előfordulhat, hogy egy sikertelen köteg sorai különböző kötegekben végződnek a későbbi meghívásokban. Ez a viselkedés azt jelenti, hogy a sikertelen köteg nem minden sorát hagyja figyelmen kívül. Ha a köteg többi sora okozta a kivételt, előfordulhat, hogy a "jó" sorok egy másik kötegbe kerülnek, amely a jövőbeni meghívások során nem hiúsul meg.

Kapcsolódó tartalom

• Adatok beolvasása adatbázisból (bemeneti kötés)
• Adatok mentése adatbázisba (kimeneti kötés)