Desenvolva Azure Functions usando o Visual Studio Code

A extensão Azure Functions para Visual Studio Code permite-lhe desenvolver funções localmente e implementá-las em Azure. Se esta é a tua primeira experiência com Azure Functions, podes aprender mais em Uma introdução à Azure Functions.

A extensão Azure Functions oferece os seguintes benefícios:

• Edite, crie e execute funções no seu computador de desenvolvimento local.
• Publique o seu projeto Azure Functions diretamente no Azure.
• Escreva as suas funções em várias linguagens enquanto aproveita os benefícios do Visual Studio Code.

Pré-requisitos

• Visual Studio Code instalado numa das plataformas suportadas .

• Extensão do Azure Functions. Também pode instalar o pacote de extensões Azure Tools, que é recomendado para trabalhar com Azure recursos.

• Uma subscrição ativa Azure. Se ainda não tens conta, podes criar uma a partir da 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 obrigados a criar ou publicar projetos apenas no Azure Functions.

• O Azure Functions Core Tools, que permite uma experiência integrada de depuração local. Quando tem a extensão Azure Functions instalada, a forma mais fácil de instalar ou atualizar o Core Tools é executar o comando Azure Functions: Install or Update Azure Functions Core Tools a partir da paleta de comandos.

Criar um projeto Azure Functions

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

1. Em Visual Studio Code, pressione F1 para abrir a paleta de comandos. Procura e executa o comando Azure Functions: Create New Project.... Selecione a localização do diretório para o seu espaço de trabalho de projeto e depois escolha Selecionar.

   Você pode criar uma nova pasta ou escolher uma pasta vazia para o espaço de trabalho do projeto, mas não escolha uma pasta de projeto que já faça parte de um espaço de trabalho.

   Pode, em vez disso, executar o comando Azure Functions: Create New Containerized Project... para também gerar um Dockerfile para o projeto.

2. Quando solicitado, selecione um idioma para o seu projeto. Se necessário, escolha uma versão linguística específica.

3. Selecione o modelo de função HTTP trigger , ou selecione Skip por agora para criar um projeto sem função. Você sempre pode adicionar uma função ao seu projeto mais tarde.

   Gorjeta

   Para visualizar modelos adicionais, selecione a opção de filtro Alterar modelo e defina o valor para Núcleo ou Todos.

4. Para o nome da função, introduza HttpExample, selecione Enter e depois selecione a autorização de privilégios de função.

   Esse nível de autorização requer que forneça uma chave de função quando chamar o endpoint da função.

5. Na lista suspensa, selecione Adicionar ao espaço de trabalho.

6. Na janela Você confia nos autores dos arquivos nesta pasta?, selecione Sim.

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

Arquivos de projeto gerados

O modelo de projeto cria um projeto no idioma escolhido e instala as dependências necessárias. Para qualquer idioma, o novo projeto tem estes arquivos:

• host.json: Permite configurar o host Functions. Estas definições aplicam-se quando estás a executar funções localmente e quando as estás a executar no Azure. Para obter mais informações, consulte host.json referência.

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

  Importante

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

• Dockerfile (opcional): Permite criar um aplicativo de função em contêiner a partir do seu projeto usando uma imagem base aprovada para o seu projeto. Só recebes este ficheiro quando executas o comando Azure Functions: Create New Containerized Project.... Pode adicionar um Dockerfile a um projeto existente usando o func init --docker-only comando nas Ferramentas Core.

Neste ponto, podes executar a tua função de trigger HTTP localmente.

Adicionar uma função ao seu projeto

Pode adicionar uma nova função a um projeto existente usando um dos templates de trigger Functions pré-definidos. Para adicionar um novo trigger de função, selecione F1 para abrir a paleta de comandos, depois encontre e execute o comando Azure Functions: Criar função. Siga as instruções para escolher o tipo de gatilho e definir os atributos necessários do gatilho. Se o seu gatilho requer uma chave de acesso ou uma cadeia de conexão para se ligar a um serviço, tenha esse item pronto antes de criar o gatilho da função.

Ligar aos serviços

Pode ligar a sua função a outros serviços do Azure adicionando ligações de entrada e saída. As vinculações conectam a sua função a outros serviços sem necessidade de escrever 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 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"
    }
  ]
}

Iniciar sessão no Azure

Antes de poderes criar recursos do Azure ou publicar a tua aplicação, tens de iniciar sessão no Azure.

1. Se ainda não tiver iniciado sessão, selecione o ícone Azure na Barra de Atividades. Depois, em Resources, selecione Iniciar sessão em Azure.

   

   Se já tiver sessão iniciada e visualizar as suas subscrições existentes, vá para a seção seguinte. Se ainda não tem uma conta Azure, selecione Criar uma Conta Azure. Os alunos podem selecionar Criar um Azure para a Conta dos Alunos.

