Partilhar via

Ligue o Azure Functions ao Azure Storage usando o Visual Studio Code

O Azure Functions permite-te ligar serviços Azure e outros recursos a funções sem teres de escrever o teu próprio código de integração. Essas ligações, que representam entrada e saída, são declaradas dentro da definição de função. Os dados de enlaces são fornecidos à função como parâmetros. Um gatilho é um tipo especial de ligação de entrada. Embora uma função tenha apenas um gatilho, ela pode ter várias ligações de entrada e saída. Para saber mais, consulte Azure Functions gatilhos e conceitos de ligações.

Neste artigo, aprende como usar o Visual Studio Code para ligar o Azure Storage à função que criou no artigo de início rápido anterior. A ligação de saída que você adiciona para esta função escreve dados do pedido HTTP numa mensagem numa fila de armazenamento do Azure Queue.

A maioria das ligações requer uma cadeia de ligação armazenada que o Funções usa para acesso ao serviço vinculado. Para facilitar, usa a conta de armazenamento que criou com a sua aplicação de função. A conexão com essa conta já está armazenada em uma configuração de aplicativo chamada AzureWebJobsStorage.

Nota

Este artigo suporta atualmente Node.js v4 para funções.

Configure seu ambiente local

Antes de começar, você deve atender aos seguintes requisitos:

  • Instala a extensão Azure Storage para Visual Studio Code.

  • Instala Azure Storage Explorer. O Storage Explorer é uma ferramenta que vais usar para examinar as mensagens da fila geradas pela tua ligação de saída. O Storage Explorer é suportado em sistemas operativos baseados em macOS, Windows e Linux.

Este artigo assume que já está autenticado na sua subscrição do Azure através do Visual Studio Code. Pode iniciar sessão executando Azure: Sign In a partir da paleta de comandos.

Baixe as configurações do aplicativo de função

No artigo de início rápido anterior, criou uma aplicação de funções no Azure, juntamente com a conta de armazenamento necessária. A connection string desta conta está armazenada de forma segura nas definições da aplicação no Azure. Neste artigo, escreve mensagens para uma fila de armazenamento na mesma conta. Para se ligar à sua conta storage ao executar a função localmente, deve descarregar as definições da aplicação para o ficheiro local.settings.json.

  1. Pressione F1 para abrir a paleta de comandos, depois procure e execute o comando Azure Functions: Download Remote Settings....

  2. Escolha o aplicativo de função que você criou no artigo anterior. Selecione Sim para todos para substituir as configurações locais existentes.

    Importante

    Como o arquivo local.settings.json contém segredos, ele nunca é publicado e é excluído do controle de origem.

  3. Copie o valor AzureWebJobsStorage, que é o valor da chave da cadeia de conexão da conta de armazenamento. Use essa conexão para verificar se a ligação de saída funciona conforme o esperado.

Registar extensões de associação

Como estás a usar uma ligação de saída de storage em fila, tens de ter a extensão Storage bindings instalada antes de executares o projecto.

O seu projeto foi configurado para usar conjuntos de extensões, que instalam automaticamente um conjunto predefinido de pacotes de extensão.

Pacotes de extensões já estão ativados no ficheiro host.json na raiz do projeto, que deve assemelhar-se ao exemplo seguinte:

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

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

O seu projeto foi configurado para usar conjuntos de extensões, que instalam automaticamente um conjunto predefinido de pacotes de extensão.

Pacotes de extensões já estão ativados no ficheiro host.json na raiz do projeto, o qual deve ficar com o seguinte exemplo:

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

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

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

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

Adicionar um enlace de saída

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: 'function',
    handler: () => {}
}

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

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

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: 'function',
    handler: () => {}
}

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

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

Em Funções, cada tipo de ligação requer um direction, type e um único name. A maneira como você define esses atributos depende do idioma do seu aplicativo de função.

Os atributos de associação são definidos no arquivo function.json para uma determinada função. Dependendo do tipo de ligação, propriedades adicionais podem ser necessárias. A configuração de saída queue descreve os campos necessários para uma ligação de fila Azure Storage. A extensão facilita a adição de ligações ao arquivo function.json .

Para criar uma ligação, clique com o botão direito do mouse (Ctrl+clique no macOS) no function.json arquivo na pasta HttpTrigger e escolha Adicionar ligação.... Siga os prompts para definir as seguintes propriedades de vinculação para a nova vinculação:

