Freigeben über

Azure-Datenbank für MySQL-Ausgabebindung für Azure Functions

Sie können die Azure-Datenbank für MySQL-Ausgabebindung verwenden, um in eine Datenbank zu schreiben.

Informationen zur Einrichtung und Konfiguration finden Sie in der Übersicht.

Wichtig

In diesem Artikel werden Registerkarten verwendet, um mehrere Versionen des Node.js-Programmiermodells zu unterstützen. Das v4-Modell ist allgemein verfügbar und bietet JavaScript- und TypeScript-Entwicklern eine flexiblere und intuitivere Erfahrung. Weitere Informationen zur Funktionsweise des v4-Modells finden Sie im Azure Functions Node.js-Entwicklerhandbuch. Weitere Informationen zu den Unterschieden zwischen v3 und v4 finden Sie im Migrationshandbuch.

Beispiele

Sie können eine C#-Funktion mit einem der folgenden C#-Modi erstellen:

  • Isoliertes Workermodell: Kompilierte C#-Funktion, die in einem Workerprozess ausgeführt wird, der von der Runtime isoliert ist. Ein isolierter Arbeitsprozess ist erforderlich, um C#-Funktionen zu unterstützen, die auf long-term support (LTS) und nicht-LTS-Versionen für .NET und .NET Framework ausgeführt werden.
  • In-Process-Modell: Kompilierte C#-Funktion, die im gleichen Prozess wie die Azure Functions-Laufzeit ausgeführt wird.
  • C#-Skript: Wird hauptsächlich beim Erstellen von C#-Funktionen im Azure-Portal verwendet.

Wichtig

Die Unterstützung für das In-Process-Modell endet am 10. November 2026. Es wird dringend empfohlen, Ihre Apps zum isolierten Workermodell zu migrieren, um den vollständigen Support zu ermöglichen.

Weitere Beispiele für die Azure-Datenbank für MySQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält das folgende Beispiel:

Das Beispiel bezieht sich auf eine Product-Klasse und eine entsprechende Datenbanktabelle:

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

DROP TABLE IF EXISTS Products;

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

HTTP-Trigger: Schreiben eines Datensatzes

Das folgende Beispiel zeigt eine C#-Funktion , die einer Datenbank einen Datensatz hinzufügt, indem Daten verwendet werden, die in einer HTTP-Anforderung POST als JSON-Text bereitgestellt werden.

using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Extensions.MySql;
using Microsoft.Azure.Functions.Worker.Http;
using AzureMySqlSamples.Common;

namespace AzureMySqlSamples.OutputBindingSamples
{
    public static class AddProduct
    {
        [FunctionName(nameof(AddProduct))]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "addproduct")]
            [FromBody] Product prod,
            [MySql("Products", "MySqlConnectionString")] out Product product)
        {
            product = prod;
            return new CreatedResult($"/api/addproduct", product);
        }
    }
}

Weitere Beispiele für die Azure-Datenbank für MySQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält das folgende Beispiel:

Das Beispiel bezieht sich auf eine Product-Klasse und eine entsprechende Datenbanktabelle:

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

DROP TABLE IF EXISTS Products;

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

HTTP-Trigger: Schreiben eines Datensatzes in eine Tabelle

Das folgende Beispiel zeigt eine Azure-Datenbank für MySQL-Ausgabebindung in einer Java-Funktion, die einer Tabelle einen Datensatz hinzufügt, indem Daten verwendet werden, die in einer HTTP-Anforderung POST als JSON-Text bereitgestellt werden. Die Funktion verwendet eine zusätzliche Abhängigkeit von der com.google.code.gson-Bibliothek , um den JSON-Text zu analysieren.

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

package com.function;

import com.microsoft.azure.functions.HttpMethod;
import com.microsoft.azure.functions.HttpRequestMessage;
import com.microsoft.azure.functions.HttpResponseMessage;
import com.microsoft.azure.functions.HttpStatus;
import com.microsoft.azure.functions.OutputBinding;
import com.microsoft.azure.functions.annotation.AuthorizationLevel;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.annotation.HttpTrigger;
import com.microsoft.azure.functions.mysql.annotation.MySqlOutput;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.function.Common.Product;

import java.io.IOException;
import java.util.Optional;

public class AddProduct {
    @FunctionName("AddProduct")
    public HttpResponseMessage run(
            @HttpTrigger(
                name = "req",
                methods = {HttpMethod.POST},
                authLevel = AuthorizationLevel.ANONYMOUS,
                route = "addproduct")
                HttpRequestMessage<Optional<String>> request,
            @MySqlOutput(
                name = "product",
                commandText = "Products",
                connectionStringSetting = "MySqlConnectionString")
                OutputBinding<Product> product) throws JsonParseException, JsonMappingException, IOException {

        String json = request.getBody().get();
        ObjectMapper mapper = new ObjectMapper();
        Product p = mapper.readValue(json, Product.class);
        product.setValue(p);

        return request.createResponseBuilder(HttpStatus.OK).header("Content-Type", "application/json").body(product).build();
    }
}

