Desenvolver Azure Functions usando Visual Studio Code

A extensão Azure Functions para Visual Studio Code permite desenvolver funções localmente e implantá-las em Azure. Se essa experiência for sua primeira com Azure Functions, você poderá saber mais em An introdução ao Azure Functions.

A extensão Azure Functions fornece estes benefícios:

• Editar, criar e executar funções em seu computador de desenvolvimento local.
• Publique seu projeto de Azure Functions diretamente no Azure.
• Escreva suas funções em vários idiomas, aproveitando os benefícios de Visual Studio Code.

Pré-requisitos

• Visual Studio Code instalado em uma das plataformas suportadas.

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

• Uma assinatura Azure ativa. Se você ainda não tiver uma conta, poderá criar uma com base na extensão em Visual Studio Code.

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

• O Azure Functions Core Tools, que permite uma experiência de depuração local integrada. Quando você tem a extensão Azure Functions instalada, a maneira mais fácil de instalar ou atualizar as Ferramentas Principais é executando o comando Azure Functions: Install or Update Azure Functions Core Tools na paleta de comandos.

Criar um projeto de 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. Em Visual Studio Code, pressione F1 para abrir a paleta de comandos. Pesquise e execute 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 por enquanto para criar um projeto sem uma função. Você sempre poderá adicionar uma função ao projeto posteriormente.

   Dica

   Para exibir modelos adicionais, selecione a opção Alterar filtro de modelo e defina o valor como Core ou All.

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.

Visual Studio Code cria uma função no idioma escolhido e no modelo para 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ê executa funções localmente e quando as executa em 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 func init --docker-only comando em Ferramentas Principais.

Neste ponto, você pode executar a 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 predefinidos do Functions. Para adicionar um novo gatilho de função, selecione F1 para abrir a paleta de comandos e, em seguida, localize 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 da função.

Conectar-se a serviços

Você pode conectar sua função a outros serviços Azure adicionando associações de entrada e 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 disparada 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"
    }
  ]
}

Entrar no Azure

Antes de criar Azure recursos ou publicar seu aplicativo, você deve entrar no Azure.

1. Se você ainda não estiver conectado, na barra Activity, selecione o ícone Azure. Em seguida, em Resources, selecione Entrar no Azure.

   

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

2. Quando você for solicitado no navegador, selecione sua conta de Azure e entre usando suas credenciais de conta 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 Azure são exibidas na barra lateral.

Criar recursos de Azure

Antes de publicar seu projeto do Functions para Azure, você deve ter um aplicativo de funções e recursos relacionados em sua assinatura Azure para executar seu 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 em Azure, você pode escolher um caminho de criação de aplicativo de funções rápida usando padrões ou um caminho que oferece opções avançadas, como usar recursos de Azure existentes. Dessa forma, você tem mais controle sobre a criação dos recursos remotos.

Criar uma implantação de Azure Container Apps

Use Visual Studio Code para criar recursos Azure para um projeto de código em contêineres. 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. Visual Studio Code cria um ambiente Azure Container Apps para seu projeto de código em contêineres integrado ao Azure Functions. Para obter mais informações, consulte hospedagem do Azure Functions em Azure Container Apps.

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

Configure a implantação continuosa para que o aplicativo de funções no Azure seja atualizado ao atualizar os arquivos de origem no local de origem conectado. Você também pode implantar seus arquivos de projeto a partir do 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 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. Quando a implantação for concluída, selecione View Output para exibir os resultados de criação e implantação, incluindo os recursos de Azure que você criou. Se você não viu a notificação, selecione o ícone do 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 em Azure, utilize a função Execute agora funcionalidade da extensão.

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

2. Siga os prompts para selecionar seu 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 a URL de uma função em Azure, ela usa sua conta 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 em seu projeto no computador de desenvolvimento local ou em sua assinatura de 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 de Visual Studio Code, siga estas etapas:

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

2. Na lista, escolha seu aplicativo de funções em 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, Visual Studio Code mostra uma notificação.