2. Quando for solicitado no navegador, selecione a sua conta Azure e inicie sessão usando as credenciais da sua conta Azure. Se criar uma nova conta, pode iniciar sessão depois de a sua conta ser criada.

3. Depois de iniciar sessão com êxito, pode fechar a nova janela do browser. As subscrições que pertencem à sua conta Azure são exibidas na barra lateral.

Criar recursos do Azure

Antes de poder publicar o seu projeto de Funções no Azure, deve ter uma aplicação de funções e recursos relacionados na sua subscrição do Azure para executar o seu código. A aplicação de funções proporciona um contexto de execução para as suas funções. Quando publica do Visual Studio Code para uma aplicação de funções no Azure, o projeto é empacotado e implementado na aplicação de funções selecionada na sua subscrição do Azure.

Quando crias uma aplicação de funções no Azure, podes escolher entre um caminho de criação rápida de aplicações de funções usando os predefinidos ou um caminho que te dá opções avançadas, como usar recursos existentes do Azure. Dessa forma, você tem mais controle sobre a criação dos recursos remotos.

Criar uma implementação do Azure Container Apps

Use o Visual Studio Code para criar recursos do Azure para um projeto de código containerizado. Quando a extensão deteta a presença de um Dockerfile durante a criação do recurso, pergunta se queres implementar a imagem do contentor em vez de apenas o código. O Visual Studio Code cria um ambiente Azure Container Apps para o seu projeto de código containerizado, integrado com o Azure Functions. Para mais informações, consulte Azure Container Apps hospedagem de 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 em contêineres em Aplicativos de Contêiner, consulte Recursos necessários.

Implantar arquivos de projeto

Configura deployment contínuo para que a tua aplicação de funções em Azure atualize quando atualizas os ficheiros de origem na localização de origem ligada. Também pode disponibilizar os seus ficheiros de projeto a partir do Visual Studio Code. Quando publica a partir de Visual Studio Code, pode tirar partido da tecnologia de implementação Zip.

1. Na paleta de comandos, enter e depois selecione Azure Functions: Deploy to Function App.

2. Selecione o aplicativo de função que você acabou de criar. Quando for solicitado para substituir implantações anteriores, selecione Implantar para transferir o seu código de função para o novo recurso da aplicação de funções.

3. Quando a implementação estiver concluída, selecione Ver Saída para visualizar os resultados da criação e implementação, incluindo os recursos Azure que criou. Se você perder a notificação, selecione o ícone de sino no canto inferior direito para vê-lo novamente.

   

Obtenha a URL de uma função ativada por HTTP no Azure

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

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

2. Siga as instruções para selecionar a sua aplicação de funções no Azure e depois o gatilho HTTP específico que pretende invocar.

A URL da função é copiada para a área de transferência, juntamente com quaisquer chaves necessárias passadas 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 recebe o URL de uma função no Azure, usa a sua conta Azure para recuperar automaticamente as chaves necessárias para iniciar a função. Saiba mais sobre as teclas de acesso de função. Iniciar funções acionadas não HTTP requer o uso da chave admin.

Executar funções

A extensão Azure Functions permite executar funções individuais. Pode executar funções tanto no seu projeto no seu computador de desenvolvimento local como na sua subscrição do Azure.

Para funções de gatilho HTTP, a extensão chama o endpoint HTTP. Para outros tipos de gatilhos, a extensão chama 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 requer 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 estes passos:

1. Na paleta de comandos, introduza Azure Functions: Executar função agora e selecione a sua subscrição de Azure.

2. Da lista, escolha a sua aplicação de funções no Azure. Se não vir a sua aplicação de função, certifique-se de que iniciou sessão na subscrição correta.

3. Na lista, escolha a função que 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 Enter request body indica o formato do corpo. Se o seu aplicativo de função não tiver funções, um erro de notificação será exibido com esse erro.

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

Também pode executar a sua função a partir da área Azure: Functions abrindo o menu de atalho da função que quer executar na sua aplicação de funções na subscrição de Azure, e depois selecionando Executar Função Agora... .

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

Executar funções localmente

O runtime local é o mesmo que aloja a tua aplicação de funções no Azure. O runtime lê as definições locais do ficheirolocal.settings.json. Para executar seu projeto do Functions localmente, você deve atender a mais requisitos.

Configurar o projeto para ser executado localmente

O runtime Functions utiliza uma conta Azure Storage internamente para todos os tipos de gatilhos, exceto HTTP e webhooks. Defina a chave Values.AzureWebJobsStorage para uma cadeia de conexão válida de conta do Azure Storage.

Esta secção utiliza a extensão Azure Storage para Visual Studio Code com Azure Storage Explorer para se ligar ao armazenamento e recuperar a cadeia de ligação de armazenamento.

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

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

