Připojení Azure Functions ke službě Azure Cosmos DB pomocí editoru Visual Studio Code

Než začnete, musíte dokončit rychlý start: Vytvoření funkce jazyka C# v Azure pomocí editoru Visual Studio Code. Pokud jste už vyčistili prostředky na konci tohoto článku, projděte si kroky znovu a znovu vytvořte aplikaci funkcí a související prostředky v Azure.

Než začnete, musíte dokončit rychlý start: Vytvoření funkce JavaScriptu v Azure pomocí editoru Visual Studio Code. Pokud jste už vyčistili prostředky na konci tohoto článku, projděte si kroky znovu a znovu vytvořte aplikaci funkcí a související prostředky v Azure.

Než začnete, musíte dokončit rychlý start: Vytvoření funkce Pythonu v Azure pomocí editoru Visual Studio Code. Pokud jste už vyčistili prostředky na konci tohoto článku, projděte si kroky znovu a znovu vytvořte aplikaci funkcí a související prostředky v Azure.

Kromě triggerů HTTP a časovače se vazby implementují jako balíčky rozšíření. Spuštěním následujícího příkazu dotnet add package v okně terminálu přidejte do projektu balíček rozšíření Azure Cosmos DB.

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.CosmosDB

Váš projekt je nakonfigurovaný tak, aby používal sady rozšíření, které automaticky nainstaluje předdefinovanou sadu balíčků rozšíření.

Využití sad rozšíření je povolené v souboru host.json v kořenovém adresáři projektu, který se zobrazí takto:

{
  "version": "2.0",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  },
  "concurrency": {
    "dynamicConcurrencyEnabled": true,
    "snapshotPersistenceEnabled": true
  },
  "extensions": {
    "cosmosDB": {
      "connectionMode": "Gateway"
    }
  }
}

Váš projekt je nakonfigurovaný tak, aby používal sady rozšíření, které automaticky nainstaluje předdefinovanou sadu balíčků rozšíření.

Využití sad rozšíření je povolené v souboru host.json v kořenovém adresáři projektu, který se zobrazí takto:

{
  "version": "2.0",
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[3.*, 4.0.0)"
  } 
}

V projektu knihovny tříd jazyka C# jsou vazby definovány jako atributy vazby v metodě funkce.

Otevřete soubor projektu HttpExample.cs a přidejte následující třídy:

public class MultiResponse
{
    [CosmosDBOutput("my-database", "my-container",
        Connection = "CosmosDbConnectionSetting", CreateIfNotExists = true)]
    public MyDocument Document { get; set; }
    public HttpResponseData HttpResponse { get; set; }
}
public class MyDocument {
    public string id { get; set; }
    public string message { get; set; }
}

Třída MyDocument definuje objekt, který se zapíše do databáze. Vlastnost nastaví Connection připojovací řetězec pro účet úložiště. V tomto případě byste mohli vynechat Connection , protože už používáte výchozí účet úložiště.

Třída MultiResponse umožňuje jak zapisovat do zadané kolekce ve službě Azure Cosmos DB, tak vrátit zprávu o úspěchu protokolu HTTP. Protože potřebujete vrátit MultiResponse objekt, musíte také aktualizovat podpis metody.

Konkrétní atributy určují název kontejneru a název nadřazené databáze. Připojovací řetězec pro váš účet služby Azure Cosmos DB je nastavena nástrojem CosmosDbConnectionSetting.

Atributy vazby jsou definovány přímo v kódu funkce. Konfigurace výstupu služby Azure Cosmos DB popisuje pole požadovaná pro výstupní vazbu Azure Cosmos DB.

V tomto MultiResponse scénáři je potřeba do funkce přidat extraOutputs výstupní vazbu.

