Desenvolver Azure Functions localmente usando Core Tools

O Azure Functions Core Tools permite-lhe desenvolver e testar as suas funções no seu computador local. Quando estiveres pronto, também podes usar o Core Tools para implementar o teu projeto de código no Azure e trabalhar com as definições da aplicação.

Instale as Ferramentas Centrais do Azure Functions

A maneira recomendada de instalar o Core Tools depende do sistema operacional do seu computador de desenvolvimento local.

Para obter ajuda com problemas relacionados à versão, consulte Versões das ferramentas principais.

Criar o seu projeto local

Na janela do terminal ou em um prompt de comando, execute o seguinte comando para criar um projeto na MyProjFolder pasta:

func init MyProjFolder --worker-runtime dotnet-isolated 

func init MyProjFolder --worker-runtime dotnet 

func init MyProjFolder --worker-runtime javascript --model V4

func init MyProjFolder --worker-runtime javascript --model V3

func init MyProjFolder --worker-runtime typescript --model V4

func init MyProjFolder --worker-runtime typescript --model V3

func init MyProjFolder --worker-runtime powershell

func init MyProjFolder --worker-runtime python --model V2

func init MyProjFolder --worker-runtime python

Quando você executa func init sem a --worker-runtime opção, você é solicitado a escolher o idioma do projeto. Para saber mais sobre as opções disponíveis para o func init comando, consulte a func init referência.

Criar uma função

Para adicionar uma função ao seu projeto, execute o func new comando usando a --template opção para selecionar seu modelo de gatilho. O exemplo a seguir cria um gatilho HTTP chamado MyHttpTrigger:

func new --template "Http Trigger" --name MyHttpTrigger

Este exemplo cria um gatilho de Armazenamento de Filas chamado MyQueueTrigger:

func new --template "Azure Queue Storage Trigger" --name MyQueueTrigger

As seguintes considerações se aplicam ao adicionar funções:

• Quando você executa func new sem a --template opção, você é solicitado a escolher um modelo.

• Use o func templates list comando para ver a lista completa de modelos disponíveis para o seu idioma.

• Quando adiciona um gatilho que se liga a um serviço, também terá de adicionar ao ficheiro local.settings.json uma definição de aplicação que faça referência a uma cadeia de ligação ou a uma identidade gerida. Usar as configurações do aplicativo dessa maneira evita que você tenha que incorporar credenciais em seu código. Para obter mais informações, consulte Trabalhar com configurações de aplicativo localmente.

Para saber mais sobre as opções disponíveis para o func new comando, consulte a func new referência.

Adicionar uma vinculação à sua função

O Functions fornece um conjunto de ligações de entrada e saída específicas para cada serviço, que facilitam a ligação da sua função a outros serviços do Azure sem ter de usar os SDKs do cliente específicos do serviço. Para mais informações, veja conceitos de disparadores e ligações do Azure Functions.

Para adicionar uma ligação de entrada ou saída a uma função existente, você deve atualizar manualmente a definição de função.

O exemplo a seguir mostra a definição de função depois de adicionar uma vinculação de saída do Armazenamento de Fila a uma função desencadeada por HTTP:

