Connettere Azure Functions a Azure Storage usando gli strumenti da riga di comando

Prima di iniziare, è necessario completare l'articolo Quickstart: Creare un Azure Functions project dalla riga di comando. Se le risorse sono già state eliminate alla fine di questo articolo, eseguire di nuovo i passaggi per ricreare l'app per le funzioni e le risorse correlate in Azure.

Prima di iniziare, è necessario completare l'articolo Quickstart: Creare un Azure Functions project dalla riga di comando. Se le risorse sono già state eliminate alla fine di questo articolo, eseguire di nuovo i passaggi per ricreare l'app per le funzioni e le risorse correlate in Azure.

Prima di iniziare, è necessario completare l'articolo Quickstart: Creare un Azure Functions project dalla riga di comando. Se le risorse sono già state eliminate alla fine di questo articolo, eseguire di nuovo i passaggi per ricreare l'app per le funzioni e le risorse correlate in Azure.

Prima di iniziare, è necessario completare l'articolo Quickstart: Creare un Azure Functions project dalla riga di comando. Se le risorse sono già state eliminate alla fine di questo articolo, eseguire di nuovo i passaggi per ricreare l'app per le funzioni e le risorse correlate in Azure.

Prima di iniziare, è necessario completare l'articolo Quickstart: Creare un Azure Functions project dalla riga di comando. Se le risorse sono già state eliminate alla fine di questo articolo, eseguire di nuovo i passaggi per ricreare l'app per le funzioni e le risorse correlate in Azure.

Prima di iniziare, è necessario completare l'articolo Quickstart: Creare un Azure Functions project dalla riga di comando. Se le risorse sono già state eliminate alla fine di questo articolo, eseguire di nuovo i passaggi per ricreare l'app per le funzioni e le risorse correlate in Azure.

Registrare le estensioni delle associazioni

Ad eccezione dei trigger HTTP e timer, i binding vengono implementati come pacchetti di estensione. Eseguire il comando dotnet add package seguente nella finestra terminale per aggiungere il pacchetto di estensione Storage al project.

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

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

È ora possibile aggiungere l'associazione di output storage al project.

Aggiungere una definizione di binding di output alla funzione

Anche se una funzione può avere un solo trigger, può avere più associazioni di input e output, che consente di connettersi ad altri servizi e risorse Azure senza scrivere codice di integrazione personalizzato.

Quando si usa il modello di programmazione Node.js v4, gli attributi di associazione vengono definiti direttamente nel file ./src/functions/HttpExample.js . Nella guida di avvio rapido precedente, il file contiene già un binding HTTP definito dal metodo 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' };
    }
  },
});

Quando si usa il modello di programmazione Node.js v4, gli attributi di associazione vengono definiti direttamente nel file ./src/functions/HttpExample.js . Nella guida di avvio rapido precedente, il file contiene già un binding HTTP definito dal metodo app.http.

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

Questi binding vengono dichiarati nel file function.json nella cartella della funzione. Dall'argomento di avvio rapido precedente il file function.json nella cartella HttpExample contiene due binding nella raccolta bindings:

Quando si usa il modello di programmazione Python v2, gli attributi di associazione vengono definiti direttamente nel file function_app.py come elementi decorator. Dalla precedente guida di avvio rapido, il file function_app.py già contiene un binding basato sull'elemento Decorator:

import azure.functions as func
import logging

app = func.FunctionApp()

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

L'elemento Decorator route aggiunge il binding HttpTrigger e HttpOutput alla funzione, consentendo l'attivazione della funzione quando le richieste HTTP raggiungono la route indicata.

Per scrivere in una coda di Azure Storage da questa funzione, aggiungere il decoratore queue_output al codice della funzione.

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

Nel decoratore arg_name identifica il parametro di binding a cui si fa riferimento nel codice, queue_name è il nome della coda su cui scrive il binding e connection è il nome di un'impostazione dell'applicazione che contiene la stringa di connessione per l'account di archiviazione. Nei quickstart si usa lo stesso account di archiviazione dell'app per le funzioni, che si trova nell'impostazione AzureWebJobsStorage (dal file local.settings.json). Se queue_name non esiste, il binding lo crea al primo utilizzo.

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

Per scrivere in una coda di Azure Storage:

• Aggiungere una proprietà extraOutputs alla configurazione dell'associazione

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

