Desenvolva o Azure Functions localmente usando as Ferramentas Principais

As Ferramentas Principais do Azure Functions permitem-lhe desenvolver e testar as suas funções no seu computador local. Quando estiver pronto, você também poderá usar as Ferramentas Principais para implantar seu projeto de código no Azure e trabalhar com as configurações do aplicativo.

Instalar as Ferramentas de Núcleo de Funções do Azure

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.

• Ao adicionar um gatilho que se conecta a um serviço, você também precisará adicionar uma configuração de aplicativo que faça referência a uma cadeia de conexão ou uma identidade gerenciada ao arquivo local.settings.json. 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 ligação à sua função

O Functions fornece um conjunto de ligações de entrada e saída específicas do serviço, que facilitam a conexão da sua função com outros serviços do Azure sem precisar usar os SDKs de cliente específicos do serviço. Para obter mais informações, veja Conceitos de acionadores e enlaces das Funções do Azure.

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 ligação de saída de armazenamento de fila a uma função acionada por HTTP:

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

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.Anonymous, "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) {

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

{
  "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:

• Ao adicionar associações que se conectam a um serviço, você também deve adicionar uma configuração de aplicativo que faça referência a uma cadeia de conexão ou identidade gerenciada ao arquivo local.settings.json. Para obter mais informações, consulte Trabalhar com configurações de aplicativo localmente.

Iniciar o tempo de execução do Functions

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

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 pontos de extremidade 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

• Você pode usar o emulador local do Azurite ao executar localmente funções que exigem acesso aos serviços de Armazenamento do Azure (Armazenamento de Filas, Armazenamento de Blobs e Armazenamento de Tabelas) sem precisar se conectar a esses 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

As Ferramentas Principais do Azure Functions dão suporte a três tipos de implantação:

Você deve ter a CLI do Azure ou o Azure PowerShell instalado localmente para poder publicar no Azure a partir das Ferramentas Principais. Por padrão, as Ferramentas Principais usam essas ferramentas para autenticar com 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

As Ferramentas Principais permitem implantar seu aplicativo de função em contêiner em ambientes gerenciados de Aplicativos de Contêiner do Azure e clusters Kubernetes que você gerencia.

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 executado em um aplicativo de função no Azure, as configurações exigidas por suas funções são armazenadas com segurança nas configurações do aplicativo. Durante o desenvolvimento local, essas configurações são adicionadas Values à coleção no arquivo local.settings.json. O arquivo local.settings.json também armazena as configurações usadas pelas ferramentas de desenvolvimento local.

Os itens na Values coleção no arquivo de local.settings.json do seu projeto destinam-se a espelhar itens nas configurações do aplicativo de função 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 padrão, as configurações locais não são migradas automaticamente quando o projeto é publicado no Azure. Use a --publish-local-settings opção ao publicar seus arquivos de projeto para garantir que essas configurações sejam adicionadas ao aplicativo de função 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.

• Você pode baixar e substituir configurações em seu arquivo de local.settings.json com configurações de seu aplicativo de função no Azure. Para obter mais informações, consulte Baixar configurações do aplicativo.

• Quando nenhuma cadeia de conexão de armazenamento válida está definida e AzureWebJobsStorage um emulador de armazenamento local não está sendo usado, um erro é mostrado. Você pode usar as Ferramentas Principais para baixar uma cadeia de conexão específica de qualquer uma de suas contas de Armazenamento do Azure.

Baixar configurações do aplicativo

Na raiz do projeto, use o seguinte comando para baixar todas as configurações do myfunctionapp12345 aplicativo no Azure:

func azure functionapp fetch-app-settings myfunctionapp12345

Este comando substitui todas as configurações existentes no arquivo local.settings.json com valores do 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.

Baixar uma cadeia de conexão de armazenamento

As ferramentas principais também facilitam a obtenção da cadeia de conexão de qualquer conta de armazenamento à qual você tenha acesso. Na raiz do projeto, use o seguinte comando para baixar a cadeia de conexão de uma conta de armazenamento chamada mystorage12345.

func azure storage fetch-connection-string mystorage12345

Este comando adiciona uma configuração nomeada mystorage12345_STORAGE ao arquivo local.settings.json, que contém a cadeia de conexão para a mystorage12345 conta. 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 configurações locais para o Azure

Quando você publica seus arquivos de projeto no Azure sem usar a --publish-local-settings opção, as configurações no arquivo local.settings.json não são definidas em seu aplicativo de função. Você sempre pode executar novamente o func azure functionapp publish com a --publish-settings-only opção de carregar apenas as configurações sem republicar os arquivos do projeto.

O exemplo a seguir carrega apenas configurações da coleção no arquivo local.settings.json Values para o aplicativo de função no Azure chamado 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 esse arquivo é criptografado, o tempo de execução descriptografa automaticamente as configurações quando necessário, da mesma forma que faz com a configuração do aplicativo 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

Funções, gatilhos e associações 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 versões principais das Ferramentas Principais do Azure Functions estão vinculadas a versões principais específicas do tempo de execução 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. Você pode determinar a versão de lançamento mais recente das Ferramentas Principais no repositório de Ferramentas Principais do Azure Functions.

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 você 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 tempo de execução do Functions, que chegaram ao fim do suporte. Para obter mais informações, consulte Visão geral das versões de tempo de execução do Azure Functions.

Próximos passos

Saiba como desenvolver, testar e publicar funções do Azure usando as ferramentas principais do Azure Functions. O Azure Functions Core Tools é de código aberto e hospedado no GitHub. Para arquivar um bug ou solicitação de recurso, abra um problema no GitHub.