Início Rápido: Criar e implantar código de função para Azure usando Visual Studio Code

Use Visual Studio Code para criar uma função que responde a solicitações HTTP de um modelo. Use GitHub Copilot para melhorar o código de função gerado, verificar as atualizações de código localmente e, em seguida, implantá-lo no plano de hospedagem de Consumo Flex sem servidor no Azure Functions.

Use Visual Studio Code para criar uma função custom handler que responde a solicitações HTTP. Depois de verificar o código localmente, você o implanta no plano de hospedagem de Consumo Flex sem servidor no Azure Functions.

Os manipuladores personalizados podem ser usados para criar funções em qualquer linguagem ou runtime executando um processo do servidor HTTP. Este artigo dá suporte ao Go e ao Rust.

Concluir este início rápido incorre em um pequeno custo de alguns centavos de dólar ou menos em sua conta de Azure.

Selecione seu idioma de desenvolvimento preferido na parte superior do artigo.

Pré-requisitos

• Uma conta Azure com uma assinatura ativa. Crie uma conta gratuitamente.

• Visual Studio Code em uma das plataformas suportadas.

• A extensão Azure Functions para Visual Studio Code.

• .NET SDK 8.0

• Extensão C# para Visual Studio Code.

• O Java Development Kit, versão 8, 11, 17 ou 21 (somente Linux).

• Apache Maven, versão 3.0 ou posterior.

• O pacote de extensões Java

• Node.js 18.x ou posterior. Use o comando para verificar sua versão.

• PowerShell 7.2

• .NET runtime 6.0

• A extensão PowerShell para Visual Studio Code.

• Versões de Python que são compatíveis com o Azure Functions. Para obter mais informações, consulte Como instalar Python.

• A extensão Python para Visual Studio Code.

• Go, versão mais recente recomendada. Use o comando para verificar sua versão.

• Cadeia de ferramentas do Rust usando rustup. Use o comando para verificar sua versão.

Instalar ou atualizar ferramentas principais

A extensão Azure Functions para Visual Studio Code integra-se ao Azure Functions Core Tools para que você possa executar e depurar suas funções localmente em Visual Studio Code usando o runtime do Azure Functions. Antes de começar, é uma boa ideia instalar o Core Tools localmente ou atualizar uma instalação existente para usar a versão mais recente.

Em Visual Studio Code, selecione F1 para abrir a paleta de comandos e pesquise e execute o comando Azure Functions: Instalar ou Atualizar Ferramentas Principais.

Esse comando tenta iniciar uma instalação baseada em pacote da versão mais recente do Core Tools ou atualizar uma instalação baseada em pacote existente. Se você não tiver o npm ou o Homebrew instalado em seu computador local, será necessário instalar ou atualizar manualmente o Core Tools.

Criar seu projeto local

Nesta seção, você usará Visual Studio Code para criar um projeto de Azure Functions local em seu idioma preferido. Posteriormente no artigo, você atualiza, executa e publica seu código de função para Azure.

1. Em Visual Studio Code, pressione F1 para abrir a paleta de comandos. Pesquise e execute o comando Azure Functions: Create New Project....

2. Escolha o local de diretório para o workspace do projeto e escolha Selecionar. Você deve criar uma pasta ou escolher uma pasta vazia para o workspace do projeto. Não escolha uma pasta de projeto que já faça parte de um workspace.

