Desenvolver o Azure Functions usando o Visual Studio Code

A extensão do Azure Functions para Visual Studio Code permite que você desenvolva as funções localmente e as implante no Azure. Se esta for sua primeira experiência com o Azure Functions, você pode aprender mais em Uma introdução ao Azure Functions.

A extensão do Azure Functions oferece estes benefícios:

• Editar, criar e executar funções em seu computador de desenvolvimento local.
• Publicar seu projeto do Azure Functions diretamente no Azure.
• Gravar as funções em várias linguagens, aproveitando os benefícios do Visual Studio Code.

Pré-requisitos

• Visual Studio Code instalado em uma das plataformas compatíveis.

• Extensão Azure Functions. Você também pode instalar o pacote de extensões das Ferramentas do Azure, que é recomendado para trabalhar com recursos do Azure.

• Uma assinatura ativa do Azure. Se você ainda não tiver uma conta, crie uma com base na extensão no Visual Studio Code.

Você também precisa desses pré-requisitos para executar e depurar suas funções localmente. Eles não são necessários apenas para criar ou publicar projetos no Azure Functions.

• O Azure Functions Core Tools, que permite uma experiência de depuração local integrada. Com a extensão do Azure Functions instalada, a forma mais simples de instalar ou atualizar as Core Tools é executando o comando Azure Functions: Install or Update Azure Functions Core Tools através da paleta de comandos.

Criar um projeto do Azure Functions

A extensão do Functions permite criar o projeto de aplicativo de funções necessário ao mesmo tempo que você cria sua primeira função. Use estas etapas para criar uma função disparada por HTTP em um novo projeto. Um gatilho HTTP é o modelo de gatilho de função mais simples de demonstrar.

1. No Visual Studio Code, pressione F1 para abrir a paleta de comandos e pesquisar e executar o comando Azure Functions: Create New Project.... Selecione o local do diretório para o workspace do projeto e escolha Selecionar.

   Você pode criar uma nova pasta ou escolher uma pasta vazia para o workspace do projeto, mas não escolha uma pasta do projeto que já faz parte de um workspace.

   Em vez disso, você pode executar o comando Azure Functions: Create New Containerized Project... para também gerar um Dockerfile para o projeto.

2. Quando solicitado, Selecione uma linguagem para seu projeto. Se necessário, escolha uma versão específica da linguagem.

3. Selecione o modelo de função de gatilho HTTP ou selecione Ignorar agora para criar um projeto sem uma função. Você sempre poderá adicionar uma função ao projeto posteriormente.

   Dica

   Você pode exibir modelos adicionais selecionando a opção Alterar filtro de modelo e definindo o valor como Core ou Todos.

4. Para o nome da função, insira HttpExample, selecione Enter e, em seguida, selecione autorização de Função.

   Esse nível de autorização exige que você forneça uma chave de função ao chamar o ponto de extremidade da função.

5. Na lista suspensa, selecione Adicionar ao workspace.

6. Na janela Você confia nos autores dos arquivos desta pasta?, escolha Sim.

O Visual Studio Code cria uma função na linguagem escolhida e no modelo de uma função disparada por HTTP.

Arquivos de projeto gerados

O modelo do projeto cria um projeto na linguagem escolhida e instala as dependências necessárias. Para qualquer linguagem, o novo projeto tem estes arquivos:

• host.json: Permite que você configure o host do Functions. Essas configurações se aplicam quando você estiver executando as funções localmente e quando as estiver executando no Azure. Para obter mais informações, consulte a referência para host.json.

• local.settings.json: mantém as configurações usadas ao executar as funções localmente. Essas configurações são usadas somente quando você está executando as funções localmente. Para obter mais informações, confira Arquivo de configurações local.

  Importante

  Como o arquivo local.settings.json pode conter segredos, certifique-se de excluir o arquivo do controle do código-fonte do seu projeto.

• Dockerfile (opcional): permite criar um aplicativo de funções conteinerizado do seu projeto usando uma imagem base aprovada para seu projeto. Você só obtém esse arquivo quando executa o comando Azure Functions: Create New Containerized Project.... Você pode adicionar um Dockerfile a um projeto existente usando o comando func init --docker-only no Core Tools.

Dependendo da linguagem, esses outros arquivos são criados:

Neste ponto, você poderá executar sua função de gatilho HTTP localmente.

Adicionar uma função ao projeto

Você pode adicionar uma nova função a um projeto existente usando um dos modelos de gatilho de funções predefinidos. Para adicionar um novo gatilho de função, selecione F1 para abrir a paleta de comandos e, em seguida, procure e execute o comando Azure Functions: Criar Função. Siga os prompts para escolher o tipo de gatilho e definir os atributos necessários do gatilho. Se o gatilho exigir uma chave de acesso ou uma cadeia de conexão para se conectar a um serviço, prepare esse item antes de criar o gatilho de função.

