Ligue o Azure Functions ao Azure Storage usando ferramentas de linha de comandos

Antes de começar, deve completar o artigo, Quickstart: Crie um Azure Functions project a partir da linha de comandos. Se já limpaste os recursos no final desse artigo, repete os passos para recriar a aplicação de funções e os recursos relacionados no Azure.

Antes de começar, deve completar o artigo, Quickstart: Crie um Azure Functions project a partir da linha de comandos. Se já limpaste os recursos no final desse artigo, repete os passos para recriar a aplicação de funções e os recursos relacionados no Azure.

Antes de começar, deve completar o artigo, Quickstart: Crie um Azure Functions project a partir da linha de comandos. Se já limpaste os recursos no final desse artigo, repete os passos para recriar a aplicação de funções e os recursos relacionados no Azure.

Antes de começar, deve completar o artigo, Quickstart: Crie um Azure Functions project a partir da linha de comandos. Se já limpaste os recursos no final desse artigo, repete os passos para recriar a aplicação de funções e os recursos relacionados no Azure.

Antes de começar, deve completar o artigo, Quickstart: Crie um Azure Functions project a partir da linha de comandos. Se já limpaste os recursos no final desse artigo, repete os passos para recriar a aplicação de funções e os recursos relacionados no Azure.

Antes de começar, deve completar o artigo, Quickstart: Crie um Azure Functions project a partir da linha de comandos. Se já limpaste os recursos no final desse artigo, repete os passos para recriar a aplicação de funções e os recursos relacionados no Azure.

Registar extensões de associação

Exceto para gatilhos HTTP e timer, as ligações são implementadas como pacotes de extensão. Execute o seguinte comando dotnet add package na janela do Terminal para adicionar o pacote de extensão Storage ao seu project.

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

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

Agora, podes adicionar a vinculação de saída de armazenamento ao teu projeto.

Adicionar uma definição de vinculação de saída à função

Embora uma função possa ter apenas um trigger, pode ter múltiplas ligações de entrada e saída, o que permite conectar-se a outros serviços e recursos do Azure sem escrever código de integração personalizado.

Ao usar o modelo de programação Node.js v4, os atributos de ligação são definidos diretamente no arquivo ./src/functions/HttpExample.js . A partir do início rápido anterior, seu arquivo já contém uma ligação HTTP definida pelo app.http método.

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

Ao usar o modelo de programação Node.js v4, os atributos de ligação são definidos diretamente no arquivo ./src/functions/HttpExample.js . A partir do início rápido anterior, seu arquivo já contém uma ligação HTTP definida pelo app.http método.

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

Você declara essas associações no arquivo function.json na sua pasta de funções. A partir do arranque rápido anterior, o seu arquivo function.json na pasta HttpExample contém duas associações na bindings coleção de configurações:

Ao usar o modelo de programação Python v2, os atributos de ligação são definidos diretamente no arquivo function_app.py como decoradores. A partir do início rápido anterior, seu arquivo de function_app.py já contém uma ligação baseada em decorador:

import azure.functions as func
import logging

app = func.FunctionApp()

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

O route decorador adiciona a ligação HttpTrigger e HttpOutput à função, o que permite que sua função seja acionada quando as solicitações http atingem a rota especificada.

Para escrever numa fila de Azure Storage a partir desta função, adicione o decorador queue_output ao seu código de função:

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

No decorador, arg_name identifica o parâmetro de ligação referenciado no seu código, queue_name é o nome da fila onde a ligação escreve, e connection é o nome de uma configuração de aplicação que contém a cadeia de ligação para a conta de armazenamento. Em inícios rápidos, utiliza-se a mesma conta de armazenamento do aplicativo de funções, que se encontra na definição AzureWebJobsStorage (do ficheiro local.settings.json). Quando o queue_name não existe, a ligação cria-o na primeira utilização.

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

Para escrever numa fila do Azure Storage:

• Adicionar uma extraOutputs propriedade à configuração de vinculação

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

• Adicionar uma output.storageQueue função acima da app.http chamada

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

A segunda ligação na coleção é denominada res. Essa http associação é uma ligação de saída (out) que é usada para gravar a resposta HTTP.