2. No teu projeto, abre o ficheiro local.settings.json e define o valor da chave AzureWebJobsStorage para a connection string que copiaste.

3. Repita a etapa anterior para adicionar chaves exclusivas à matriz Values para quaisquer outras conexões exigidas por suas funções.

Para obter mais informações, consulte Arquivo de configurações locais.

Depurar funções localmente

Para depurar suas funções, selecione F5. Se as Ferramentas Principais não estiverem disponíveis, você será solicitado a instalá-las. Quando o Core Tools está instalado e em execução, a saída é mostrada no Terminal. Esta etapa é a mesma que executar o func start comando Core Tools a partir do Terminal, mas com tarefas de compilação extras e um depurador anexado.

Quando o projeto está a correr, pode usar a função Executar Agora... funcionalidade da extensão para ativar as tuas funções como farias quando o projeto é implementado para Azure. Com o projeto a correr em modo de depuração, os pontos de interrupção são atingidos no Visual Studio Code, como seria de esperar.

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

2. Escolha a função que deseja executar em seu projeto e digite o corpo da mensagem da solicitação em Inserir corpo da solicitação. Prima Enter para enviar esta mensagem de pedido para a sua função. O texto padrão em Enter request body deve indicar o formato do corpo. Se o seu aplicativo de função não tiver funções, um erro de notificação será exibido com esse erro.

3. Quando a função é executada localmente e após a resposta ser recebida, surge uma notificação 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 quando se executa localmente. Esta regra aplica-se tanto às teclas de função como às de nível administrativo.

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.

Por defeito, estas definições não são migradas automaticamente quando publicas o projeto para o Azure. Depois de a publicação terminar, pode optar por publicar as definições de local.settings.json para a sua aplicação de funções no Azure. Para saber mais, consulte Publicar configurações do aplicativo.

Os valores em ConnectionStrings nunca são publicados.

Definições de aplicação no Azure

As definições no ficheiro local.settings.json do teu projeto devem corresponder às definições da aplicação na aplicação de funções no Azure. Tem de adicionar quaisquer novas definições tanto à local.settings.json como à aplicação de funções no Azure. Essas configurações não são carregadas automaticamente quando você publica o projeto. Da mesma forma, deve descarregar quaisquer definições que crie na sua aplicação de funções no portal do seu projeto local.

Publicar configurações do aplicativo

A forma mais fácil de publicar as definições necessárias na tua app de funções no Azure é usar o link Definições de upload que aparece depois de publicares o teu projeto:

Também pode publicar definições usando o comando Azure Functions: Upload Local Setting na paleta de comandos. Pode adicionar definições individuais às definições da aplicação em Azure usando o comando Azure Functions: Adicionar Nova Definição.

Se o ficheiro local estiver encriptado, o processo desencripta-o, publica-o e volta a encriptá-lo. Se existirem valores conflitantes nas duas localizações, é-lhe pedido que escolha como proceder.

Consulte as definições existentes da aplicação na área Azure: Funções expandindo a sua subscrição, a sua aplicação de funções e Definições da Aplicação.

Descarregar definições do Azure

Se criares as definições da aplicação no Azure, podes descarregá-las para o teu ficheiro local.settings.json usando o comando Azure Functions: Download Remote Settings.

Tal como no upload, se o ficheiro local estiver encriptado, o processo desencripta-o, atualiza-o e volta a encriptá-lo. Se existirem valores conflitantes nas duas localizações, é-lhe pedido que escolha como proceder.

Instalar as extensões de enlace

Exceto para gatilhos HTTP e timer, as ligações são implementadas em 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 monitorização

Quando executas funções localmente, o Core Tools transmite os dados de registo para a consola do Terminal. Também podes obter dados de log quando o teu projeto de Funções é executado numa aplicação de funções no Azure. Pode ligar-se a logs de streaming no Azure para ver dados de registo quase em tempo real. Deve ativar o Application Insights para uma compreensão mais completa do comportamento da sua aplicação de funções.

Application Insights

Você deve monitorar a execução de suas funções integrando seu aplicativo de função com o Application Insights. Quando crias uma aplicação de funções no portal do Azure, esta integração ocorre por defeito. Quando cria a sua aplicação de funções durante a publicação no Visual Studio, precisa de integrar o Application Insights por si próprio. Para saber como, consulte Habilitar a integração do Application Insights.

Para saber mais sobre monitorização usando 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 as suas aplicações 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óximos passos

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

Para saber mais sobre o desenvolvimento de funções como bibliotecas de classes .NET, consulte Azure Functions C# developer reference. Este artigo também fornece ligações para exemplos de como usar atributos para declarar os vários tipos de ligações suportadas pelo Azure Functions.