Conectar-se a serviços

Você pode conectar a função a outros serviços do Azure, adicionando associações de entrada e de saída. As associações conectam a função a outros serviços, sem a necessidade de gravar o código de conexão.

{
    "type": "queue",
    "direction": "out",
    "name": "msg",
    "queueName": "outqueue",
    "connection": "MyStorageConnection"
}

{
    "type": "queue",
    "direction": "out",
    "name": "msg",
    "queueName": "outqueue",
    "connection": "MyStorageConnection"
}

{
    "type": "queue",
    "direction": "out",
    "name": "msg",
    "queueName": "outqueue",
    "connection": "MyStorageConnection"
}

O exemplo a seguir mostra a definição de função depois de adicionar uma Associação de saída do Armazenamento de Filas a uma função de gatilho 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"
    }
  ]
}

Entrar no Azure

Antes de criar recursos do Azure ou publicar o aplicativo, entre no Azure.

1. Se ainda não estiver conectado, selecione o ícone do Azure na barra de Atividades. Em seguida, em Recursos, selecione Entrar no Azure.

   

   Se você já estiver conectado e puder ver suas assinaturas existentes, vá para a próxima seção. Se ainda não tiver uma conta do Azure, selecione Criar uma Conta do Azure. Os alunos podem selecionar Criar uma Conta do Microsoft Azure for Students.

2. Quando for solicitado no navegador, selecione sua conta do Azure e entre usando as credenciais da sua conta do Azure. Se você criar uma conta, poderá se conectar depois que a conta for criada.

3. Após fazer login com sucesso, você poderá fechar a nova janela do navegador. As assinaturas que pertencem à sua conta do Azure são exibidas na barra lateral.

Criar recursos do Azure

Para publicar seu projeto do Functions no Azure, você precisa ter um aplicativo de funções e recursos relacionados na sua assinatura do Azure para executar o código. O aplicativo de funções fornece um contexto de execução para suas funções. Quando você publica do Visual Studio Code em um aplicativo de funções no Azure, o projeto é empacotado e implantado no aplicativo de funções selecionado em sua assinatura do Azure.

Ao criar um aplicativo de funções no Azure, você pode escolher um caminho rápido de criação de aplicativo de funções usando os padrões ou um caminho que oferece opções avançadas como usar recursos do Azure existentes. Dessa forma, você tem mais controle sobre a criação dos recursos remotos.

Criar uma implantação de Aplicativos de Contêiner do Azure

Use o Visual Studio Code para criar recursos do Azure para um projeto de código conteinerizado. Quando a extensão detecta a presença de um Dockerfile durante a criação de recursos, ela pergunta se você deseja implantar a imagem de contêiner em vez de apenas o código. O Visual Studio Code cria um ambiente de Aplicativos de Contêiner do Azure para seu projeto de código conteinerizado integrado ao Azure Functions. Para obter mais informações, consulte Aplicativos de Contêiner do Azure que hospedam o Azure Functions.

O processo de criação depende se você escolhe uma criação rápida ou se precisa usar opções avançadas:

Para obter mais informações sobre os recursos necessários para executar suas funções conteinerizadas em Aplicativos de Contêiner, consulte Recursos necessários.

Implantar arquivos de projeto

Recomendamos configurar a implantação contínua, de modo que o aplicativo de funções do Azure seja atualizado quando você atualizar os arquivos de origem no local de origem conectado. Você também pode implantar seus arquivos de projeto no Visual Studio Code. Ao publicar do Visual Studio Code, você pode aproveitar a tecnologia de implantação zip.

1. Na paleta de comandos, insira e, em seguida, selecione Azure Functions: Implantar no Aplicativo de Funções.

2. Selecione o aplicativo de funções que você acabou de criar. Quando solicitado sobre a substituição de implantações anteriores, selecione Implantar para implantar seu código de função no novo recurso do aplicativo de funções.

3. Após sua implantação ser concluída, escolha Ver o resultado para ver os resultados da criação e da implantação, incluindo os recursos do Azure que você criou. Se você deixou passar a notificação, selecione o ícone de sino no canto inferior direito para vê-la novamente.

   

Obter a URL de uma função disparada por HTTP no Azure

Para chamar uma função disparada por HTTP de um cliente, você precisa da URL da função, que estará disponível após a implantação em seu aplicativo de funções. Essa URL inclui as chaves de função necessárias. Você pode usar a extensão para obter essas URLs para as funções implantadas. Se você quiser apenas executar a função remota no Azure, use a funcionalidade Executar função agora da extensão.

1. Selecione F1 para abrir a paleta de comandos, pesquise e execute o comando Azure Functions: Copiar URL da Função.

