Az Azure Functions parancssori eszközökkel történő Csatlakozás Az Azure Storage-ba

Cikk
04/27/2024

Ebben a cikkben integrál egy Azure Storage-üzenetsort az előző rövid útmutatóban létrehozott függvénysel é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 további költségekkel az előző rövid útmutató néhány USD centje után. A kötésekkel kapcsolatos további információkért tekintse meg az Azure Functions eseményindítóinak és kötéseinek alapelveit.

A helyi környezet konfigurálása

Mielőtt hozzákezdene, be kell fejeznie egy rövid útmutatót: Azure Functions-projekt létrehozása a parancssorból. Ha a cikk végén már megtisztította az erőforrásokat, végezze el újra a lépéseket a függvényalkalmazás és a kapcsolódó erőforrások Azure-beli újbóli létrehozásához.

Az Azure Storage kapcsolati sztring lekérése

Korábban létrehozott egy Azure Storage-fiókot a függvényalkalmazás használatához. A fiók kapcsolati sztring biztonságosan tárolja az Azure-beli alkalmazásbeállításokban. 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.

A projekt gyökerében futtassa a következő parancsot, és cserélje le <APP_NAME> a függvényalkalmazás nevét az előző lépésben. Ez a parancs felülírja a fájl meglévő értékeit.
```
func azure functionapp fetch-app-settings <APP_NAME>
```
Nyissa meg local.settings.json fájlt, és keresse meg a Storage-fiók kapcsolati sztring nevű AzureWebJobsStorageértéket. A cikk más szakaszaiban a nevet AzureWebJobsStorage és a kapcsolati sztring használja.

Fontos

Mivel a local.settings.json fájl az Azure-ból 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ényprojekttel 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álablakban a Storage bővítménycsomag projekthez való hozzáadásához.

Izolált folyamat
Folyamatban

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

dotnet add package Microsoft.Azure.WebJobs.Extensions.Storage

Most hozzáadhatja a tárkimeneti kötést a projekthez.

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 metódus által definiált HTTP-kötést app.http .

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

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 ebből a függvényből szeretne írni egy Azure Storage-üzenetsorba, adja hozzá a queue_output dekorátort a függvény kódjához:

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

A dekorátorban arg_name azonosítja a kódban hivatkozott kötési paramétert, annak az üzenetsornak a nevét, queue_name amelybe a kötés ír, és connection egy alkalmazásbeállítás neve, amely tartalmazza a Tárfiók kapcsolati sztring. A rövid útmutatókban ugyanazt a tárfiókot használja, mint a függvényalkalmazás, amely a AzureWebJobsStorage beállításban van (local.settings.json fájlból). Ha a queue_name kötés nem létezik, a kötés 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"
  }
]

Írás 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: 'anonymous',
    handler: () => {}
}

output.storageQueue Függvény hozzáadása a app.http hívás fölött

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

A gyűjtemény második kötésének neve res. 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 egy Azure Storage-üzenetsorba írni, adjon hozzá egy típuskötést outqueue a következő kódban látható névvel msg:

    {
      "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"
    }
  ]
}

Típus esetén queue meg kell adnia az üzenetsor queueName nevét, és meg kell adnia az Azure Storage-kapcsolat nevét (local.settings.json fájlból) a fájlbanconnection.

Egy C#-projektben 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.

Izolált feldolgozói modell
Folyamaton belüli modell

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

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

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

A Connection tulajdonság beállítja a tárfiók kapcsolati sztring. Ebben az esetben kihagyhatja Connection , mert már használja az alapértelmezett tárfiókot.

Fontos

A folyamaton belüli modell támogatása 2026. november 10-én megszűnik. Erősen javasoljuk, hogy az alkalmazásokat az elkülönített feldolgozói modellbe migrálja a teljes támogatás érdekében.

Nyissa meg a HttpExample.cs projektfájlt, és adja hozzá a következő paramétert a Run metódusdefinícióhoz:

[Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg,

A msg paraméter egy ICollector<T> típus, amely egy kimeneti kötésbe írt üzenetek gyűjteményét jelöli, amikor a függvény befejeződik. Ebben az esetben a kimenet egy tárolósor neve outqueue. A StorageAccountAttribute tárfiók kapcsolati sztring állítja be. Ez az attribútum azt a beállítást jelzi, amely tartalmazza a tárfiók kapcsolati sztring, és alkalmazható az osztály, a metódus vagy a paraméter szintjén. Ebben az esetben kihagyhatja StorageAccountAttribute , mert már használja az alapértelmezett tárfiókot.

A futtatási metódus definíciójának a következő kódhoz hasonlóan kell kinéznie:

[FunctionName("HttpExample")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, 
    [Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg, 
    ILogger log)

Egy Java-projektben a kötések a függvénymetódus kötési széljegyzeteiként vannak definiálva. 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 az src/main/java területen, nyissa meg a Function.java projektfá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 tárolósor neve outqueue. A Storage-fiók kapcsolati sztring a connection metódus állítja be. A Tárfiók kapcsolati sztring tartalmazó alkalmazásbeállítást adja át ahelyett, hogy a kapcsolati sztring ad á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 az Azure Functions eseményindítói és kötési fogalmai, valamint az üzenetsor kimeneti 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. A set metódus sztringüzenetet ír az üzenetsorba. Ebben az esetben ez az name URL-lekérdezési sztring függvényének átadott függvény.

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 az üzenetsorba a msg kimeneti kötés használatával. 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
})

Izolált feldolgozói modell
Folyamaton belüli modell

