Azure Functions csatlakoztatása Azure Storage parancssori eszközökkel

Ebben a cikkben integrál egy Azure Storage-üzenetsort az előző gyorsútmutatóban létrehozott funkcióval és tárfiókkal. Ezt az integrációt egy kimeneti kötés használatával érheti el, amely adatokat ír egy HTTP-kérésből az üzenetsor üzeneteibe. A cikk befejezése nem jár többletköltséggel azon néhány USD centhez képest, amelyet az előző gyorsindításért fizettünk. A kötésekről további információért olvassa el az Azure Functions triggerek és kötések fogalmait.

A helyi környezet konfigurálása

Mielőtt hozzákezdene, be kell fejeznie a Gyorsútmutató: Hozzon létre egy Azure Functions projektet a parancssorból. Ha a cikk végén már megtisztította az erőforrásokat, ismételje meg a lépéseket a Azure-ban a funkcióalkalmazás és a kapcsolódó erőforrások újra létrehozásához.

Mielőtt hozzákezdene, be kell fejeznie a Gyorsútmutató: Hozzon létre egy Azure Functions-projektet a parancssorból. Ha a cikk végén már megtisztította az erőforrásokat, ismételje meg a lépéseket a Azure-ban a funkcióalkalmazás és a kapcsolódó erőforrások újra létrehozásához.

Mielőtt hozzákezdene, be kell fejeznie a Gyorsútmutató: Azure Functions projekt parancssorból történő létrehozása. Ha a cikk végén már megtisztította az erőforrásokat, ismételje meg a lépéseket a Azure-ban a funkcióalkalmazás és a kapcsolódó erőforrások újra létrehozásához.

Mielőtt hozzákezdene, be kell fejeznie a Gyorsútmutató: Hozzon létre egy Azure Functions projektet a parancssorból. Ha a cikk végén már megtisztította az erőforrásokat, ismételje meg a lépéseket a Azure-ban a funkcióalkalmazás és a kapcsolódó erőforrások újra létrehozásához.

Mielőtt hozzákezd, be kell fejeznie a Gyorsútmutató: Hozzon létre egy Azure Functions projektet a parancssorból. Ha a cikk végén már megtisztította az erőforrásokat, ismételje meg a lépéseket a Azure-ban a funkcióalkalmazás és a kapcsolódó erőforrások újra létrehozásához.

Mielőtt hozzákezdene, el kell végeznie a Gyorsútmutató: Hozzon létre egy Azure Functions projektet a parancssorból. Ha a cikk végén már megtisztította az erőforrásokat, ismételje meg a lépéseket a Azure-ban a funkcióalkalmazás és a kapcsolódó erőforrások újra létrehozásához.

Azure Storage kapcsolatkarakterlánc lekérése

Fontos

Ez a cikk jelenleg bemutatja, hogyan csatlakozhat Azure Storage fiókjához a megosztott titkos kulcsot tartalmazó connection string használatával. A connection string használatával egyszerűbben ellenőrizheti az adatfrissítéseket a storage-fiókban. A legjobb biztonság érdekében ehelyett felügyelt identitásokat kell használnia a storage-fiókhoz való csatlakozáskor. További információ: Kapcsolatok a fejlesztői útmutatóban.

Korábban létrehozott egy Azure Storage fiókot a függvényalkalmazás használatához. A fiók kapcsolati sztringje biztonságosan van tárolva az Azure alkalmazásbeállításaiban. Ha letölti a beállítást a local.settings.json fájlba, a kapcsolat segítségével írhat egy Storage üzenetsorba ugyanabban a fiókban, amikor helyileg futtatja a függvényt.

  1. A projekt gyökerében futtassa a következő parancsot, és cserélje le az <APP_NAME> az előző lépésben szereplő függvényalkalmazás nevére. Ez a parancs felülírja a fájl meglévő értékeit.

    func azure functionapp fetch-app-settings <APP_NAME>

  2. Nyissa meg a local.settings.json fájlt, és keresse meg a AzureWebJobsStorage nevű értéket, amely a tároló fiók kapcsolati karakterlánca. A cikk más szakaszaiban a AzureWebJobsStorage nevet és a kapcsolati karakterláncot használja.

Fontos

Mivel a local.settings.json fájl Azure letöltött titkos kódokat tartalmaz, mindig zárja ki ezt a fájlt a forrásvezérlőből. A helyi függvény project ekkel létrehozott .gitignore fájl alapértelmezés szerint kizárja a fájlt.

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

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 definíciójának hozzáadása a függvényhez

Bár egy függvénynek csak egy eseményindítója lehet, több bemeneti és kimeneti kötéssel is rendelkezhet, így egyéni integrációs kód írása nélkül csatlakozhat más Azure szolgáltatásokhoz és erőforrásokhoz.