2. Siga os prompts para selecionar o aplicativo de funções no Azure e, em seguida, o gatilho HTTP específico que você deseja invocar.

A URL da função é copiada na área de transferência, juntamente com as chaves necessárias que passaram pelo parâmetro de consulta code. Use uma ferramenta HTTP para enviar solicitações POST ou um navegador para enviar solicitações GET para a função remota.

Quando a extensão obtém o URL de uma função do Azure, a extensão usa sua conta do Azure para recuperar automaticamente as chaves necessárias para iniciar a função. Saiba mais sobre as chaves de acesso da função. Iniciar funções que não foram disparadas por HTTP requer o uso da chave de administração.

Executar funções

A extensão Azure Functions permite executar funções individuais. Você pode executar funções individuais em seu projeto no computador de desenvolvimento local ou na assinatura do Azure.

Para funções de gatilho HTTP, a extensão chama o ponto de extremidade HTTP. Para outros tipos de gatilhos, a extensão chama as APIs de administrador para iniciar a função. O corpo da mensagem da solicitação enviada para a função depende do tipo de gatilho. Quando um gatilho exige dados de teste, você é solicitado a inserir dados em um formato JSON específico.

Executar funções no Azure

Para executar uma função no Azure a partir do Visual Studio Code, siga estas etapas:

1. Na paleta de comandos, insira Azure Functions: Executar função agora e selecione sua assinatura do Azure.

2. Na lista, escolha seu aplicativo de funções no Azure. Se você não estiver vendo o aplicativo de funções, verifique se está conectado à assinatura correta.

3. Na lista, escolha a função que você deseja executar. Em Inserir corpo da solicitação, digite o corpo da mensagem da solicitação e pressione Enter para enviar essa mensagem de solicitação para sua função.

   O texto padrão em Inserir corpo da solicitação indica o formato do corpo. Se o aplicativo de funções não tiver funções, um erro de notificação será mostrado com esse erro.

   Quando a função é executada no Azure e retorna uma resposta, o Visual Studio Code mostra uma notificação.

Você também pode executar sua função na área Azure: Funções, abrindo o menu de atalho para a função que você deseja executar de seu aplicativo de funções em sua assinatura do Azure e selecionando Executar Função Agora....

Quando você executa suas funções no Azure a partir do Visual Studio Code, a extensão usa sua conta do Azure para recuperar automaticamente as chaves necessárias para iniciar a função. Saiba mais sobre as chaves de acesso da função. Iniciar funções que não foram disparadas por HTTP requer o uso da chave de administração.

Executar funções localmente

O runtime local é o mesmo runtime que hospeda o aplicativo de funções no Azure. As configurações locais são lidas no arquivo local.settings.json. Para executar o projeto do Functions localmente, você deve atender a mais requisitos.

Configurar o projeto para ser executado localmente

O runtime do Functions usa uma conta de Armazenamento do Azure internamente para todos os tipos de gatilho diferentes de HTTP e WebHooks. Portanto, você precisa definir a chave Values.AzureWebJobsStorage para uma cadeia de conexão válida da conta de armazenamento do Azure.

Esta seção usa a extensão de Armazenamento do Azure para Visual Studio Code com o Gerenciador de Armazenamento do Azure para se conectar e recuperar a cadeia de conexão de armazenamento.

Para definir a cadeia de conexão da conta de armazenamento:

1. No Visual Studio, abra o Gerenciador de Nuvem, expanda a Conta de Armazenamento>A Conta de Armazenamento, selecione Propriedades e copie o valor da Cadeia de Conexão Primária.

2. Em seu projeto, abra o arquivo local.settings.json e defina o valor da chave AzureWebJobsStorage na cadeia de conexão que você copiou.

3. Repita a etapa anterior para adicionar as chaves exclusivas para a matriz de Valores para todas as outras conexões necessárias para as suas funções.

Para obter mais informações, confira Arquivo de configurações local.

Depurar funções localmente

Para depurar as funções, selecione F5. Caso as Core Tools não estejam disponíveis, será solicitada a instalação. Quando o Core Tools está instalado e em execução, a saída é mostrada no Terminal. Essa etapa é a mesma da execução do comando do func start Core Tools no Terminal, mas com tarefas de compilação adicionais e um depurador anexado.

Quando o projeto estiver em execução, você poderá usar o recurso Executar função agora... da extensão para disparar as funções como você faria quando o projeto é implantado no Azure. Com o projeto em execução no modo de depuração, os pontos de interrupção são atingidos no Visual Studio Code como você esperaria.

1. Na paleta de comandos, insira Azure Functions: Executar função agora e escolha Projeto local.