Você também pode executar sua função na área Azure: Functions abrindo o menu de atalho para a função que deseja executar em seu aplicativo de funções em sua assinatura Azure e selecionando Execute Function Now... .

Quando você executa suas funções em Azure de Visual Studio Code, a extensão usa sua conta 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 seu aplicativo de funções em Azure. O runtime lê as configurações locais do arquivolocal.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 Azure Storage internamente para todos os tipos de gatilho, exceto HTTP e webhooks. Defina a chave Values.AzureWebJobsStorage para uma cadeia de conexão válida da conta do Azure Storage.

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

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

1. Em Visual Studio, abra Cloud Explorer expanda Storage Account>Your Storage Account e selecione Properties e copie o valor Primary Connection String.

2. Em seu projeto, abra o arquivo local.settings.json e defina o valor da chave AzureWebJobsStorage para o connection string copiado.

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 Execute Agora... da extensão para disparar suas funções como 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 em Visual Studio Code como você esperaria.

1. Na paleta de comandos, insira Azure Functions: Execute a função agora e escolha Projetolocal.

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 depois que a resposta é recebida, uma notificação é gerada em 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 executar localmente. Essa regra se aplica a chaves de função e chaves no nível do administrador.

Trabalhar com configurações de aplicativo localmente

Quando o aplicativo de funções é executado no Azure, as configurações exigidas por suas funções são armazenadas criptografadas 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 locais.

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

Por padrão, essas configurações não são migradas automaticamente quando você publica o projeto para Azure. Após a conclusão da publicação, você pode optar por publicar configurações de local.settings.json para seu 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 em seu projeto devem corresponder às configurações do aplicativo de funções no Azure. Você deve adicionar novas configurações ao local.settings.json e ao aplicativo de funções no Azure. Essas configurações não são carregadas automaticamente quando você publica o projeto. Da mesma forma, você deve baixar as configurações que criar no aplicativo de funções no portal para seu 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 Upload que aparece depois de publicar seu projeto:

Você também pode publicar configurações usando o comando Azure Functions: Carregar Configuração Local na paleta de comandos. Você pode adicionar configurações individuais às configurações do aplicativo em Azure usando o comando Azure Functions: Adicionar Nova Configuração.

Se o arquivo local for criptografado, o processo o descriptografa, publica e criptografa novamente. Se houver valores conflitantes nos dois locais, você será solicitado a escolher como proceder.

Exiba as configurações de aplicativo existentes na área Azure: Functions expandindo sua assinatura, seu aplicativo de funções e Application Settings.

Baixar configurações de Azure

Se você criar configurações de aplicativo no Azure, poderá baixá-las no arquivo local.settings.json usando o comando Azure Functions: Baixar Configurações Remotas.

Assim como no carregamento, se o arquivo local for criptografado, o processo o descriptografa, atualiza-o e criptografa-o novamente. Se houver 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, o Core Tools transmite dados de log para o console do Terminal. Você também pode obter dados de log quando seu projeto do Functions é executado em um aplicativo de funções em 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 uma compreensão mais completa de como seu aplicativo de funções se comporta.

Application Insights

Monitore a execução das funções integrando o aplicativo de funções com o Application Insights. Quando você cria um aplicativo de funções no portal Azure, essa integração ocorre por padrão. Ao criar seu aplicativo de funções durante a publicação no Visual Studio, você precisa integrar o Application Insights por conta própria. Para saber como, confira Habilitar a integração do Application Insights.

Para saber mais sobre como monitorar usando o Application Insights, consulte Monitor Azure Functions.

Referência da paleta de comandos

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

Próximas etapas

Para saber mais sobre Azure Functions Core Tools, consulte Work with Azure Functions Core Tools.

Para saber mais sobre como desenvolver funções como bibliotecas de classes .NET, consulte Azure Functions referência de desenvolvedor C#. Este artigo também fornece links para exemplos de como usar atributos para declarar os vários tipos de associações compatíveis com Azure Functions.