A Node.js v4 programozási modell használatakor a kötési attribútumok közvetlenül a ./src/functions/HttpExample.js fájlban vannak definiálva. Az előző rövid útmutatóban a fájl már tartalmaz egy a(z) app.http metódus által definiált HTTP-kötést.

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

app.http('httpTrigger', {
  methods: ['GET', 'POST'],
  authLevel: 'anonymous',
  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) {
        return { status: 404, body: 'Not Found' };
      }

      return { body: `Hello, ${name}!` };
    } catch (error) {
      context.log(`Error: ${error}`);
      return { status: 500, body: 'Internal Server Error' };
    }
  },
});

A Node.js v4 programozási modell használatakor a kötési attribútumok közvetlenül a ./src/functions/HttpExample.js fájlban vannak definiálva. Az előző rövid útmutatóban a fájl már tartalmaz egy a(z) app.http metódus által definiált HTTP-kötést.

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

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

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

  return { body: `Hello, ${name}!` };
}

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

Ezeket a kötéseket a függvénymappában lévő function.json fájlban deklarálja. Az előző rövid útmutatóban a HttpExample mappában lévő function.json fájl két kötést tartalmaz a bindings gyűjteményben:

A Python v2 programozási modell használatakor a kötési attribútumok közvetlenül a function_app.py fájlban dekorátorokként vannak definiálva. Az előző rövid útmutatóban a function_app.py fájl már tartalmaz egy dekorátoralapú kötést:

import azure.functions as func
import logging

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="hello", auth_level=func.AuthLevel.ANONYMOUS)

A route dekoratőr HttpTrigger- és HttpOutput-kötést ad hozzá a függvényhez, ami lehetővé teszi a függvény aktiválását, amikor a http-kérések elérik a megadott útvonalat.

Ha egy Azure Storage üzenetsorba szeretne írni ebből a függvényből, adja hozzá a queue_output dekoratőrt a függvény kódjához:

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

A dekorátorban 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 Storage-fiók kapcsolati karakterláncát. A gyors kezdő lépések során ugyanazt a tárolófiókot használja, mint a függvényalkalmazás, ami a AzureWebJobsStorage beállításban található (local.settings.json fájlból). Amikor a queue_name kötés nem létezik, az első használatkor hozza létre.

"bindings": [
  {
    "authLevel": "function",
    "type": "httpTrigger",
    "direction": "in",
    "name": "Request",
    "methods": [
      "get",
      "post"
    ]
  },
  {
    "type": "http",
    "direction": "out",
    "name": "Response"
  }
]

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: 'anonymous',
    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 gyűjtemény második kötése res névre lett elnevezve. Ez a http kötés egy kimeneti kötés (out), amely a HTTP-válasz megírására szolgál.

Ha ebből a függvényből szeretne Azure Storage üzenetsorba írni, adjon hozzá egy out típusú kötést queuemsg néven, ahogyan az alábbi kódban látható:

    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

queue típus esetén meg kell adnia az üzenetsor nevét a queueName mezőben, és az nevet az Azure Storage kapcsolat számára (a local.settings.json fájlból) a connection mezőben.

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 sztringek gyűjteményét jelöli. Ezek a sztringek üzenetként lesznek megírva egy kimeneti kötésbe, amikor a függvény befejeződik. 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. Olyan alkalmazásbeállítást adjon át, amely a Storage-fiók kapcsolati karakterláncot tartalmazza, ahelyett, hogy magát a kapcsolati karakterláncot adná át.

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

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

A kötések részleteiről további információt a Azure Functions triggerek és kötések fogalmai és kimenet konfigurációja című témakörben talál.

Kód hozzáadása a kimeneti kötés használatához

Az üzenetsor-kötés definiálva mostantól frissítheti a függvényt, hogy megkapja a msg kimeneti paramétert, és üzeneteket írjon az üzenetsorba.

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.

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

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 a következő példához hasonlóan kell kinéznie:

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 kódsort a //Invoke alatt 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);

Figyelje meg, hogy nem kell semmilyen kódot írnia a hitelesítéshez, az üzenetsor-hivatkozás lekéréséhez vagy az adatok írásához. Ezeket az integrációs feladatokat kényelmesen kezeli a Azure Functions futtatókörnyezet és az üzenetsor kimeneti kötése.