3. Forneça as seguintes informações nos campos solicitados.

   Rápido	Seleção
   Selecione um idioma	Escolha .
   Selecione um runtime .NET	Escolha .NET 8.0 LTS.
   Selecione um modelo para a primeira função do projeto	Escolha .
   Forneça um nome para a função	Digite .
   Forneça um namespace	Digite .
   Nível de autorização	Escolha , que requer uma chave de acesso para chamar o endpoint da função. Para obter mais informações, confira Nível de autorização.
   Selecione como deseja abrir o projeto	Escolha .

   Rápido	Seleção
   Selecione um idioma	Escolha Java.
   Selecione uma versão do Java	Escolha Java 8, Java 11, Java 17 ou Java 21, a versão Java na qual suas funções são executadas em Azure. Escolha uma versão Java que você verificou localmente.
   Forneça uma ID de grupo	Escolha .
   Forneça uma ID de artefato	Escolha .
   Forneça uma versão	Escolha .
   Forneça um nome de pacote	Escolha .
   Forneça um nome de aplicativo	Escolha .
   Selecione um modelo para a primeira função do projeto	Escolha .
   Selecione a ferramenta de build para o projeto Java	Escolha .
   Selecione como deseja abrir o projeto	Escolha .

   Rápido	Seleção
   Selecione um idioma	Escolha .
   Selecione um modelo de programação JavaScript	Escolha .
   Selecione um modelo para a primeira função do projeto	Escolha .
   Forneça um nome para a função	Digite .
   Nível de autorização	Escolha , que requer uma chave de acesso para chamar o endpoint da função. Para obter mais informações, confira Nível de autorização.
   Selecione como deseja abrir o projeto	Escolha .

   Rápido	Seleção
   Selecione um idioma	Escolha .
   Selecione um modelo de programação JavaScript	Escolha .
   Selecione um modelo para a primeira função do projeto	Escolha .
   Forneça um nome para a função	Digite .
   Nível de autorização	Escolha , que requer uma chave de acesso para chamar o endpoint da função. Para obter mais informações, confira Nível de autorização.
   Selecione como deseja abrir o projeto	Escolha .

   Rápido	Seleção
   Selecione um idioma	Escolha Python.
   Elecione um interpretador de Python para criar um ambiente virtual	Escolha seu interpretador de Python preferido. Se uma opção não for mostrada, digite o caminho completo para o binário Python.
   Selecione um modelo para a primeira função do projeto	Escolha .
   O nome da função que você deseja criar	Digite .
   Nível de autorização	Escolha , que requer uma chave de acesso para chamar o endpoint da função. Para obter mais informações, confira Nível de autorização.
   Selecione como deseja abrir o projeto	Escolha .

   Rápido	Seleção
   Selecione uma linguagem para o projeto de função	Escolha .
   Selecione um modelo para a primeira função do projeto	Escolha .
   Forneça um nome para a função	Digite .
   Nível de autorização	Escolha , que requer uma chave de acesso para chamar o endpoint da função. Para obter mais informações, confira Nível de autorização.
   Selecione como deseja abrir o projeto	Escolha .

   Rápido	Seleção
   Selecione uma linguagem para o projeto de função	Escolha .
   Selecione um modelo para a primeira função do projeto	Escolha .
   Forneça um nome para a função	Digite .
   Nível de autorização	Escolha , que requer uma chave de acesso para chamar o endpoint da função. Para obter mais informações, confira Nível de autorização.
   Selecione como deseja abrir o projeto	Escolha .

   Usando essas informações, o Visual Studio Code gera um projeto de código para o Azure Functions com um endpoint de função acionada por HTTP. Você pode exibir os arquivos de projeto locais no Explorer. Para saber mais sobre os arquivos criados, confira Arquivos de projeto gerados.

4. No arquivo local.settings.json, atualize a configuração como no exemplo a seguir:

   "AzureWebJobsStorage": "UseDevelopmentStorage=true",
   

   Essa configuração informa ao host local do Functions a usar o emulador de armazenamento na conexão de armazenamento exigida pelo modelo Python v2. Quando você publica seu projeto para Azure, essa configuração usa a conta de armazenamento padrão. Se você usar uma conta do Azure Storage durante o desenvolvimento local, defina a string de conexão da conta de armazenamento aqui.

Iniciar o emulador

1. Em Visual Studio Code, pressione F1 para abrir a paleta de comandos. Na paleta de comandos, pesquise e selecione .

2. Verifique a barra inferior e verifique se os serviços de emulação do Azurite estão em execução. Nesse caso, agora você pode executar a função localmente.

Criar e compilar sua função