2. Escolha a função que você deseja executar no projeto e digite o corpo da mensagem da solicitação em Inserir corpo da solicitação. Clique em ENTER para enviar essa mensagem de solicitação à função. O texto padrão no Inserir corpo da solicitação deve indicar o formato do corpo. Se o aplicativo de funções não tiver funções, um erro de notificação será mostrado com esse erro.

3. Quando a função é executada localmente e após o recebimento da 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.

As chaves não são necessárias ao serem executadas localmente, o que se aplica a chaves de função e a chaves no nível do administrador.

Trabalhe com as configurações do aplicativo localmente

Ao executar em um aplicativo de funções 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 à coleção Values no arquivo local.settings.json. O arquivo local.settings.json também armazena as configurações usadas pelas ferramentas de desenvolvimento locais.

Os itens da Values coleção no arquivo local.settings.json do seu projeto destinam-se a espelhar itens nas configurações do aplicativo do seu aplicativo de funções no Azure.

Por padrão, essas configurações não são migradas automaticamente quando o projeto é publicado no Azure. Depois que a publicação for concluída, você terá a opção de publicar as configurações do local.settings.json no aplicativo de funções no Azure. Para saber mais, confira Publicar configurações de aplicativo.

Os valores em ConnectionStrings nunca são publicados.

Configurações de aplicativo no Azure

As configurações no arquivo local.settings.json no projeto devem ser iguais às configurações do aplicativo de funções no Azure. As configurações adicionadas ao local.settings.json também devem ser adicionadas ao aplicativo de funções no Azure. Essas configurações não são carregadas automaticamente quando você publica o projeto. Da mesma forma, todas as configurações criadas no aplicativo de funções no portal devem ser baixadas no projeto local.

Publicar configuração de aplicativo

A maneira mais fácil de publicar as configurações necessárias no aplicativo de funções no Azure é usar o link Carregar configurações, que é exibido depois de publicar o projeto:

Você também pode publicar as configurações usando o comando Azure Functions: carregar configuração local na paleta de comandos. Você pode adicionar configurações individuais às configurações de aplicativo no Azure usando o comando Azure Functions: adicionar nova configuração.

Se o arquivo local for criptografado, ele será descriptografado, publicado e criptografado novamente. Se houver configurações com valores conflitantes nos dois locais, você será solicitado a escolher como proceder.

Exiba as configurações de aplicativo existentes na área Azure: Functions, expandindo a assinatura, o aplicativo de funções e as Configurações de Aplicativo.

Baixar configurações do Azure

Se você criou as configurações de aplicativo no Azure, pode baixá-las no arquivo local.settings.json usando o comando Azure Functions: baixar configurações remotas.

Assim como acontece com o carregamento, se o arquivo local for criptografado, ele será descriptografado, atualizado e criptografado novamente. Se houver configurações com valores conflitantes nos dois locais, você será solicitado a escolher como proceder.

Instalar extensões de associação

Com exceção dos gatilhos de timer e HTTP, as associações são implementadas nos pacotes de extensão.

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.<BINDING_TYPE_NAME> --version <TARGET_VERSION>

dotnet add package Microsoft.Azure.WebJobs.Extensions.<BINDING_TYPE_NAME> --version <TARGET_VERSION>

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

Funções de monitoramento

Quando você executa funções localmente, os dados de log são transmitidos para o console do Terminal. Você também pode obter os dados de log quando o projeto do Functions está em execução em um aplicativo de funções no Azure. Você pode se conectar aos logs de streaming no Azure para ver dados de log quase em tempo real. Você deve habilitar o Application Insights para obter uma compreensão mais completa do comportamento do seu aplicativo de funções.

Application Insights

Você deve monitorar a execução das funções integrando o aplicativo de funções com o Application Insights. Ao criar um aplicativo de funções no portal do Azure, essa integração ocorre por padrão. Ao criar o aplicativo de funções durante a publicação do Visual Studio, você precisa integrar o Application Insights. Para saber como, confira Habilitar a integração do Application Insights.

Para saber mais sobre o monitoramento usando o Application Insights, confira Monitorar o Azure Functions.

Referência da paleta de comandos

A extensão do Azure Functions fornece uma interface gráfica útil na área para interagir com os aplicativos de funções no Azure. A mesma funcionalidade também está disponível como comandos na paleta de comandos (F1). Estes comandos do Azure Functions estão disponíveis:

Próximas etapas

Para saber mais sobre o Azure Functions Core Tools, confira Trabalhar com o Azure Functions Core Tools.

Para saber mais sobre como desenvolver funções como bibliotecas de classes do .NET, consulte Referência do desenvolvedor de C# do Azure Functions. Este tópico também fornece links para exemplos de como usar atributos para declarar os vários tipos de associações com suporte no Azure Functions.