Azure Functions csatlakoztatása Azure Storage Visual Studio Code használatával

Azure Functions lehetővé teszi Azure szolgáltatások és egyéb erőforrások függvényekhez való csatlakoztatását anélkül, hogy saját integrációs kódot kellene írnia. Ezek a kötések, amelyek mind a bemenetet, mind a kimenetet képviselik, a függvénydefinícióban deklarálódnak. A kötések adatai a függvények számára paraméterekként vannak megadva. Az eseményindító egy speciális típusú bemeneti kötés. Bár egy függvénynek csak egy eseményindítója van, több bemeneti és kimeneti kötéssel is rendelkezhet. További információ: Azure Functions triggerek és hozzárendelések fogalmai.

Ebből a cikkből megtudhatja, hogyan csatlakoztathat Azure Storage Visual Studio kóddal az előző rövid útmutatóban létrehozott függvényhez. Az ehhez a függvényhez hozzáadott kimeneti csatorna az HTTP-kérés adatait egy üzenetbe írja, amely bekerül egy Azure Queue tároló sorba.

A legtöbb kötéshez olyan tárolt kapcsolati karakterláncra van szükség, amelyet a Functions a kötött szolgáltatás eléréséhez használ. A könnyebb használat érdekében használja a függvényalkalmazással létrehozott storage fiókot. A fiókhoz való csatlakozást a rendszer már egy nevesített AzureWebJobsStoragealkalmazásbeállításban tárolja.

Megjegyzés

Ez a cikk jelenleg Node.js függvényekhez készült v4-et támogatja.

A helyi környezet konfigurálása

A kezdés előtt meg kell felelnie a következő követelményeknek:

Ez a cikk feltételezi, hogy már bejelentkezett a Azure-előfizetésbe Visual Studio Code-ból. A parancskatalógusból Azure: Sign In futtatásával jelentkezhet be.

A függvényalkalmazás beállításainak letöltése

Az előző rövid útmutatóban létrehozott egy függvényalkalmazást az Azure-ban a szükséges tárfiókkal együtt. Az Azure alkalmazásbeállításokban biztonságosan van tárolva a fiók kapcsolati karakterlánca. Ebben a cikkben üzeneteket ír egy Storage üzenetsorba ugyanabban a fiókban. Ha a függvény helyi futtatásakor szeretne csatlakozni storage fiókjához, le kell töltenie az alkalmazásbeállításokat a local.settings.json fájlba.

  1. Nyomja le a F1 billentyűt a parancspaletta megnyitásához, majd keresse meg és futtassa a parancsot Azure Functions: Download Remote Settings....

  2. Válassza ki az előző cikkben létrehozott függvényalkalmazást. Az Igen elemet választva felülírhatja a meglévő helyi beállításokat.

    Fontos

    Mivel a local.settings.json fájl titkos kódokat tartalmaz, soha nem lesz közzétéve, és ki van zárva a forrásvezérlőből.

  3. Másolja ki a AzureWebJobsStorage értéket, amely a tárfiók kapcsolati karakterlánc értékének kulcsa. Ezzel a kapcsolattal ellenőrizheti, hogy a kimeneti kötés a várt módon működik-e.

Kötési bővítmények regisztrálása

Mivel queue storage kimeneti kötést használ, a project futtatása előtt telepítenie kell a Storage kötések bővítményét.

A project extension-csomagok használatára lett konfigurálva, amely automatikusan telepíti az előre definiált bővítménycsomagokat.

A bővítménycsomagok már engedélyezve van a host.json fájlban a project gyökerénél, amelynek a következő példához hasonlóan kell kinéznie:

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

Most hozzáadhatja a tároló kimeneti kapcsolatot a projekthez.

A project extension-csomagok használatára lett konfigurálva, amely automatikusan telepíti az előre definiált bővítménycsomagokat.

A bővítménycsomagok már engedélyezve van a host.json fájlban a project gyökerénél, amelynek a következő példához hasonlóan kell kinéznie:

{
  "version": "2.0",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}

Most hozzáadhatja a tárhely kimeneti kötést a projektjéhez.

A HTTP- és időzítő-eseményindítók kivételével a kötések bővítménycsomagként vannak implementálva. Futtassa a következő dotnet add package parancsot a Terminál ablakban a Storage bővítménycsomag hozzáadásához a projekt.

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Storage.Queues --prerelease