Cserélje le a meglévő HttpExample osztályt a következő kódra:

    [Function("HttpExample")]
    public static MultiResponse Run([HttpTrigger(AuthorizationLevel.Function, "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 storage output binding.
        return new MultiResponse()
        {
            // Write a single message.
            Messages = new string[] { message },
            HttpResponse = response
        };
    }
}

Fontos

Adjon hozzá egy kódot, amely a msg kimeneti kötési objektumot használja üzenetsor-üzenet létrehozásához. Adja hozzá ezt a kódot a metódus visszatérése előtt.

if (!string.IsNullOrEmpty(name))
{
    // Add a message to the output collection.
    msg.Add(name);
}

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

[FunctionName("HttpExample")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, 
    [Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg, 
    ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string name = req.Query["name"];

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic data = JsonConvert.DeserializeObject(requestBody);
    name = name ?? data?.name;

    if (!string.IsNullOrEmpty(name))
    {
        // Add a message to the output collection.
        msg.Add(name);
    }
    return name != null
        ? (ActionResult)new OkObjectResult($"Hello, {name}")
        : new BadRequestObjectResult("Please pass a name on the query string or in the request body");
}

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 a kimeneti kötés értékének name hozzáadásához msg .

msg.setValue(name);

Kimeneti kötés használatakor nem kell az 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 az src/test/java területen, nyissa meg a Function.java projektfájlt, és cserélje le a kódsort //Invoke 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. Ezek az integrációs feladatok kényelmesen kezelhetők az Azure Functions futtatókörnyezetében és az üzenetsor kimeneti kötésében.

Függvény helyi futtatása

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:

Feljegyzés

Ha a HttpExample nem jelenik meg a fent látható módon, valószínűleg a projekt gyökérmappájából indította el a gazdagépet. Ebben az esetben a Ctrl C billentyűkombinációval +állítsa le a gazdagépet, nyissa meg a projekt gyökérmappáját, és futtassa újra az előző parancsot.
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 sztringet ?name=<YOUR_NAME>, így a teljes URL-cím hasonló http://localhost:7071/api/HttpExample?name=Functionslesz. 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, amelyben elindította a projektet, a naplókimenetet is megjeleníti a kérések során.
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.

Tipp.

Az indítás során a gazdagép letölti és telepíti a Storage kötésbővítményt és más Microsoft-kötésbővítményeket . Ez a telepítés azért történik, mert a kötésbővítmények alapértelmezés szerint engedélyezve vannak a host.json fájlban az alábbi tulajdonságokkal:

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

Ha a kötésbővítményekkel kapcsolatos hibákat tapasztal, ellenőrizze, hogy a fenti tulajdonságok host.json találhatók-e.

Az üzenet megtekintése az Azure Storage üzenetsorában

Az üzenetsort az Azure Portalon vagy a Microsoft Azure Storage Explorerben tekintheti meg. Az üzenetsort az Azure CLI-ben is megtekintheti az alábbi lépésekben leírtak szerint:

Nyissa meg a függvényprojekt local.setting.json fájlját, és másolja ki a kapcsolati sztring értéket. Egy terminál vagy parancsablakban futtassa a következő parancsot egy környezeti változó létrehozásáhozAZURE_STORAGE_CONNECTION_STRING, és illessze be az adott kapcsolati sztring a <MY_CONNECTION_STRING>helyére. (Ez a környezeti változó azt jelenti, hogy nem kell megadnia a kapcsolati sztring minden további parancshoz az --connection-string argumentum használatával.)
```
export AZURE_STORAGE_CONNECTION_STRING="<MY_CONNECTION_STRING>"
```
```
$env:AZURE_STORAGE_CONNECTION_STRING = "<MY_CONNECTION_STRING>"
```
```
set AZURE_STORAGE_CONNECTION_STRING="<MY_CONNECTION_STRING>"
```
(Nem kötelező) az storage queue list A paranccsal megtekintheti a társorokat a fiókjában. 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
```
az storage message get A parancs használatával olvassa be az üzenetet ebből 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`
```
```
[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($(az storage message get --queue-name outqueue -o tsv --query '[].{Message:content}')))
```
```
az storage message get --queue-name outqueue -o tsv --query [].{Message:content} > %TEMP%out.b64 && certutil -decode -f %TEMP%out.b64 %TEMP%out.txt > NUL && type %TEMP%out.txt && del %TEMP%out.b64 %TEMP%out.txt /q
```
Ez a szkript a certutil használatával dekódolja a base64 kódolású üzenetgyűjteményt egy helyi ideiglenes fájlból. Ha nincs kimenet, próbálja meg eltávolítani > NUL a szkriptből, hogy ne tiltsa le a certutil kimenetet, ha hiba történt.
Mivel az üzenet törzse base64 kódolású, az üzenetet a megjelenítés előtt dekódolni kell. A végrehajtás az storage message getutá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.

A projekt ismételt üzembe helyezése az Azure-ban

Most, hogy helyileg ellenőrizte, hogy a függvény üzenetet írt-e az Azure Storage-üzenetsorba, újra üzembe helyezheti a projektet, hogy frissítse az Azure-ban futó végpontot.

A LocalFunctionsProj mappában a func azure functionapp publish paranccsal helyezze újra üzembe a projektet, és cserélje le<APP_NAME> az alkalmazás nevére.

func azure functionapp publish <APP_NAME>

A helyi projektmappában a következő Maven-paranccsal tegye közzé újra a projektet:

mvn azure-functions:deploy

Ellenőrzés az Azure-ban

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.
- Böngésző
- Curl
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.

Futtassa curl a meghívási URL-címet a paraméter &name=Functionshozzáfűzésével. A kimenetnek meg kell egyeznie a függvény helyi futtatásakor megadott kimenettel.
Vizsgálja meg újra a Storage-üzenetsort az előző szakaszban leírtak szerint, hogy ellenőrizze, hogy tartalmazza-e az üzenetsorba írt új üzenetet.

Az erőforrások eltávolítása

Ha végzett, az alábbi paranccsal törölje az erőforráscsoportot és annak összes benne foglalt 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

Frissítette a HTTP által aktivált függvényt, hogy adatokat írjon egy Storage-üzenetsorba. Most már többet is megtudhat a Functions parancssori fejlesztéséről a Core Tools és az Azure CLI használatával:

Az Azure Functions parancssori eszközökkel történő Csatlakozás Az Azure Storage-ba

A helyi környezet konfigurálása

Az Azure Storage kapcsolati sztring lekérése

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

Kimeneti kötés definíciójának hozzáadása a függvényhez

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

A tesztek frissítése

Függvény helyi futtatása

Az üzenet megtekintése az Azure Storage üzenetsorában

A projekt ismételt üzembe helyezése az Azure-ban

Ellenőrzés az Azure-ban

Az erőforrások eltávolítása

Következő lépések

További források