[Function("HttpExample")]
public MultiResponse Run([HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequest req)
{

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

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

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

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

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

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

@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.')

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

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

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

As seguintes considerações se aplicam ao adicionar associações a uma função:

• Quando adiciona bindings que se ligam a um serviço, também deve adicionar uma definição de aplicação que faça referência a uma string de conexão ou identidade gerida ao ficheiro local.settings.json. Para obter mais informações, consulte Trabalhar com configurações de aplicativo localmente.

Iniciar o tempo de execução das Funções

Antes de executar ou depurar as funções em seu projeto, você precisa iniciar o host Functions a partir do diretório raiz do seu projeto. O host habilita gatilhos para todas as funções no projeto. Use este comando para iniciar o tempo de execução local:

mvn clean package 
mvn azure-functions:run

func start

func start

func start

npm install
npm start     

Quando o host Functions é iniciado, ele gera uma lista de funções no projeto, incluindo as URLs de quaisquer funções acionadas por HTTP, como neste exemplo:

Found the following functions:
Host.Functions.MyHttpTrigger

Job host started
Http Function MyHttpTrigger: http://localhost:7071/api/MyHttpTrigger

Tenha em mente as seguintes considerações ao executar suas funções localmente:

• Por padrão, a autorização não é imposta localmente para endpoints HTTP. Isso significa que todas as solicitações HTTP locais são tratadas como authLevel = "anonymous". Para obter mais informações, consulte Nível de autorização. Você pode usar a --enableAuth opção para exigir autorização ao executar localmente. Para mais informações, consulte func start

• Pode usar o emulador local do Azurite ao executar localmente funções que exigem acesso aos serviços do Azure Storage (Queue Storage, Blob Storage e Table Storage) sem ter de se ligar a estes serviços no Azure. Ao usar a emulação local, certifique-se de iniciar o Azurite antes de iniciar o host local (func.exe). Para obter mais informações, consulte Emulação de armazenamento local.

• Você pode acionar funções não-HTTP localmente sem se conectar a um serviço ativo. Para obter mais informações, consulte Executar uma função local.

• Quando você inclui as informações de conexão do Application Insights no arquivo local.settings.json, os dados de log locais são gravados na instância específica do Application Insights. Para manter os dados de telemetria locais separados dos dados de produção, considere o uso de uma instância separada do Application Insights para desenvolvimento e teste.

Executar uma função local

Com o host (func.exe) local do Functions em execução, agora você pode acionar funções individuais para executar e depurar seu código de função. A maneira como você executa uma função individual depende de seu tipo de gatilho.

http://localhost:<PORT>/api/<FUNCTION_NAME>

curl --get http://localhost:7071/api/MyHttpTrigger?name=Azure%20Rocks

curl --request POST http://localhost:7071/api/MyHttpTrigger --data '{"name":"Azure Rocks"}'

curl --request POST http://localhost:7071/api/MyHttpTrigger --data "{'name':'Azure Rocks'}"

http://localhost:<PORT>/admin/functions/<FUNCTION_NAME>

{
    "input": "<TRIGGER_INPUT>"
}

curl --request POST -H "Content-Type:application/json" --data '{"input":"sample queue data"}' http://localhost:7071/admin/functions/QueueTrigger

curl --request POST -H "Content-Type:application/json" --data "{'input':'sample queue data'}" http://localhost:7071/admin/functions/QueueTrigger

Publicar no Azure

O Azure Functions Core Tools suporta três tipos de implementação:

Tens de ter instalado localmente o Azure CLI ou Azure PowerShell para poderes publicar para Azure a partir do Core Tools. Por padrão, o Core Tools utiliza estas ferramentas para autenticar-se na sua conta do Azure.

Se você não tiver essas ferramentas instaladas, precisará obter um token de acesso válido para usar durante a implantação. Você pode apresentar um token de acesso usando a --access-token opção nos comandos de implantação.

Implantar arquivos de projeto

func azure functionapp publish <FunctionAppName>

mvn azure-functions:deploy

Implantar contêineres

O Core Tools permite-lhe implementar a sua aplicação de funções containerizada tanto para ambientes Azure Container Apps geridos como para clusters Kubernetes que gere.

func azurecontainerapps deploy --name <APP_NAME> --environment <ENVIRONMENT_NAME> --storage-account <STORAGE_CONNECTION> --resource-group <RESOURCE_GROUP> --image-name <IMAGE_NAME> [--registry-password] [--registry-server] [--registry-username]

func kubernetes deploy --name <DEPLOYMENT_NAME> --registry <REGISTRY_USERNAME> 

Trabalhar com as configurações do aplicativo localmente

Quando a sua aplicação de funções corre em Azure, as definições exigidas pelas suas funções são armazenadas encriptadas nas definições da app. Durante o desenvolvimento local, essas configurações são adicionadas à coleção Values no arquivo local.settings.json. O arquivo local.settings.json também armazena as configurações usadas pelas ferramentas de desenvolvimento local.

Os itens da coleção Values no ficheiro local.settings.json do seu projeto destinam-se a espelhar itens nas definições application da sua aplicação de funções no Azure.

As seguintes considerações se aplicam ao trabalhar com o arquivo de configurações locais:

• Como o local.settings.json pode conter segredos, como cadeias de conexão, você nunca deve armazená-lo em um repositório remoto. As Ferramentas Principais ajudam-no a encriptar este ficheiro de definições locais para melhorar a segurança. Para obter mais informações, consulte Arquivo de configurações locais. Você também pode criptografar o arquivo local.settings.json para maior segurança.

• Por defeito, as definições locais não são migradas automaticamente quando o projeto é publicado para o Azure. Usa a opção --publish-local-settings quando publicares os ficheiros do projeto para garantir que estas definições são adicionadas à aplicação de funções no Azure. Os valores na ConnectionStrings seção nunca são publicados. Você também pode carregar configurações do arquivo local.settings.json a qualquer momento.

• Podes descarregar e sobrescrever as definições do teu ficheiro local.settings.json com as definições da tua aplicação de funções no Azure. Para obter mais informações, consulte Baixar configurações do aplicativo.

• Quando não há uma cadeia de conexão de armazenamento válida definida para AzureWebJobsStorage e um emulador de armazenamento local não está a ser usado, aparece um erro. Podes usar o Core Tools para descarregar um connection string específico de qualquer uma das tuas contas Azure Storage.

Baixar configurações do aplicativo

A partir da raiz do projeto, use o seguinte comando para descarregar todas as definições da aplicação myfunctionapp12345 em Azure:

func azure functionapp fetch-app-settings myfunctionapp12345

Este comando sobrescrive quaisquer definições existentes no ficheiro local.settings.json com valores de Azure. Quando ainda não estão presentes, novos itens são adicionados à coleção. Para obter mais informações, consulte o func azure functionapp fetch-app-settings comando.

Descarregar uma cadeia de ligação de armazenamento

O Core Tools também facilita a obtenção da connection string de qualquer conta de armazenamento a que tenha acesso. A partir da raiz do projeto, use o seguinte comando para descarregar o connection string de uma conta de armazenamento chamada mystorage12345.

func azure storage fetch-connection-string mystorage12345

Este comando adiciona uma definição chamada mystorage12345_STORAGE ao ficheiro local.settings.json, que contém a connection string para a conta mystorage12345. Para obter mais informações, consulte o func azure storage fetch-connection-string comando.

Para melhorar a segurança durante o desenvolvimento, considere criptografar o arquivo local.settings.json.

Carregar definições locais para o Azure

Quando publicas os ficheiros do teu projeto para Azure sem usar a opção --publish-local-settings, as definições no ficheiro local.settings.json não estão definidas na tua aplicação de funções. Você pode sempre voltar a executar o func azure functionapp publish com a opção --publish-settings-only para carregar apenas as configurações sem publicar novamente os arquivos do projeto.

O exemplo seguinte carrega apenas as definições da coleção Values no ficheiro local.settings.json para a aplicação de funções em Azure chamada myfunctionapp12345:

func azure functionapp publish myfunctionapp12345 --publish-settings-only

Criptografar o arquivo de configurações locais

Para melhorar a segurança das cadeias de conexão e outros dados valiosos em suas configurações locais, as Ferramentas Principais permitem criptografar o arquivo local.settings.json. Quando este ficheiro é encriptado, o runtime desencripta automaticamente as definições quando necessário, tal como acontece com as definições de aplicação no Azure. Também pode desencriptar um ficheiro encriptado localmente para trabalhar com as configurações.

Use o seguinte comando para criptografar o arquivo de configurações locais para o projeto:

func settings encrypt

Use o seguinte comando para descriptografar uma configuração local criptografada, para que você possa trabalhar com ela:

func settings decrypt

Quando o ficheiro de definições é encriptado e desencriptado, a definição do IsEncrypted ficheiro também é atualizada.

Configurar extensões de vinculação

Functions triggers e bindings são implementados como pacotes de extensão .NET (NuGet). Para poder usar uma extensão de vinculação específica, essa extensão deve ser instalada no projeto.

Versões do Core Tools

As principais versões do Azure Functions Core Tools estão ligadas a versões principais específicas do runtime do Azure Functions. Por exemplo, a versão 4.x do Core Tools suporta a versão 4.x do tempo de execução do Functions. Esta versão é a versão principal recomendada do tempo de execução do Functions e do Core Tools. Pode consultar a versão mais recente do Core Tools no repositório Azure Functions Core Tools.

Execute o seguinte comando para determinar a versão da instalação atual do Core Tools:

func --version

Salvo indicação em contrário, os exemplos neste artigo referem-se à versão 4.x.

As seguintes considerações se aplicam às instalações do Core Tools:

• Você só pode instalar uma versão do Core Tools em um determinado computador.

• Ao atualizar para a versão mais recente do Core Tools, você deve usar o mesmo método usado para a instalação original para executar a atualização. Por exemplo, se usou um MSI no Windows, desinstale o MSI atual e instale o mais recente. Ou, se você usou npm, execute novamente o npm install commandarquivo .

• As versões 2.x e 3.x do Core Tools foram usadas com as versões 2.x e 3.x do runtime do Functions, que chegaram ao fim do suporte. Para mais informações, consulte Azure Functions - visão geral das versões do runtime.

Próximos passos

Aprenda a desenvolver, testar e publicar funções do Azure utilizando as ferramentas principais do Azure Functions. Azure Functions Core Tools é open source e está alojada em GitHub. Para apresentar um relatório de bug ou pedido de funcionalidade, criar um problema no GitHub.