Weitere Beispiele für die Azure-Datenbank für MySQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält das folgende Beispiel:

Das Beispiel bezieht sich auf eine Datenbanktabelle:

DROP TABLE IF EXISTS Products;

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

HTTP-Trigger: Schreiben von Datensätzen in eine Tabelle

Das folgende Beispiel zeigt eine Azure-Datenbank für MySQL-Ausgabebindung, die einer Tabelle Datensätze hinzufügt, indem Daten verwendet werden, die in einer HTTP-Anforderung POST als JSON-Text bereitgestellt werden.

const { app, output } = require('@azure/functions');

const mysqlOutput = output.generic({
    type: 'mysql',
    commandText: 'Products',
    connectionStringSetting: 'MySqlConnectionString'
})

// Upsert the product, which will insert it into the Products table if the primary key (ProductId) for that item doesn't exist.
// If it does, update it to have the new name and cost.
app.http('AddProduct', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [mysqlOutput],
    handler: async (request, context) => {
        // Note that this expects the body to be a JSON object or array of objects that have a property
        // matching each of the columns in the table to upsert to.
        const product = await request.json();
        context.extraOutputs.set(mysqlOutput, product);

        return {
            status: 201,
            body: JSON.stringify(product)
        };
    }
});

const { app, output } = require('@azure/functions');

const mysqlOutput = output.generic({
    type: 'mysql',
    commandText: 'Products',
    connectionStringSetting: 'MySqlConnectionString'
})

// Upsert the product, which will insert it into the Products table if the primary key (ProductId) for that item doesn't exist.
// If it does, update it to have the new name and cost.
app.http('AddProduct', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [mysqlOutput],
    handler: async (request, context) => {
        // Note that this expects the body to be a JSON object or array of objects that have a property
        // matching each of the columns in the table to upsert to.
        const product = await request.json();
        context.extraOutputs.set(mysqlOutput, product);

        return {
            status: 201,
            body: JSON.stringify(product)
        };
    }
});

Weitere Beispiele für die Azure-Datenbank für MySQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält das folgende Beispiel:

Das Beispiel bezieht sich auf eine Datenbanktabelle:

DROP TABLE IF EXISTS Products;

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

HTTP-Trigger: Schreiben von Datensätzen in eine Tabelle

Das folgende Beispiel zeigt eine Azure-Datenbank für MySQL-Ausgabebindung in einer function.json-Datei und eine PowerShell-Funktion, die Einer Tabelle Datensätze hinzufügt, indem Daten verwendet werden, die in einer HTTP-Anforderung als JSON-Text POST bereitgestellt werden.

Das folgende Beispiel bindet Daten in der Datei function.json:

{
  "bindings": [
    {
      "authLevel": "function",
      "name": "Request",
      "direction": "in",
      "type": "httpTrigger",
      "methods": [
        "post"
      ],
      "route": "addproduct"
    },
    {
      "name": "response",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "product",
      "type": "mysql",
      "direction": "out",
      "commandText": "Products",
      "connectionStringSetting": "MySqlConnectionString"
    }
  ],
  "disabled": false
}

Im Abschnitt "Konfiguration" werden diese Eigenschaften erläutert.

Das folgende Beispiel ist PowerShell-Beispielcode für die Funktion in der datei run.ps1:

using namespace System.Net

# Trigger binding data passed in via parameter block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell function with MySql Output Binding processed a request."

# Note that this expects the body to be a JSON object or array of objects 
# that have a property matching each of the columns in the table to upsert to.
$req_body = $Request.Body

# Assign the value that you want to pass to the MySQL output binding. 
# The -Name value corresponds to the name property in the function.json file for the binding.
Push-OutputBinding -Name product -Value $req_body

# Assign the value to return as the HTTP response. 
# The -Name value matches the name property in the function.json file for the binding.
Push-OutputBinding -Name response -Value ([HttpResponseContext]@{
    StatusCode = [HttpStatusCode]::OK
    Body = $req_body
})

Weitere Beispiele für die Azure-Datenbank für MySQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält das folgende Beispiel:

Das Beispiel bezieht sich auf eine Datenbanktabelle:

DROP TABLE IF EXISTS Products;

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

Hinweis

Sie müssen Azure Functions Version 1.22.0b4 für Python verwenden.

HTTP-Trigger: Schreiben von Datensätzen in eine Tabelle

Das folgende Beispiel zeigt eine Azure-Datenbank für MySQL-Ausgabebindung in einer function.json-Datei und eine Python-Funktion, die einer Tabelle Datensätze hinzufügt, indem Daten verwendet werden, die in einer HTTP-Anforderung als JSON-Text POST bereitgestellt werden.

Das folgende Beispiel ist Python-Beispielcode für die function_app.py-Datei:

import json 