O arquivo function.json na pasta HttpExample declara uma função de gatilho HTTP. Conclua a função adicionando um manipulador e compilando-o em um executável.

1. Pressione Ctrl + N (Cmd + N no macOS) para criar um arquivo. Salve-o como handler.go na raiz do aplicativo de funções (na mesma pasta que host.json).

2. Em handler.go, adicione o código a seguir e salve o arquivo. Este é o manipulador personalizado do Go.

   package main
   
   import (
       "fmt"
       "log"
       "net/http"
       "os"
   )
   
   func helloHandler(w http.ResponseWriter, r *http.Request) {
       message := "This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.\n"
       name := r.URL.Query().Get("name")
       if name != "" {
           message = fmt.Sprintf("Hello, %s. This HTTP triggered function executed successfully.\n", name)
       }
       fmt.Fprint(w, message)
   }
   
   func main() {
       listenAddr := ":8080"
       if val, ok := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT"); ok {
           listenAddr = ":" + val
       }
       http.HandleFunc("/api/HttpExample", helloHandler)
       log.Printf("About to listen on %s. Go to https://127.0.0.1%s/", listenAddr, listenAddr)
       log.Fatal(http.ListenAndServe(listenAddr, nil))
   }
   

3. Pressione Ctrl + Shift + ` ou selecione Novo Terminal no menu Terminal para abrir um novo terminal integrado no VS Code.

4. Compile seu manipulador personalizado usando o comando a seguir. Um arquivo executável chamado handler (handler.exe no Windows) é gerado na pasta raiz do aplicativo de funções.

   go build handler.go
   

1. Pressione Ctrl + Shift + ` ou selecione Novo Terminal no menu Terminal para abrir um novo terminal integrado no VS Code.

2. Na raiz do aplicativo de funções (a mesma pasta que host.json), inicialize um projeto do Rust chamado .

   cargo init --name handler
   

3. Em Cargo.toml, adicione as dependências a seguir, necessárias para concluir este guia de início rápido. O exemplo usa a estrutura de servidor Web warp.

   [dependencies]
   warp = "0.3"
   tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
   

4. Em src/main.rs, adicione o código a seguir e salve o arquivo. Este é o manipulador personalizado do Rust.

   use std::collections::HashMap;
   use std::env;
   use std::net::Ipv4Addr;
   use warp::{http::Response, Filter};
   
   #[tokio::main]
   async fn main() {
       let example1 = warp::get()
           .and(warp::path("api"))
           .and(warp::path("HttpExample"))
           .and(warp::query::<HashMap<String, String>>())
           .map(|p: HashMap<String, String>| match p.get("name") {
               Some(name) => Response::builder().body(format!("Hello, {}. This HTTP triggered function executed successfully.", name)),
               None => Response::builder().body(String::from("This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.")),
           });
   
       let port_key = "FUNCTIONS_CUSTOMHANDLER_PORT";
       let port: u16 = match env::var(port_key) {
           Ok(val) => val.parse().expect("Custom Handler port is not a number!"),
           Err(_) => 3000,
       };
   
       warp::serve(example1).run((Ipv4Addr::LOCALHOST, port)).await
   }
   

5. Compile um binário para seu manipulador personalizado. Um arquivo executável chamado handler (handler.exe no Windows) é gerado na pasta raiz do aplicativo de funções.

   cargo build --release
   cp target/release/handler .
   

Configurar seu aplicativo de funções

O host de função precisa ser configurado para executar o binário do manipulador personalizado quando ele é iniciado.

1. Abra host.json.

2. Na seção customHandler.description, defina o valor de defaultExecutablePath como handler (em Windows, defina-o como handler.exe).

3. Na seção , adicione uma propriedade chamada e defina o valor dela como . Para funções formadas apenas em um gatilho HTTP, essa configuração simplifica a programação, permitindo que você trabalhe com uma solicitação HTTP típica em vez do conteúdo de solicitação do manipulador personalizado.