app.http('HttpExample', {
  methods: ['GET', 'POST'],
  extraOutputs: [sendToCosmosDb],
  handler: async (request, context) => {

Do konfigurace vazby přidejte následující vlastnosti:

const sendToCosmosDb = output.cosmosDB({
  databaseName: 'my-database',
  containerName: 'my-container',
  createIfNotExists: false,
  connection: 'CosmosDBConnectionString',
});

Atributy vazby jsou definovány přímo v souboru function_app.py . Dekorátor použijete cosmos_db_output k přidání výstupní vazby Azure Cosmos DB:

@app.cosmos_db_output(arg_name="outputDocument", database_name="my-database", 
    container_name="my-container", connection="CosmosDbConnectionSetting")

V tomto kódu identifikuje parametr vazby, na který odkazuje váš kód, database_name a container_name jedná se o názvy databází a kolekcí, do kterých se vazba zapisuje, a connection je název nastavení aplikace, arg_name které obsahuje připojovací řetězec pro účet služby Azure Cosmos DB, který je v CosmosDbConnectionSetting nastavení v souboru local.settings.json.

Nahraďte existující metodu Run následujícím kódem:

[Function("HttpExample")]
public static MultiResponse Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req,
    FunctionContext executionContext)
{
    var logger = executionContext.GetLogger("HttpExample");
    logger.LogInformation("C# HTTP trigger function processed a request.");

    var message = "Welcome to Azure Functions!";

    var response = req.CreateResponse(HttpStatusCode.OK);
    response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
    response.WriteString(message);

    // Return a response to both HTTP trigger and Azure Cosmos DB output binding.
    return new MultiResponse()
    {
         Document = new MyDocument
        {
            id = System.Guid.NewGuid().ToString(),
            message = message
        },
        HttpResponse = response
    };
}

Přidejte kód, který používá extraInputs objekt context výstupní vazby k odeslání dokumentu JSON do pojmenované výstupní vazby funkce, sendToCosmosDb. Přidejte tento kód před return příkaz.

context.extraOutputs.set(sendToCosmosDb, {
  // create a random ID
  id:
    new Date().toISOString() + Math.random().toString().substring(2, 10),
  name: name,
});

V tomto okamžiku by vaše funkce měla vypadat takto:

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

const sendToCosmosDb = output.cosmosDB({
  databaseName: 'my-database',
  containerName: 'my-container',
  createIfNotExists: false,
  connection: 'CosmosDBConnectionString',
});

app.http('HttpExampleToCosmosDB', {
  methods: ['GET', 'POST'],
  extraOutputs: [sendToCosmosDb],
  handler: async (request, context) => {
    try {
      context.log(`Http function processed request for url "${request.url}"`);

      const name = request.query.get('name') || (await request.text());

      if (!name) {
        return { status: 404, body: 'Missing required data' };
      }

      // Output to Database
      context.extraOutputs.set(sendToCosmosDb, {
        // create a random ID
        id:
          new Date().toISOString() + Math.random().toString().substring(2, 10),
        name: name,
      });

      const responseMessage = name
        ? 'Hello, ' +
          name +
          '. This HTTP triggered function executed successfully.'
        : 'This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.';

      // Return to HTTP client
      return { body: responseMessage };
    } catch (error) {
      context.log(`Error: ${error}`);
      return { status: 500, body: 'Internal Server Error' };
    }
  },
});

Tento kód teď vrátí MultiResponse objekt, který obsahuje dokument i odpověď HTTP.

Aktualizujte httpExample\function_app.py tak, aby odpovídaly následujícímu kódu. outputDocument Přidejte parametr do definice funkce a outputDocument.set() pod if name: příkaz:

import azure.functions as func
import logging

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="hello", auth_level=func.AuthLevel.ANONYMOUS)
@app.queue_output(arg_name="msg", queue_name="outqueue", connection="AzureWebJobsStorage")
@app.cosmos_db_output(arg_name="outputDocument", database_name="my-database", container_name="my-container", connection="CosmosDbConnectionSetting")
def test_function(req: func.HttpRequest, msg: func.Out[func.QueueMessage],
    outputDocument: func.Out[func.Document]) -> func.HttpResponse:
     logging.info('Python HTTP trigger function processed a request.')
     logging.info('Python Cosmos DB trigger function processed a request.')
     name = req.params.get('name')
     if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

     if name:
        outputDocument.set(func.Document.from_dict({"id": name}))
        msg.set(name)
        return func.HttpResponse(f"Hello {name}!")
     else:
        return func.HttpResponse(
                    "Please pass a name on the query string or in the request body",
                    status_code=400
                )

Dokument {"id": "name"} se vytvoří v kolekci databáze zadané v vazbě.

Místní spuštění funkce

Visual Studio Code se integruje s nástroji Azure Functions Core, které vám umožní spustit tento projekt na místním vývojovém počítači před publikováním do Azure. Pokud ještě nemáte nástroje Core Tools nainstalované místně, zobrazí se výzva k jeho instalaci při prvním spuštění projektu.

1. Pokud chcete volat funkci, stisknutím klávesy F5 spusťte projekt aplikace funkcí. Na panelu Terminálu se zobrazí výstup nástrojů Core Tools. Aplikace se spustí na panelu Terminálu . Zobrazí se koncový bod adresy URL funkce aktivované protokolem HTTP spuštěné místně.

   

   Pokud ještě nemáte nainstalované Nástroje Core Tools, po zobrazení výzvy k instalaci nástrojů Core Tools vyberte Nainstalovat .
   Pokud máte potíže se spuštěním ve Windows, ujistěte se, že výchozí terminál pro Visual Studio Code není nastavený na WSL Bash.

2. Se spuštěnými nástroji Core Tools přejděte do oblasti Azure: Functions . V části Funkce rozbalte položku Místní projektové>funkce. Klikněte pravým tlačítkem myši (Windows) nebo Ctrl – klikněte na funkci (macOS) HttpExample a zvolte Spustit funkci nyní....

   

3. V textu požadavku Enter stiskněte Enter a odešlete do funkce zprávu požadavku.

4. Když se funkce spustí místně a vrátí odpověď, v editoru Visual Studio Code se vyvolá oznámení. Informace o provádění funkce se zobrazují na panelu Terminálu .

5. Stisknutím kombinace kláves Ctrl+C zastavte nástroje Core Tools a odpojte ladicí program.

Místní spuštění funkce

1. Stejně jako v předchozím článku spusťte stisknutím klávesy F5 projekt aplikace funkcí a nástroje Core Tools.

2. Se spuštěnými nástroji Core Tools přejděte do oblasti Azure: Functions . V části Funkce rozbalte položku Místní projektové>funkce. Klikněte pravým tlačítkem myši (ctrl klikněte na Mac) HttpExample funkci a zvolte Spustit funkci nyní....

   

3. V části Zadejte text požadavku uvidíte textovou hodnotu { "name": "Azure" }zprávy požadavku . Stisknutím klávesy Enter odešlete tuto zprávu požadavku do funkce.

4. Po vrácení odpovědi stiskněte Ctrl+C a zastavte nástroje Core Tools.

• Příklady kompletních projektů funkcí v jazyce C#.

• Referenční informace pro vývojáře v jazyce C# pro Azure Functions

• Příklady kompletních projektů funkcí v JavaScriptu

• Azure Functions – Příručka pro vývojáře v JavaScriptu

• Příklady kompletních projektů funkcí v Pythonu

• Azure Functions – Příručka pro vývojáře v Pythonu