Függvény helyi futtatása

  1. Futtassa a függvényt úgy, hogy elindítja a helyi Azure Functions futtatókörnyezet gazdagépét a LocalFunctionProj mappából.

    func start

    A kimenet vége felé a következő soroknak kell megjelennie:

    A terminálablak kimenetének képernyőképe a helyi függvény futtatásakor.

    Megjegyzés

    Ha a HttpExample nem jelenik meg a fent látható módon, valószínűleg a gazdagépet a projekt gyökérmappáján kívülről indította el. Ebben az esetben használja a Ctrl+C parancsot a gazdagép leállításához, nyissa meg a project gyökérmappáját, és futtassa újra az előző parancsot.

  2. Másolja a HTTP-függvény URL-címét ebből a kimenetből egy böngészőbe, és fűzze hozzá a lekérdezési paramétereket ?name=<YOUR_NAME>, ehhez a teljes URL-cím a következőképpen néz ki: http://localhost:7071/api/HttpExample?name=Functions. A böngészőnek egy válaszüzenetet kell megjelenítenie, amely visszaadja a lekérdezési sztring értékét. Az a terminál, ahol elindította a projektet, a kérések során a naplókimenetet is megjeleníti.

  3. Ha végzett, nyomja le a Ctrl + C billentyűkombinációt, és írja be a függvénygazda y leállításához.

Az üzenet megtekintése a Azure Storage üzenetsorban

A sor megtekinthető az Azure portalon vagy a Microsoft Azure Storage Explorerben. Az Azure CLI-ban is megtekintheti a sort az alábbi lépések szerint:

  1. Nyissa meg a függvény project local.setting.json fájlját, és másolja ki a connection string értéket. Egy terminál vagy parancsablakban futtassa a következő parancsot egy AZURE_STORAGE_CONNECTION_STRING nevű környezeti változó létrehozásához, és illessze be az adott connection string a <MY_CONNECTION_STRING> helyett. (Ez a környezeti változó azt jelenti, hogy nem kell megadnia a csatlakozási karakterláncot minden további parancs számára a --connection-string argumentum használatával.)

    export AZURE_STORAGE_CONNECTION_STRING="<MY_CONNECTION_STRING>"

  2. (Nem kötelező) A az storage queue list paranccsal megtekintheti a fiók tárolási sorait. A parancs kimenetének tartalmaznia kell egy elnevezett üzenetsort outqueue, amely akkor jött létre, amikor a függvény az első üzenetét az üzenetsorba írta.

    az storage queue list --output tsv

  3. A az storage message get paranccsal olvassa be az üzenetet az üzenetsorból, amelynek a függvény korábbi tesztelése során megadott értéknek kell lennie. A parancs felolvassa és eltávolítja az első üzenetet az üzenetsorból.

    echo `echo $(az storage message get --queue-name outqueue -o tsv --query '[].{Message:content}') | base64 --decode`

    Mivel az üzenettörzs base64 kódolású van tárolva, az üzenetet a megjelenítés előtt dekódolni kell. A az storage message get végrehajtása után az üzenet el lesz távolítva az üzenetsorból. Ha csak egy üzenet volt benne outqueue, akkor nem fog üzenetet lekérni, amikor másodszor futtatja ezt a parancsot, hanem hibaüzenetet kap.

Az Azure-rendszerbe történő projekt újbóli üzembe helyezése

Miután helyileg ellenőrizte, hogy a függvény üzenetet írt-e a Azure Storage üzenetsorba, újra üzembe helyezheti a project a Azure futó végpont frissítéséhez.

A LocalFunctionsProj mappában használja a func azure functionapp publish parancsot a project ismételt üzembe helyezéséhez, és cserélje le a<APP_NAME> az alkalmazás nevére.

func azure functionapp publish <APP_NAME>

A helyi projekt mappában használja a következő Maven parancsot, hogy publikálja újra a projektet.

mvn azure-functions:deploy

Az Azure-ban való ellenőrzés

  1. Az előző rövid útmutatóhoz hasonlóan használjon böngészőt vagy CURL-t az újra üzembe helyezési függvény teszteléséhez.

    Másolja a közzétételi parancs kimenetében látható teljes meghívási URL-címet egy böngészőcímsávra a lekérdezési paraméter &name=Functionshozzáfűzésével. A böngészőnek ugyanazt a kimenetet kell megjelenítenie, mint amikor helyileg futtatta a függvényt.

  2. Vizsgálja meg újra a Storage üzenetsort az előző szakaszban leírtak szerint annak ellenőrzéséhez, hogy tartalmazza-e az üzenetsorba írt új üzenetet.

Az erőforrások megtisztítása

A befejezés után az alábbi paranccsal törölheti az erőforráscsoportot és annak összes tartalmazott erőforrását, hogy elkerülje a további költségek felmerülését.

az group delete --name AzureFunctionsQuickstart-rg

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 parancssori fejlesztéséről a Core Tools és a Azure CLI használatával:

  • Last updated on