Most hozzáadhatja a tárolási kimeneti kötést a projektjéhez.

Kimeneti kötés hozzáadása

Az üzenet írása egy Azure Storage üzenetsorba:

  • extraOutputs Tulajdonság hozzáadása a kötéskonfigurációhoz

    {
    methods: ['GET', 'POST'],
    extraOutputs: [sendToQueue], // add output binding to HTTP trigger
    authLevel: 'function',
    handler: () => {}
}

  • Adj hozzá egy output.storageQueue függvényt a app.http hívás fölé.

    const sendToQueue = output.storageQueue({
  queueName: 'outqueue',
  connection: 'AzureWebJobsStorage',
});

Az Azure Storage üzenetsorba való íráshoz:

  • extraOutputs Tulajdonság hozzáadása a kötéskonfigurációhoz

    {
    methods: ['GET', 'POST'],
    extraOutputs: [sendToQueue], // add output binding to HTTP trigger
    authLevel: 'function',
    handler: () => {}
}

  • Adj hozzá egy output.storageQueue függvényt a app.http hívás fölé.

    const sendToQueue: StorageQueueOutput = output.storageQueue({
  queueName: 'outqueue',
  connection: 'AzureWebJobsStorage',
});

A Functions minden kötéstípushoz direction, type és egyedi name szükséges. Az attribútumok definiálásának módja a függvényalkalmazás nyelvétől függ.

A kötési attribútumok egy adott függvény function.json fájljában vannak definiálva. A kötés típusától függően további tulajdonságokra lehet szükség. A queue kimeneti konfiguráció az Azure Storage üzenetsor-kötéshez szükséges mezőket ismerteti. A bővítmény megkönnyíti a kötések hozzáadását a function.json fájlhoz.

Kötés létrehozásához kattintson a jobb gombbal a httpTrigger mappában lévő fájlra (Ctrl+kattintson a macOS billentyűkombinációra), function.json és válassza a Kötés hozzáadása...parancsot. Kövesse az utasításokat az új kötés következő kötési tulajdonságainak meghatározásához:

Felszólítás Érték Leírás
Kötés irányának kiválasztása out A kötés kimeneti típusú.
Kötés kiválasztása irány szerint... Azure Queue Storage A kötés egy Azure Storage üzenetsorhoz tartozó kötés.
A kötés azonosítására használt név a kódban msg A kódban hivatkozott kötési paramétert azonosító név.
Az üzenetsor, amelybe az üzenet el lesz küldve outqueue Annak az üzenetsornak a neve, amelybe a kapcsolódás ír. Ha a queueName nem létezik, a kötés az első használatkor hozza létre.
Válassza ki a beállítást a "local.setting.json" elemből AzureWebJobsStorage Az alkalmazásbeállítás neve, amely tartalmazza a Storage-fiók kapcsolati karakterláncát. A AzureWebJobsStorage beállítás tartalmazza a függvényalkalmazással létrehozott Storage-fiók connection stringjét.

A function.json tömbjéhez bindingsegy kötést ad hozzá, amelynek a következőképpen kell kinéznie:

      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

A kötési attribútumok a function_app.py fájl adott függvénykódjának dekorálásával vannak definiálva. A queue_output dekoratőr használatával Azure Queue storage kimeneti kötést adhat hozzá.

A queue_output dekoratőr használatával a kötés iránya implicit módon "ki van kötve", a típus pedig Azure Storage Üzenetsor. Adja hozzá a következő dekoratőrt a függvénykódhoz a function_app.py:

@app.queue_output(arg_name="msg", queue_name="outqueue", connection="AzureWebJobsStorage")

Ebben a kódban a arg_name azonosítja a kódban hivatkozott kötési paramétert, a queue_name annak az üzenetsornak a neve, amelybe a kötés ír, a connection pedig annak az alkalmazásbeállításnak a neve, amely tartalmazza a tárfiók kapcsolati karakterláncát. A gyors kezdési útmutatókban ugyanazt a tárolófiókot használja, mint ami a függvényalkalmazásnak a AzureWebJobsStorage beállításban található. Amikor a queue_name kötés nem létezik, az első használatkor hozza létre.