• Aggiungere una funzione output.storageQueue sopra la chiamata app.http

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

Il secondo binding nella raccolta è denominato res. Questo binding http è un binding di output (out) usato per scrivere la risposta HTTP.

Per scrivere in una coda Azure Storage da questa funzione, aggiungere un'associazione out di tipo queue con il nome msg, come illustrato nel codice seguente:

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

Per un tipo queue, è necessario specificare il nome della coda in queueName e specificare il name della connessione Azure Storage (dal file local.settings.json) in connection.

In un project C# le associazioni vengono definite come attributi di associazione nel metodo della funzione. Definizioni specifiche dipendono dal fatto che l'app venga eseguita in-process (libreria di classi C#) o in un processo di lavoro isolato.

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

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

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

In un project Java, le associazioni vengono definite come annotazioni di associazione nel metodo della funzione. Il file function.json viene quindi generato automaticamente in base a queste annotazioni.

Passare al percorso del codice della funzione in src/main/java, aprire il file di progetto Function.java e aggiungere il seguente parametro alla definizione del metodo run:

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

Il parametro è un tipo /> outqueue. Il connection string per l'account Storage viene impostato dal metodo connection. Passare l'impostazione dell'applicazione che contiene il connection string dell'account Storage anziché passare il connection string stesso.

La definizione del run metodo deve ora essere simile all'esempio seguente:

@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) {
    ...
}

Aggiornare HttpExample\function_app.py in modo che corrisponda al codice seguente, aggiungendo il parametro msg alla definizione della funzione e msg.set(name) sotto l'istruzione if name::

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
        )

Il parametro msg è un'istanza del azure.functions.Out class. Il metodo set scrive un messaggio stringa nella coda. In questo caso, è il name passato alla funzione nella stringa di query dell'URL.

Aggiungere il codice che usa l'oggetto del binding di output in context.extraOutputs per creare un messaggio della coda. Aggiungere questo codice prima dell'istruzione return.

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

A questo punto, la funzione potrebbe essere come indicato di seguito:

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

Aggiungere il codice che usa l'oggetto del binding di output in context.extraOutputs per creare un messaggio della coda. Aggiungere questo codice prima dell'istruzione return.

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

A questo punto, la funzione potrebbe essere come indicato di seguito:

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

Aggiungere il codice che usa il cmdlet Push-OutputBinding per scrivere un testo nella coda usando il binding di output msg. Aggiungere questo codice prima di impostare lo stato OK nell'istruzione if.

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

A questo punto, la funzione deve essere come indicato di seguito:

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

Ora è possibile usare il nuovo parametro msg per scrivere nel binding di output dal codice della funzione. Aggiungere la seguente riga di codice prima della risposta di successo per aggiungere il valore di name al binding di output msg.

msg.setValue(name);

Quando si usa un'associazione di output, non è necessario usare il codice Azure Storage SDK per l'autenticazione, ottenere un riferimento alla coda o scrivere dati. Queste attività vengono eseguite automaticamente dal runtime di Funzioni e dal binding di output.

Il run metodo deve ora essere simile all'esempio seguente:

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

Aggiornare i test

Poiché l'archetipo crea anche un set di test, è necessario aggiornare questi test per gestire il nuovo parametro msg nella firma del metodo run.

Passare al percorso del codice di test in src/test/java, aprire il file Function.java project e sostituire la riga di codice in //Invoke con il codice seguente:

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

Nella cartella LocalFunctionsProj usare il comando func azure functionapp publish per ridistribuire il project, sostituendo<APP_NAME> con il nome dell'app.

func azure functionapp publish <APP_NAME>

Nella cartella project locale usare il comando Maven seguente per ripubblicare il project:

mvn azure-functions:deploy

• Esempi di progetti completi di funzione in C#.

• Informazioni di riferimento per sviluppatori Azure Functions C#

• Esempi di progetti completi di Funzione in JavaScript.

• Azure Functions Guida per sviluppatori JavaScript

• Esempi di progetti completi di Funzione in TypeScript.

• Azure Functions Guida per sviluppatori TypeScript

• Esempi di progetti completi di Funzione in Python.

• Azure Functions Guida per sviluppatori Python

• Esempi di progetti completi di funzioni in PowerShell.

• Azure Functions Guida per sviluppatori di PowerShell