4. Confirme que a seção é semelhante a este exemplo. Salve o arquivo.

   "customHandler": {
     "description": {
       "defaultExecutablePath": "handler",
       "workingDirectory": "",
       "arguments": []
     },
     "enableForwardingHttpRequest": true
   }
   

O aplicativo de funções está configurado para iniciar o executável do manipulador personalizado.

Executar a função localmente

Visual Studio Code integra-se às ferramentas Azure Functions Core para permitir que você execute esse projeto no computador de desenvolvimento local antes de publicar no Azure.

1. Para iniciar a função localmente, pressione F5 ou o ícone Executar e Depurar na barra Atividade do lado esquerdo. O painel Terminal exibirá a saída do Core Tools. Seu aplicativo é iniciado no painel Terminal. Você pode ver o ponto de extremidade de URL de sua função disparada por HTTP localmente.

   Captura de tela da saída do VS Code da função local.

   Se você tiver problemas para executar em Windows, verifique se o terminal padrão para Visual Studio Code não está definido como WSL Bash.

2. Com as Ferramentas Principais ainda em execução no Terminal, escolha o ícone Azure na barra de atividades. Na área Workspace, expanda Projeto LocalFunções. Clique com o botão direito do mouse (Windows) ou Ctrl - clique (macOS) na nova função e escolha Execute Function Now... .

   

3. Em Enter request body você vê o valor do corpo da mensagem de solicitação de { "name": "Azure" }. Clique em ENTER para enviar essa mensagem de solicitação à função.

4. Quando a função é executada localmente e retorna uma resposta, uma notificação é gerada em Visual Studio Code. As informações sobre a execução da função são mostradas no painel Terminal.

5. Com o painel Terminal focalizado, pressione Ctrl + C para parar o Core Tools e desconectar o depurador.

Depois de verificar se a função é executada corretamente em seu computador local, você pode usar opcionalmente ferramentas de IA, como GitHub Copilot em Visual Studio Code, para atualizar o código de função gerado pelo modelo.

Usar a IA para normalizar e validar a entrada

Este exemplo de prompt para o Copilot Chat atualiza o código de função existente para recuperar os parâmetros de uma cadeia de caracteres de consulta ou do texto JSON. Ele aplica conversões de tipo ou formatação e retorna os parâmetros como JSON na resposta:

Modify the function to accept name, email, and age from the JSON body of the
request. If any of these parameters are missing from the query string, read
them from the JSON body. Return all three parameters in the JSON response, 
applying these rules:
Title-case the name
Lowercase the email
Convert age to an integer if possible, otherwise return "not provided"
Use sensible defaults if any parameter is missing
Make sure that any added packages are compatible with the version of the packages already in the project

Modify the function to accept name, email, and age from the JSON body of the
request. If any of these parameters are missing from the query string, read
them from the JSON body. Return all three parameters in the JSON response, 
applying these rules:
Title-case the name
Lowercase the email
Convert age to an integer if possible, otherwise return "not provided"
Use sensible defaults if any parameter is missing

Modify the function to accept name, email, and age from the JSON body of the
request. If any of these parameters are missing from the query string, read
them from the JSON body. Return all three parameters in the JSON response, 
applying these rules:
Title-case the name
Lowercase the email
Convert age to an integer if possible, otherwise return "not provided"
Use sensible defaults if any parameter is missing
Update the FunctionTest.java file to test the new logic. 

Você pode personalizar seu prompt para adicionar detalhes conforme necessário. Em seguida, execute o aplicativo novamente localmente e verifique se ele funciona conforme o esperado após as alterações de código. Desta vez, use um corpo de mensagem como:

{ "name": "devon torres", "email": "torres.devon@contoso.com", "age": "34" }

Dica

GitHub Copilot é alimentado pela IA, portanto, surpresas e erros são possíveis. Se você encontrar erros durante a execução, cole a mensagem de erro na janela de chat, selecione Agent modo e peça a Copilot para ajudar a resolver o erro. Para obter mais informações, consulte Copilot perguntas frequentes.

Ao executar no modo Agente , os resultados dessa personalização dependem das ferramentas específicas disponíveis para o agente.