A C# project a kötések a függvénymetódus kötési attribútumaiként vannak definiálva. Bizonyos definíciók attól függenek, hogy az alkalmazás folyamatban (C#-osztálytár) vagy izolált feldolgozói folyamatban fut-e.

Nyissa meg a HttpExample.cs project fájlt, és adja hozzá a következő MultiResponse osztályt:

public class MultiResponse
{
    [QueueOutput("outqueue", Connection = "AzureWebJobsStorage")]
    public string[] Messages { get; set; }
    public IActionResult HttpResponse { get; set; }
}

A MultiResponse osztály lehetővé teszi, hogy írjon egy outqueue nevű tároló üzenetsorba és hogy HTTP-sikerüzenetet írjon. Több üzenet is elküldhető az üzenetsorba, mert az QueueOutput attribútum egy sztringtömbre van alkalmazva.

Az Connection tulajdonság beállítja a tárolófiók kapcsolati láncát. Ebben az esetben kihagyhatja Connection, mert már használja az alapértelmezett storage fiókot.

Java-projektben a kötések kötési annotációként vannak definiálva a függvény metóduson. A function.json fájl ezután automatikusan létrejön ezen széljegyzetek alapján.

Keresse meg a függvénykód helyét a src/main/java területen, nyissa meg a Function.java project fájlt, és adja hozzá a következő paramétert a run metódusdefinícióhoz:

@QueueOutput(name = "msg", queueName = "outqueue", 
connection = "AzureWebJobsStorage") OutputBinding<String> msg,

A msg paraméter egy OutputBinding<T> típus, amely a függvény befejezésekor üzenetként kiírt karakterláncok gyűjteményét jelöli az output bindinghoz. Ebben az esetben a kimenet egy outqueue nevű tárolósor. A Storage-fiók kapcsolati karakterláncát a connection metódus állítja be. A kapcsolati karakterlánc helyett a tárhely fiók kapcsolati karakterláncát tartalmazó alkalmazásbeállítást kell megadnia.

A run metódusdefiníciónak a következő példához hasonlóan kell kinéznie:

@FunctionName("HttpExample")
public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) 
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", 
        connection = "AzureWebJobsStorage") OutputBinding<String> msg, 
        final ExecutionContext context) {

Kimeneti kötést használó kód hozzáadása

A kötés definiálása után a kötés name használatával elérheted attribútumként a függvény szignatúrájában. Kimeneti kötés használatával nem kell a Azure Storage SDK-kódot használnia a hitelesítéshez, az üzenetsor-hivatkozás lekéréséhez vagy az adatok írásához. A Functions futtatókörnyezet és az üzenetsor kimeneti kötése végrehajtja ezeket a feladatokat.

Adjon hozzá egy kódot, amely a kimeneti kötési objektumot context.extraOutputs használja egy üzenetsor létrehozásához. Adja hozzá ezt a kódot a visszatérési utasítás előtt.

context.extraOutputs.set(sendToQueue, [msg]);

Ezen a ponton a függvény a következőképpen nézhet ki:

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

const sendToQueue = output.storageQueue({
  queueName: 'outqueue',
  connection: 'AzureWebJobsStorage',
});

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

      const name = request.query.get('name') || (await request.text());
      context.log(`Name: ${name}`);

      if (name) {
        const msg = `Name passed to the function ${name}`;
        context.extraOutputs.set(sendToQueue, [msg]);
        return { body: msg };
      } else {
        context.log('Missing required data');
        return { status: 404, body: 'Missing required data' };
      }
    } catch (error) {
      context.log(`Error: ${error}`);
      return { status: 500, body: 'Internal Server Error' };
    }
  },
});

Adjon hozzá egy kódot, amely a kimeneti kötési objektumot context.extraOutputs használja egy üzenetsor létrehozásához. Adja hozzá ezt a kódot a visszatérési utasítás előtt.

context.extraOutputs.set(sendToQueue, [msg]);

Ezen a ponton a függvény a következőképpen nézhet ki:

import {
  app,
  output,
  HttpRequest,
  HttpResponseInit,
  InvocationContext,
  StorageQueueOutput,
} from '@azure/functions';

const sendToQueue: StorageQueueOutput = output.storageQueue({
  queueName: 'outqueue',
  connection: 'AzureWebJobsStorage',
});