Pedido valor Descrição
Selecionar direção de vinculação out A ligação é uma ligação de saída.
Selecione a vinculação com a direção... Azure Queue Storage A associação é uma associação de fila do Azure Storage.
O nome usado para identificar essa associação em seu código msg Nome que identifica o parâmetro de vinculação referenciado em seu código.
A fila para a qual a mensagem será enviada outqueue O nome da fila para a qual a ligação escreve. Quando o queueName não existe, a associação o cria no primeiro uso.
Selecione configuração a partir de "local.setting.json" AzureWebJobsStorage O nome de uma configuração de aplicação que contém a connection string para a conta Storage. A definição AzureWebJobsStorage contém a string de conexão da conta de armazenamento que criou com a aplicação de funções.

Uma vinculação é adicionada à bindings matriz no seu function.json, que deve ter a seguinte aparência:

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

Os atributos de vinculação são definidos decorando o código de função específico no arquivo function_app.py . Usas o decorador queue_output para adicionar uma ligação de saída Azure Queue storage.

Ao usar o decorador queue_output, a direção de ligação é implicitamente 'out' e o tipo é Azure Storage Queue. Adicione o seguinte decorador ao seu código de função em function_app.py:

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

Neste código, arg_name identifica o parâmetro de ligação referenciado no seu código, queue_name é o nome da fila para a qual 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. Nos quickstarts, utilizas a mesma conta de armazenamento que a aplicação de funções, que está na configuração AzureWebJobsStorage. Quando o queue_name não existe, a ligação cria-o na primeira utilização.

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.

Abra o ficheiro HttpExample.cs project e adicione a seguinte classe MultiResponse:

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

A classe MultiResponse permite-lhe escrever numa fila de storage chamada outqueue e numa mensagem HTTP de sucesso. Várias mensagens podem ser enviadas para a fila porque o QueueOutput atributo é aplicado a uma matriz de cadeia de caracteres.

A propriedade Connection define a cadeia de conexão para a conta de armazenamento. Neste caso, podes omitir Connection porque já estás a usar a conta storage padrão.

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 que são escritas como mensagens numa ligação de saída quando a função termina. Neste caso, a saída é uma fila de armazenamento chamada outqueue. O connection string para a conta Storage é definido pelo método connection. Em vez de passar a cadeia de ligação em si, passa a definição de aplicação que contém a cadeia de ligação da conta Storage.

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

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

Adicione código que utiliza a vinculação de saída

Depois de definida a ligação, pode usar o name da ligação para a aceder como um atributo na assinatura da função. Ao usar uma vinculação de saída, não precisa de usar o código do SDK do Azure Storage para autenticação, aceder a uma referência de fila ou escrever dados. O runtime do Functions e a associação de saída da fila realizam essas tarefas por você.

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

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.

Substitua o método existente Run pelo seguinte código:

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

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 runtime do Functions e a associação de saída da fila realizam essas tarefas por você.

O seu método run deve agora estar semelhante ao seguinte exemplo:

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

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 sob //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);

Executar a função localmente

Visual Studio Code integra com Azure Functions Core ferramentas para que possa executar este projeto no seu computador local de desenvolvimento antes de publicar no Azure. Se ainda não tiver o Core Tools instalado localmente, é solicitado a instalá-lo na primeira vez que executa o seu projecto.

  1. Para chamar a sua função, pressione F5 para iniciar o projeto da aplicação da função. O painel Terminal exibe a saída das Ferramentas Principais. Seu aplicativo é iniciado no painel Terminal . Você pode ver o endpoint de URL da sua função acionada por HTTP que está a ser executada localmente.

    Captura de ecrã da saída da função Local no Visual Studio Code.

    Se ainda não tiver o Core Tools instalado, selecione Install para instalar o Core Tools quando solicitado to do isso.
    Se tiveres dificuldades a correr no Windows, certifica-te de que o terminal predefinido para Visual Studio Code não está definido para WSL Bash.

  2. Com as Ferramentas Principais a funcionar, vai à área Azure: Funções. Em Funções, expanda Local Project>Funções. Clique com o botão direito do mouse (Windows) ou Ctrl - clique em (macOS) na HttpExample função e escolha Executar função agora....

    Captura de ecrã da função de execução agora a partir de Visual Studio Code.

  3. No corpo da solicitação Enter, pressione Enter para enviar uma mensagem de solicitação para sua função.

  4. Quando a função é executada localmente e devolve uma resposta, uma notificação é gerada no Visual Studio Code. As informações sobre a execução da função são mostradas no painel Terminal .

  5. Pressione Ctrl + C para parar as ferramentas principais e desconectar o depurador.