import azure.functions as func

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)
@app.generic_trigger(arg_name="req", type="httpTrigger", route="addproduct")
@app.generic_output_binding(arg_name="$return", type="http")
@app.generic_output_binding(arg_name="r", type="mysql",
                            command_text="Products",
                            connection_string_setting="MySqlConnectionString")
def mysql_output(req: func.HttpRequest, r: func.Out[func.MySqlRow]) \
        -> func.HttpResponse:
    body = json.loads(req.get_body())
    row = func.MySqlRow.from_dict(body)
    r.set(row)

    return func.HttpResponse(
        body=req.get_body(),
        status_code=201,
        mimetype="application/json"
    )

Attribute

Die C#-Bibliothek verwendet das MySqlAttribute Attribut, um die MySQL-Bindungen für die Funktion zu deklarieren, die die folgenden Eigenschaften aufweist:

Attributeigenschaft BESCHREIBUNG
CommandText Erforderlich. Der Name der Tabelle, in die die Bindung schreibt.
ConnectionStringSetting Erforderlich. Der Name einer App-Einstellung, die die Verbindungszeichenfolge für die Datenbank enthält, in die Daten geschrieben werden. Dieser Wert ist nicht die tatsächliche Verbindungszeichenfolge und muss stattdessen in eine Umgebungsvariable aufgelöst werden.

Anmerkungen

Verwenden Sie in der Java-Funktionslaufzeitbibliothek die @MySQLOutput Anmerkung für Parameter, deren Wert aus der Azure-Datenbank für MySQL stammt. Diese Anmerkung unterstützt die folgenden Elemente:

Element BESCHREIBUNG
commandText Erforderlich. Der Name der Tabelle, in die die Bindung schreibt.
connectionStringSetting Erforderlich. Der Name einer App-Einstellung, die die Verbindungszeichenfolge für die Datenbank enthält, in die Daten geschrieben werden. Dieser Wert ist nicht die tatsächliche Verbindungszeichenfolge und muss stattdessen in eine Umgebungsvariable aufgelöst werden.
name Erforderlich. Der eindeutige Name der Funktionsbindung.

Konfiguration

In der folgenden Tabelle werden die Eigenschaften erläutert, die Sie für das options an die output.generic() Methode übergebene Objekt festlegen können:

Eigenschaft BESCHREIBUNG
commandText Erforderlich. Der Name der Tabelle, in die die Bindung schreibt.
connectionStringSetting Erforderlich. Der Name einer App-Einstellung, die die Verbindungszeichenfolge für die Datenbank enthält, in die Daten geschrieben werden. Dieser Wert ist nicht die tatsächliche Verbindungszeichenfolge und muss stattdessen in eine Umgebungsvariable aufgelöst werden.

Konfiguration

In der folgenden Tabelle werden die Bindungskonfigurationseigenschaften erläutert, die Sie in der datei function.json festlegen:

Eigenschaft BESCHREIBUNG
type Erforderlich. Muss auf Mysql festgelegt sein.
direction Erforderlich. Muss auf out festgelegt sein.
name Erforderlich. Der Name der Variablen, die die Entität im Funktionscode darstellt.
commandText Erforderlich. Der Name der Tabelle, in die die Bindung schreibt.
connectionStringSetting Erforderlich. Der Name einer App-Einstellung, die die Verbindungszeichenfolge für die Datenbank enthält, in die Daten geschrieben werden. Dieser Wert ist nicht die tatsächliche Verbindungszeichenfolge und muss stattdessen in eine Umgebungsvariable aufgelöst werden.

Wenn Sie die Entwicklung lokal ausführen, fügen Sie Ihre Anwendungseinstellungen in der Datei local.settings.json in der Values-Sammlung hinzu.

Hinweis

Die Ausgabebindung unterstützt alle Sonderzeichen, einschließlich Dollarzeichen ($), Backtick ('), Bindestrich (-) und Unterstrich (_). Weitere Informationen finden Sie in der MySQL Community-Dokumentation.

Eine Programmiersprache kann Memberattribute definieren, die Sonderzeichen enthalten, die sie unterstützt. Beispielsweise hat C# einige Einschränkungen zum Definieren von Variablen.

Andernfalls können Sie für die Ausgabebindung verwenden JObject , die alle Sonderzeichen abdeckt. Sie können einem detaillierten Beispiel auf GitHub folgen.

Verbrauch

Die CommandText Eigenschaft ist der Name der Tabelle, in der die Daten gespeichert werden. Der Name der Verbindungszeichenfolgeneinstellung entspricht der Anwendungseinstellung, die die Verbindungszeichenfolge mit der Azure-Datenbank für MySQL enthält.

Wenn eine Ausnahme auftritt, wenn eine MySQL-Eingabebindung ausgeführt wird, wird der Funktionscode nicht ausgeführt. Das Ergebnis kann ein Fehlercode sein, z. B. ein HTTP-Trigger, der einen Fehlercode 500 zurückgibt.

Verwandte Inhalte