Quando estiver satisfeito com seu aplicativo, use Visual Studio Code para publicar o projeto diretamente no Azure.

Depois de verificar se a função é executada corretamente no computador local, use Visual Studio Code para publicar o projeto diretamente no Azure.

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 Recursos, selecione Fazer login 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 o aplicativo de funções no Azure

Nesta seção, você criará um aplicativo de funções no plano de Consumo Flex juntamente com os recursos relacionados em sua assinatura de Azure. Muitas das decisões de criação de recursos são tomadas para você com base em comportamentos padrão. Para obter mais controle sobre os recursos criados, você deve, em vez disso, criar seu aplicativo de funções com opções avançadas.

1. Em Visual Studio Code, selecione F1 para abrir a paleta de comandos. No prompt (>), insira e selecione Azure Functions: Criar Aplicativo de Funções no Azure.

2. Nos prompts, forneça as informações a seguir:

   Rápido	Ação
   Selecionar assinatura	Selecione a assinatura Azure a ser usada. O prompt não aparece quando você tem apenas uma assinatura visível em Recursos.
   Insira um novo nome do aplicativo de funções	Insira um nome global exclusivo que seja válido em um caminho de URL. O nome inserido é validado para garantir que ele seja exclusivo em Azure Functions.
   Selecione uma localização para novos recursos	Selecione uma região Azure. Para obter um melhor desempenho, escolha uma região perto de você. Somente as regiões compatíveis com os planos de Consumo Flex são exibidas.
   Selecionar uma pilha de runtime	Selecione a versão da linguagem que você executa localmente no momento.
   Selecionar tipo de autenticação de recurso	Selecione a identidade gerenciada, que é a opção mais segura para se conectar à conta de armazenamento de host padrão.

   No painel Azure: Log de Atividades, a extensão Azure mostra o status dos recursos individuais conforme eles são criados em Azure.

   

3. Quando o aplicativo de funções é criado, os seguintes recursos relacionados são criados em sua assinatura Azure. Os recursos são nomeados com base no nome que você inseriu para o seu aplicativo de funções.

   • Um grupo de recursos, que é um contêiner lógico para recursos relacionados.
   • Um aplicativo de funções, que fornece o ambiente para a execução do código de função. Um aplicativo de funções lhe permite agrupar funções como uma unidade lógica para facilitar o gerenciamento, a implantação e o compartilhamento de recursos dentro do mesmo plano de hospedagem.
   • Um plano Azure App Service, que define o host subjacente para seu aplicativo de funções.
   • Uma conta Azure Storage padrão, que é usada pelo host do Functions para manter o estado e outras informações sobre seu aplicativo de funções.
   • Uma instância do Application Insights conectada ao aplicativo de funções que acompanha o uso das suas funções no aplicativo.
   • Uma identidade gerenciada atribuída pelo usuário adicionada à função Colaborador de Dados de Blobs de Armazenamento na nova conta de armazenamento de host padrão.

   Uma notificação é exibida depois que seu aplicativo de funções é criado e o pacote de implantação é aplicado.

   Dica

   Por padrão, os recursos de Azure exigidos pelo aplicativo de funções são criados com base no nome inserido para seu aplicativo de funções. Por padrão, os recursos são criados com o aplicativo de funções no mesmo novo grupo de recursos. Se você quiser personalizar os nomes dos recursos associados ou reutilizar os recursos existentes, publique o projeto com opções avançadas de criação.

Compilar o manipulador personalizado para Azure

Nesta seção, você compila seu projeto para implantação para Azure em um aplicativo de funções que executa o Linux. Na maioria dos casos, você precisa recompilar seu binário e ajustar sua configuração para corresponder à plataforma de destino antes de publicá-la para Azure.

• No terminal integrado, compile o manipulador em Linux/x64.

  GOOS=linux GOARCH=amd64 go build handler.go
  

  GOOS=linux GOARCH=amd64 go build handler.go
  

  Windows

  set GOOS=linux
  set GOARCH=amd64
  go build handler.go
  

  Altere o em host.json de para . Essa alteração instrui o aplicativo de funções a executar o binário do Linux.