Executar a função localmente

  1. Como no artigo anterior, pressione F5 para iniciar o projeto da aplicação de funções e as Ferramentas Principais.

  2. Com as Ferramentas Principais a funcionar, vai à área Azure: Funções. Em Funções, expanda Local Project>Funções. Clique com o botão direito do rato (Ctrl-clique no Mac) na HttpExample função e selecione Executar Função Agora....

    Captura de ecrã da função em execução do Visual Studio Code.

  3. No Enter request body, vê o valor do corpo da mensagem de { "name": "Azure" }. Prima Enter para enviar esta mensagem de pedido para a sua função.

  4. Depois que uma resposta for retornada, pressione Ctrl + C para parar as Ferramentas Principais.

Como está a usar o storage connection string, a sua função liga-se à conta Azure storage quando está a correr localmente. Uma nova fila chamada outqueue é criada na sua conta de storage pelo runtime Functions quando a ligação de saída é usada pela primeira vez. Vais usar o Storage Explorer para verificar se a fila foi criada juntamente com a nova mensagem.

Ligue o Storage Explorer à sua conta

Salta esta secção se já instalaste o Azure Storage Explorer e o ligaste à tua conta Azure.

  1. Execute a ferramenta Azure Storage Explorer, selecione o ícone de ligação à esquerda e selecione Adicionar uma conta.

    Captura de ecrã de como adicionar uma conta Azure à Microsoft Azure Storage Explorer.

  2. No diálogo Conectar, escolha Adicionar uma conta Azure, escolha o seu ambiente Azure e depois selecione Iniciar sessão... .

    Captura de ecrã do início de sessão na janela da sua conta Azure.

Depois de iniciar sessão com sucesso na sua conta, vê todas as subscrições do Azure associadas à sua conta. Escolha a sua subscrição e selecione Abrir Explorer.

Examinar a fila de saída

  1. No Visual Studio Código, pressione F1 para abrir a paleta de comandos, depois procure e execute o comando Azure Storage: Open in Storage Explorer e escolha o nome da sua conta storage. A sua conta de armazenamento abre no Azure Storage Explorer.

  2. Expanda o nó Filas e, em seguida, selecione a fila chamada outqueue.

    A fila contém a mensagem que a ligação de saída da fila criou quando executou a função acionada por HTTP. Se invocar a função com o valor padrão nameAzure, a mensagem da fila é Nome passado para a função: Azure.

    Captura de ecrã da mensagem da fila mostrada em Azure Storage Explorer.

  3. Execute a função novamente, envie outra solicitação e você verá uma nova mensagem na fila.

Agora, é altura de republicar a aplicação de funções atualizada no Azure.

Reimplantar e verificar o aplicativo atualizado

  1. Em Visual Studio Código, pressione F1 para abrir a paleta de comandos. Na paleta de comandos, procure e selecione Azure Functions: Deploy to function app....

  2. Escolha o aplicativo de função que você criou no primeiro artigo. Como estás a redistribuir o teu project na mesma aplicação, seleciona Deploy para ignorar o aviso sobre sobrescrever ficheiros.

  3. Depois de concluída a implantação, pode voltar a usar a função Executar Agora... para ativar a função em Azure. Este comando recupera automaticamente a chave de acesso à função e utiliza-a ao chamar o endpoint HTTP trigger.

  4. Mais uma vez, visualizar a mensagem na fila de armazenamento para verificar se a ligação de saída gera uma nova mensagem na fila.

Limpar recursos

Em Azure, recursos referem-se a aplicações de funções, funções, contas de armazenamento, e assim por diante. Eles são agrupados em grupos de recursos e você pode excluir tudo em um grupo excluindo o grupo.

Você criou recursos para completar estas introduções rápidas. Pode ser cobrado por estes recursos, dependendo do estado da sua conta e dos preços dos serviços. Se já não precisar dos recursos, pode eliminá-los da seguinte forma:

  1. Em Visual Studio Código, pressione F1 para abrir a paleta de comandos. Na paleta de comandos, procure e selecione Azure: Open in portal.

  2. Escolha seu aplicativo de função e pressione Enter. A página da aplicação de funções abre no portal do Azure.

  3. Na guia Visão geral, selecione o link nomeado ao lado de Grupo de recursos.

    Captura de ecrã a mostrar a seleção do grupo de recursos a eliminar da página da aplicação de funções.

  4. Na página Grupo de recursos, revise a lista de recursos incluídos e verifique se eles são aqueles que você deseja excluir.

  5. Selecione Eliminar grupo de recursos e siga as instruções.

    A eliminação pode demorar alguns minutos. Quando terminar, é apresentada uma notificação durante alguns segundos. Também pode selecionar o ícone de sino na parte superior da página para ver a notificação.

Próximos passos

Atualizaste a tua função ativada por HTTP para escrever dados numa fila de armazenamento. Agora pode aprender mais sobre o desenvolvimento de Funções usando o Visual Studio Code:

  • Last updated on