export async function HttpExample(
  request: HttpRequest,
  context: InvocationContext,
): Promise<HttpResponseInit> {
  try {
    context.log(`Http function processed request for url "${request.url}"`);

    const name = request.query.get('name') || (await request.text());
    context.log(`Name: ${name}`);

    if (name) {
      const msg = `Name passed to the function ${name}`;
      context.extraOutputs.set(sendToQueue, [msg]);
      return { body: msg };
    } else {
      context.log('Missing required data');
      return { status: 404, body: 'Missing required data' };
    }
  } catch (error) {
    context.log(`Error: ${error}`);
    return { status: 500, body: 'Internal Server Error' };
  }
}

app.http('HttpExample', {
  methods: ['GET', 'POST'],
  authLevel: 'anonymous',
  handler: HttpExample,
});

Adjon hozzá olyan kódot, amely a Push-OutputBinding parancsmag használatával szöveget ír a sorba, a msg kimeneti kötést használva. Adja hozzá ezt a kódot, mielőtt beállítja az OK állapotot az if utasításban.

$outputMsg = $name
Push-OutputBinding -name msg -Value $outputMsg

Ezen a ponton a függvénynek a következőképpen kell kinéznie:

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with query parameters or the body of the request.
$name = $Request.Query.Name
if (-not $name) {
    $name = $Request.Body.Name
}

if ($name) {
    # Write the $name value to the queue, 
    # which is the name passed to the function.
    $outputMsg = $name
    Push-OutputBinding -name msg -Value $outputMsg

    $status = [HttpStatusCode]::OK
    $body = "Hello $name"
}
else {
    $status = [HttpStatusCode]::BadRequest
    $body = "Please pass a name on the query string or in the request body."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = $status
    Body = $body
})

Frissítse a HttpExample\function_app.py a következő kódnak megfelelően, adja hozzá a msg paramétert a függvénydefinícióhoz és msg.set(name) az if name: utasítás alatt:

import azure.functions as func
import logging

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.route(route="HttpExample")
@app.queue_output(arg_name="msg", queue_name="outqueue", connection="AzureWebJobsStorage")
def HttpExample(req: func.HttpRequest, msg: func.Out [func.QueueMessage]) -> func.HttpResponse:
    logging.info('Python HTTP 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:
        msg.set(name)
        return func.HttpResponse(f"Hello, {name}. This HTTP triggered function executed successfully.")
    else:
        return func.HttpResponse(
             "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.",
             status_code=200
        )

A msg paraméter a azure.functions.Out class egy példánya. A set metódus sztringüzenetet ír az üzenetsorba. Ebben az esetben az name az URL-lekérdezési stringben található, amit a függvényhez adtak át.

Cserélje le a meglévő Run metódust a következő kódra:

[Function("HttpExample")]
public MultiResponse Run([HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequest req)
{
    _logger.LogInformation("C# HTTP trigger function processed a request.");

    var message = "Welcome to Azure Functions!";

    // Return a response to both HTTP trigger and storage output binding.
    return new MultiResponse()
    {
        // Write a single message.
        Messages = new string[] { message },
        HttpResponse = new OkObjectResult(message)
    };
}

Most az új msg paraméter használatával írhat a függvénykód kimeneti kötésére. A sikeres válasz előtt adja hozzá a következő kódsort, hogy name értékét hozzáadja a msg kimeneti kötéshez.

msg.setValue(name);

Kimeneti kötés használatakor nem kell a Azure Storage SDK-kódot használnia a hitelesítéshez, az üzenetsor-hivatkozás lekéréséhez vagy az adatok írásához. A Functions futtatókörnyezet és az üzenetsor kimeneti kötése végrehajtja ezeket a feladatokat.

A run metódusnak most a következő példához hasonlóan kell kinéznie:

@FunctionName("HttpExample")
public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) 
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", 
        connection = "AzureWebJobsStorage") OutputBinding<String> msg, 
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a request.");

    // Parse query parameter
    String query = request.getQueryParameters().get("name");
    String name = request.getBody().orElse(query);

    if (name == null) {
        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
        .body("Please pass a name on the query string or in the request body").build();
    } else {
        // Write the name to the message queue. 
        msg.setValue(name);

        return request.createResponseBuilder(HttpStatus.OK).body("Hello, " + name).build();
    }
}

A tesztek frissítése

