Partager via

Liaison de sortie Azure Database pour MySQL pour Azure Functions

Vous pouvez utiliser la liaison de sortie Azure Database pour MySQL pour écrire dans une base de données.

Pour plus d’informations sur l’installation et la configuration, consultez la vue d’ensemble.

Important

Cet article utilise des onglets pour prendre en charge plusieurs versions du modèle de programmation Node.js. Le modèle v4 est en disponibilité générale. Il est conçu pour offrir une expérience plus flexible et intuitive aux développeurs JavaScript et TypeScript. Pour plus d’informations sur le fonctionnement du modèle v4, reportez-vous au guide du développeur Azure Functions Node.js. Si vous souhaitez obtenir plus d’informations sur les différences entre v3 et v4, consultez le guide de migration.

Exemples

Vous pouvez créer une fonction C# à l’aide de l’un des modes C# suivants :

  • Modèle worker isolé : fonction C# compilée exécutée dans un processus worker isolé du runtime. Un processus de travail isolé est nécessaire pour prendre en charge les fonctions C# s’exécutant sur la prise en charge à long terme (LTS) et les versions non LTS pour .NET et .NET Framework.
  • Modèle in-process : fonction C# compilée qui s’exécute dans le même processus que le runtime Azure Functions.
  • Script C# : principalement utilisé lors de la création de fonctions C# dans le portail Azure.

Important

La prise en charge du modèle in-process prendra fin le 10 novembre 2026. Pour continuer à bénéficier d’une prise en charge complète, nous vous recommandons vivement de migrer vos applications vers le modèle worker isolé.

D’autres exemples pour la liaison de sortie Azure Database pour MySQL sont disponibles dans le référentiel GitHub.

Cette section contient l’exemple suivant :

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

DROP TABLE IF EXISTS Products;

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

Déclencheur HTTP, écriture d’un enregistrement

L’exemple suivant montre une fonction C# qui ajoute un enregistrement à une base de données, à l’aide de données fournies dans une requête HTTP POST en tant que corps JSON.

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

D’autres exemples pour la liaison de sortie Azure Database pour MySQL sont disponibles dans le référentiel GitHub.

Cette section contient l’exemple suivant :

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

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

Déclencheur HTTP, écrire un enregistrement dans une table

L’exemple suivant montre une liaison de sortie Azure Database pour MySQL dans une fonction Java qui ajoute un enregistrement à une table, à l’aide de données fournies dans une requête HTTP POST en tant que corps JSON. La fonction prend une dépendance supplémentaire sur la bibliothèque com.google.code.gson pour analyser le corps JSON.

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

D’autres exemples pour la liaison de sortie Azure Database pour MySQL sont disponibles dans le référentiel GitHub.

Cette section contient l’exemple suivant :

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

DROP TABLE IF EXISTS Products;

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

Déclencheur HTTP, écriture d’enregistrements dans une table

L’exemple suivant montre une liaison de sortie Azure Database pour MySQL qui ajoute des enregistrements à une table, à l’aide de données fournies dans une requête HTTP POST en tant que corps JSON.

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

D’autres exemples pour la liaison de sortie Azure Database pour MySQL sont disponibles dans le référentiel GitHub.

Cette section contient l’exemple suivant :

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

DROP TABLE IF EXISTS Products;

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

Déclencheur HTTP, écriture d’enregistrements dans une table

L’exemple suivant montre une liaison de sortie Azure Database pour MySQL dans un fichier function.json et une fonction PowerShell qui ajoute des enregistrements à une table, à l’aide de données fournies dans une requête HTTP POST en tant que corps JSON.

L’exemple suivant montre une liaison de données dans le fichier 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
}

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

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

D’autres exemples pour la liaison de sortie Azure Database pour MySQL sont disponibles dans le référentiel GitHub.

Cette section contient l’exemple suivant :

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

DROP TABLE IF EXISTS Products;

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

Remarque

Vous devez utiliser Azure Functions version 1.22.0b4 pour Python.

Déclencheur HTTP, écriture d’enregistrements dans une table

L’exemple suivant montre une liaison de sortie Azure Database pour MySQL dans un fichier function.json et une fonction Python qui ajoute des enregistrements à une table, à l’aide de données fournies dans une requête HTTP POST en tant que corps JSON.

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

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

Attributs

La bibliothèque C# utilise l’attribut MySqlAttribute pour déclarer les liaisons MySQL sur la fonction, qui possède les propriétés suivantes :

Propriété d’attribut Descriptif
CommandText Obligatoire. Nom de la table dans laquelle la liaison écrit.
ConnectionStringSetting Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données dans laquelle les données sont écrites. Cette valeur n’est pas la chaîne de connexion réelle et doit plutôt être résolue en variable d’environnement.

Commentaires

Dans la bibliothèque runtime de fonctions Java, utilisez l’annotation sur les paramètres dont la @MySQLOutput valeur provient de Azure Database pour MySQL. Cette annotation prend en charge les éléments suivants :

Élément Descriptif
commandText Obligatoire. Nom de la table dans laquelle la liaison écrit.
connectionStringSetting Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données dans laquelle les données sont écrites. Cette valeur n’est pas la chaîne de connexion réelle et doit plutôt être résolue en variable d’environnement.
name Obligatoire. Nom unique de la liaison de fonction.

Paramétrage

Le tableau suivant explique les propriétés que vous pouvez définir sur l’objet options passé à la output.generic() méthode :

Propriété Descriptif
commandText Obligatoire. Nom de la table dans laquelle la liaison écrit.
connectionStringSetting Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données dans laquelle les données sont écrites. Cette valeur n’est pas la chaîne de connexion réelle et doit plutôt être résolue en variable d’environnement.

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
type Obligatoire. Cette propriété doit être définie sur Mysql.
direction Obligatoire. Cette propriété doit être définie sur out.
name Obligatoire. Nom de la variable qui représente l’entité dans le code de la fonction.
commandText Obligatoire. Nom de la table dans laquelle la liaison écrit.
connectionStringSetting Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données dans laquelle les données sont écrites. Cette valeur n’est pas la chaîne de connexion réelle et doit plutôt être résolue en variable d’environnement.

Lorsque vous développez en local, ajoutez vos paramètres d’application dans le fichier local.settings.json de la collection Values.

Remarque

La liaison de sortie prend en charge tous les caractères spéciaux, y compris le signe dollar ($), backtick ('), le trait d’union (-) et le trait de soulignement (_). Pour plus d’informations, consultez la documentation de la communauté MySQL.

Un langage de programmation peut définir des attributs membres qui contiennent des caractères spéciaux qu’il prend en charge. Par exemple, C# présente quelques limitations pour définir des variables.

Sinon, vous pouvez utiliser JObject pour la liaison de sortie qui couvre tous les caractères spéciaux. Vous pouvez suivre un exemple détaillé sur GitHub.

Utilisation

La CommandText propriété est le nom de la table où les données sont stockées. Le nom du paramètre de chaîne de connexion correspond au paramètre d’application qui contient la chaîne de connexion à Azure Database pour MySQL.

Si une exception se produit lorsqu’une liaison d’entrée MySQL est exécutée, le code de fonction ne s’exécute pas. Le résultat peut être un code d’erreur, tel qu’un déclencheur HTTP qui retourne un code d’erreur 500.

Contenu connexe

  • Last updated on