Para escrever numa fila de Azure Storage a partir desta função, adicione uma ligação out do tipo queue com o nome msg, conforme mostrado no código abaixo:

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

Para um tipo queue, deve especificar o nome da fila em queueName e fornecer o nome da ligação Azure Storage (do ficheiro local.settings.json) em connection.

Num project C#, as ligações são definidas como atributos de ligação no método da função. As definições específicas dependem se seu aplicativo é executado em processo (biblioteca de classes C#) ou em um processo de trabalho isolado.

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)

Num projeto Java, as ligações são definidas como anotações de ligação no método de função. O arquivo function.json é gerado automaticamente com base nessas anotações.

Navegue até à localização do seu código de função em src/main/java, abra o ficheiro Function.java project e adicione o seguinte parâmetro à definição do método run:

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

O parâmetro msg é um tipo OutputBinding<T>, que representa uma coleção de cadeias. Essas cadeias de caracteres são gravadas como mensagens para uma ligação de saída quando a função é concluída. Neste caso, a saída é uma fila de armazenamento chamada outqueue. O connection string para a conta Storage é definido pelo método connection. Passa a definição de aplicação que contém a cadeia de conexão da conta de armazenamento, em vez de passar a própria cadeia de conexão.

A run definição do método agora deve se parecer com o exemplo a seguir:

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

Atualize HttpExample\function_app.py para corresponder ao código a seguir, adicione o msg parâmetro à definição da função e msg.set(name) sob a if name: instrução:

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
        )

O parâmetro msg é uma instância do azure.functions.Out class. O set método grava uma mensagem de texto na fila. Nesse caso, é o name passado para a função na string de consulta do URL.

Adicione código que utilize o objeto de vinculação de saída em context.extraOutputs para criar uma mensagem de fila. Adicione este código antes da instrução return.

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

Neste ponto, sua função pode ter a seguinte aparência:

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

Adicione código que utilize o objeto de vinculação de saída em context.extraOutputs para criar uma mensagem de fila. Adicione este código antes da instrução return.

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

Neste ponto, sua função pode ter a seguinte aparência:

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

Adicione código que usa o Push-OutputBinding cmdlet para gravar texto na fila usando a msg associação de saída. Adicione este código antes de definir o status OK na if instrução.

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

Neste ponto, sua função deve ter a seguinte aparência:

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

Agora, pode usar o novo parâmetro msg para gravar na vinculação de saída do seu código de função. Adicione a seguinte linha de código antes da resposta de sucesso para adicionar o valor de name à ligação de saída de msg.

msg.setValue(name);

Quando usas uma ligação de saída, não precisas de usar o código do SDK do Azure Storage para autenticação, obter uma referência de fila ou escrever dados. O tempo de execução do Functions e a vinculação de saída da fila fazem essas tarefas por você.

O seu run método deve agora parecer-se com o exemplo a seguir:

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

Atualizar os testes

Como o arquétipo também cria um conjunto de testes, você precisa atualizar esses testes para manipular o novo msg parâmetro na assinatura do run método.

Navegue até à localização do seu código de teste em src/test/java, abra o ficheiro Function.java project e substitua a linha de código em //Invoke pelo seguinte código:

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

Na pasta LocalFunctionsProj, use o comando func azure functionapp publish para redistribuir o project, substituindo<APP_NAME> pelo nome da sua aplicação.

func azure functionapp publish <APP_NAME>

Na pasta do projeto local, use o seguinte comando Maven para republicar o seu projeto.

mvn azure-functions:deploy

• Exemplos de projetos completos de Funções em C#.

• Azure Functions Referência de desenvolvimento em C#

• Exemplos de projetos completos de Funções em JavaScript.

• Azure Functions Guia para programadores JavaScript

• Exemplos de projetos completos de Funções em TypeScript.

• Azure Functions Guia para desenvolvedores TypeScript

• Exemplos de projetos completos de Funções em Python.

• Azure Functions Guia para programadores Python

• Exemplos de projetos completos de Funções em PowerShell.

• Azure Functions Guia para programadores PowerShell