Mivel az archetípus egy tesztkészletet is létrehoz, frissítenie kell ezeket a teszteket, hogy kezelni tudja az új msg paramétert a run metódus-aláírásban.

Keresse meg a tesztkód helyét a src/test/java területen, nyissa meg a Function.java project fájlt, és cserélje le a //Invoke kódsort a következő kódra.

@SuppressWarnings("unchecked")
final OutputBinding<String> msg = (OutputBinding<String>)mock(OutputBinding.class);
final HttpResponseMessage ret = new Function().run(req, msg, context);

Függvény helyi futtatása

Visual Studio Code integrálódik az Azure Functions Core-eszközökkel, hogy még az Azure-ba való közzététel előtt futtathassa a projektet a helyi fejlesztői számítógépén. Ha még nincs telepítve helyileg a Core Tools, a rendszer a project első futtatásakor kéri a telepítést.

  1. A függvény meghívásához nyomja le a F5 billentyűt a függvényalkalmazás project elindításához. A Terminál panelen a Core Tools kimenete látható. Az alkalmazás a Terminál panelen kezdődik. Láthatja a helyileg futó, HTTP által aktivált függvény URL-végpontját.

    A Helyi függvény képernyőképe Visual Studio Code output.

    Ha még nincs telepítve a Core Tools, válassza az Install lehetőséget a Core Tools telepítéséhez, amikor a rendszer kéri erre.
    Ha problémákat tapasztal a Windows rendszeren való futtatás során, győződjön meg arról, hogy a Visual Studio Code alapértelmezett terminálja nincs beállítva WSL Bash.

  2. A Core Tools futtatásával lépjen a Azure: Függvények területre. A Functions területen bontsa ki a Local Project>Functions elemet. Kattintson a jobb gombbal (Windows) vagy Ctrl billentyűkombinációra – kattintson a függvényre (macOS), és válassza a HttpExample Függvény végrehajtása parancsot....

    A Végrehajtási függvény jelenlegi képernyőképe a Visual Studio Code-ból.

  3. A kérelem törzsében nyomja le az Enter billentyűt a kérésüzenet függvényhez való elküldéséhez.

  4. Amikor a függvény helyileg fut, és választ ad vissza, a rendszer értesítést küld Visual Studio Code-ban. A függvény végrehajtásával kapcsolatos információk a Terminál panelen jelennek meg.

  5. Nyomja le a Ctrl + C billentyűkombinációt a Core Tools leállításához és a hibakereső leválasztásához.

Függvény helyi futtatása

  1. Az előző cikkhez hasonlóan nyomja le a F5 billentyűt a függvényalkalmazás project és a Core Tools elindításához.

  2. A Core Tools futtatásával lépjen a Azure: Függvények területre. A Functions területen bontsa ki a Local Project>Functions elemet. Kattintson a jobb gombbal a HttpExample függvényre (Mac esetén tartsa lenyomva a Ctrl billentyűt), és válassza a Függvény végrehajtása most... lehetőséget.

    Screenshot a függvény végrehajtásáról a Visual Studio Code-ban.

  3. A kérelem törzsének megadása során látja a kérési üzenet törzsértékét { "name": "Azure" }. Az Enter billentyűt lenyomva küldje el ezt a kérésüzenetet a függvénynek.

  4. A válasz visszaadása után nyomja le a Ctrl + C billentyűkombinációt a Core Tools leállításához.

Mivel a storage connection string használja, a függvény helyi futtatáskor csatlakozik a Azure storage fiókhoz. A outqueue nevű új üzenetsort a Functions futtatókörnyezet hozza létre a storage-fiókban a kimeneti kötés első használatakor. A Storage Explorer használatával ellenőrizheti, hogy az üzenetsor létrejött-e az új üzenettel együtt.

Storage Explorer csatlakoztatása a fiókjához

Hagyja ki ezt a szakaszt, ha már telepítette Azure Storage Explorer, és csatlakoztatta a Azure fiókjához.

  1. Futtassa a Azure Storage Explorer eszközt, válassza a bal oldali csatlakozás ikont, majd válassza a Fiók hozzáadása lehetőséget.

    Képernyőfotó arról, hogyan lehet egy Azure-fiókot hozzáadni a Microsoft Azure Storage Explorerhez.

  2. A Connect párbeszédpanelen válassza a Add an Azure account, select your Azure environment, majd select Sign in... .

    A bejelentkezés képernyőképe a Azure-fiók ablak.