Um binário chamado é criado na raiz do aplicativo de funções.

1. Crie um arquivo em .cargo/configuração. Adicione o conteúdo a seguir e salve o arquivo.

   [target.x86_64-unknown-linux-musl]
   linker = "rust-lld"
   

2. No terminal integrado, compile o manipulador em Linux/x64. Um binário chamado é criado. Copie-o para a raiz do aplicativo de funções.

   rustup target add x86_64-unknown-linux-musl
   cargo build --release --target=x86_64-unknown-linux-musl
   cp target/x86_64-unknown-linux-musl/release/handler .
   

3. Se você estiver usando Windows, altere o defaultExecutablePath em host.json de handler.exe para handler. Essa alteração instrui o aplicativo de funções a executar o binário do Linux.

4. Adicione a seguinte linha ao arquivo .funcignore:

   target
   

   Essa linha impede a publicação do conteúdo da pasta de destino .

Implantar o projeto para Azure

Importante

A implantação em um aplicativo de funções existente sempre substitui o conteúdo do aplicativo no Azure.

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. 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.

   Captura de tela da janela Exibir saída.

Executar a função no Azure

1. Pressione F1 para exibir a paleta de comandos e, em seguida, pesquise e execute o comando Azure Functions:Execute Function Now.... Se solicitado, selecione sua assinatura.

2. Selecione seu novo recurso do aplicativo de funções e como sua função.

3. Em Inserir o corpo da solicitação, digite , em seguida, pressione Enter para enviar essa mensagem de solicitação para sua função.

4. Quando a função é executada em Azure, a resposta é exibida na área de notificação. Expanda a notificação para revisar a resposta completa.

Resolução de problemas

Use a tabela a seguir para resolver os problemas mais comuns encontrados ao usar este artigo.

Problema	Solução
Não consegue criar um projeto de função local?	Verifique se você tem a extensão Azure Functions instalada.
Não consegue executar a função localmente?	Verifique se você tem a versão mais recente do Azure Functions Core Tools instalado. Ao executar no Windows, verifique se o shell de terminal padrão para Visual Studio Code não está definido como WSL Bash.
Não é possível implantar a função no Azure?	Examine a saída para obter informações sobre o erro. O ícone de sino no canto inferior direito é outra maneira de ver a saída. Você publicou em um aplicativo de funções existente? Essa ação substitui o conteúdo desse aplicativo em Azure.
Não conseguiu executar o aplicativo de funções baseado em nuvem?	Lembre-se de usar a cadeia de caracteres de consulta para enviar parâmetros ou usar o corpo da solicitação para manipuladores personalizados.

Limpar os recursos

Quando você passar para a próxima etapa e adicionar uma associação de fila do Armazenamento do Azure à sua função, você precisará manter todos os seus recursos em vigor para se basear no que você já fez.

Caso contrário, você poderá usar as etapas a seguir para excluir o aplicativo de funções e recursos relacionados para evitar incorrer em custos adicionais.

1. Em Visual Studio Code, selecione o ícone Azure para abrir o gerenciador de Azure.
2. Na seção grupos de recursos, localize o grupo de recursos.
3. Clique com o botão direito do mouse no nome do grupo de recursos e selecione Excluir.

Para saber mais sobre os custos do Functions, confira Estimar os custos do plano de consumo.

Próximas etapas

Você usou Visual Studio Code para criar um aplicativo de funções com uma função simples disparada por HTTP. Nos próximos artigos, você expande essa função conectando-se a Azure Cosmos DB ou Azure Storage. Para saber mais sobre como se conectar a outros serviços do Azure, consulte Adicionar vinculações a uma função existente no Azure Functions. Se você quiser saber mais sobre segurança, consulte Securing Azure Functions.

Conectar para Azure Cosmos DB

Conectar a Azure Queue Storage

Manipuladores personalizados do Azure Functions