Miután sikeresen bejelentkezett a fiókjába, megjelenik a fiókjához társított összes Azure előfizetés. Válassza ki az előfizetést, és válassza az Explorer megnyitása lehetőséget.

A kimeneti várakozási sor vizsgálata

  1. A Visual Studio Code-ban nyomja le a F1 billentyűt a parancskatalógus megnyitásához, majd keresse meg és futtassa a parancsot Azure Storage: Open in Storage Explorer, és válassza ki storage fióknevét. A storage fiókja megnyílik az Azure Storage Explorer.

  2. Bontsa ki az Üzenetsorok csomópontot, majd válassza ki az outqueue nevű üzenetsort.

    Az üzenetsor tartalmazza az üzenetet, amelyet az üzenetsor kimeneti kötése létrehozott a HTTP által aktivált függvény futtatásakor. Ha a függvényt az alapértelmezett nameAzure értékkel hívja meg, az üzenetsor üzenete A függvénynek átadott név: Azure.

    Az Azure Storage Explorerben megjelenített várólistaüzenet képernyőképe.

  3. Futtassa újra a függvényt, küldjön egy másik kérést, és megjelenik egy új üzenet az üzenetsorban.

Itt az ideje, hogy újra közzétehesse a frissített függvényalkalmazást a Azure.

A frissített alkalmazás ismételt üzembe helyezése és ellenőrzése

  1. A Visual Studio Code-ban nyomja le a F1 billentyűt a parancskatalógus megnyitásához. A parancskatalógusban keresse meg és válassza ki a Azure Functions: Deploy to function app....

  2. Válassza ki az első cikkben létrehozott függvényalkalmazást. Mivel újratelepíti a projektet ugyanarra az alkalmazásra, válassza a Deploy lehetőséget a fájlok felülírására vonatkozó figyelmeztetés elvetéséhez.

  3. Az üzembe helyezés befejezése után ismét használhatja az Execute Function Now... funkciót a funkció aktiválásához az Azure-on. Ez a parancs automatikusan lekéri a függvényhozzáférési kulcsot, és azt a HTTP-triggerelő végponton történő híváskor használja.

  4. Ismét nézze meg az üzenetet a tároló üzenetsorban annak ellenőrzésére, hogy a kimeneti kötés új üzenetet hoz-e létre az üzenetsorban.

Az erőforrások megtisztítása

A Azure resources függvényalkalmazásokra, függvényekre, storage fiókokra stb. hivatkozik. Ezek erőforráscsoportokba vannak csoportosítva, és a csoport törlésével törölheti a csoport összes elemét.

A gyors kezdési útmutatók elvégzéséhez erőforrásokat hoztál létre. Ezekért az erőforrásokért a fiók állapotától és szolgáltatás díjszabásától függően lehet fizetni. Ha már nincs szüksége ezekre az erőforrásokra, a következőképpen törölheti őket:

  1. A Visual Studio Code-ban nyomja le a F1 billentyűt a parancskatalógus megnyitásához. A parancskatalógusban keresse meg és válassza ki a Azure: Open in portal.

  2. Válassza ki a függvényalkalmazást, és nyomja le az Enter billentyűt. Megnyílik a függvényalkalmazás lapja az Azure portal.

  3. Az Áttekintés lapon válassza az Erőforráscsoport melletti elnevezett hivatkozást.

    Képernyőkép a függvényalkalmazás oldaláról törölni kívánt erőforráscsoport kiválasztásáról.

  4. Az Erőforráscsoport lapon tekintse át a belefoglalt erőforrások listáját, és ellenőrizze, hogy ezek-e törölni kívánt erőforrások.

  5. Válassza az Erőforráscsoport törlése elemet, majd kövesse az utasításokat.

    A törlés eltarthat néhány percig. Amint a művelet befejeződött, néhány másodpercre egy értesítés jelenik meg. Az értesítést úgy is megtekintheti, ha kiválasztja a harang ikont az oldal tetején.

Következő lépések

HTTP-vel aktivált függvényét úgy frissítette, hogy adatokat írjon egy tárhely várósorba. Most már többet is megtudhat a Functions Visual Studio Code használatával történő fejlesztéséről:

  • Last updated on