Guia de início rápido: criar e implantar código de função no Azure usando o Visual Studio Code

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

Use o Visual Studio Code para criar uma função handler personalizada que responda a pedidos HTTP. Depois de verificar o código localmente, implementa-o no plano de alojamento serverless Flex Consumption no Azure Functions.

Manipuladores personalizados podem ser usados para criar funções em qualquer linguagem ou tempo de execução executando um processo de servidor HTTP. Este artigo suporta tanto o Go como o Rust.

A conclusão deste tutorial rápido implica um pequeno custo de alguns cêntimos de dólar ou menos na sua conta do Azure.

Certifique-se de selecionar sua linguagem de desenvolvimento preferida na parte superior do artigo.

Pré-requisitos

Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
Visual Studio Code em uma das plataformas suportadas.
A extensão do Azure Functions para Visual Studio Code.

SDK do .NET 8.0
Extensão C# para Visual Studio Code.

O Java Development Kit, versões 8, 11, 17 ou 21 (apenas para Linux).
Apache Maven, versão 3.0 ou superior.
O pacote de extensão Java

Node.js 18.x ou superior. Use o node --version comando para verificar sua versão.

Versões Python suportadas pelo Azure Functions. Para obter mais informações, consulte Como instalar o Python.
A extensão Python para Visual Studio Code.

Vá
Ferrugem

Vá, última versão recomendada. Use o go version comando para verificar sua versão.

Instalar ou atualizar as ferramentas principais

A extensão do Azure Functions para Visual Studio Code integra-se com as Ferramentas Principais do Azure Functions para que você possa executar e depurar suas funções localmente no Visual Studio Code usando o tempo de execução 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.

No Visual Studio Code, selecione F1 para abrir a paleta de comandos e, em seguida, procure e execute o comando Azure Functions: Install or Update Core Tools.

Este 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, deverá instalar ou atualizar manualmente as Ferramentas Principais.

Criar o seu projeto local

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

No Visual Studio Code, pressione F1 para abrir a paleta de comandos. Procure e execute o comando Azure Functions: Create New Project....
Escolha o local do diretório para o espaço de trabalho do projeto e escolha Selecionar. Você deve criar uma nova pasta ou escolher uma pasta vazia para o espaço de trabalho do projeto. Não escolha uma pasta de projeto que já faça parte de um espaço de trabalho.

Forneça as seguintes informações quando solicitado:

Pronta	Seleção
Selecione um idioma	Escolha `C#`.
Selecione um tempo de execução do .NET	Escolha `.NET 8.0 LTS`.
Selecione um modelo para a primeira função do seu projeto	Escolha `HTTP trigger`.
Fornecer um nome de função	Escreva `HttpExample`.
Fornecer um namespace	Escreva `My.Functions`.
Nível de autorização	Escolha `Function`, que requer uma chave de acesso para chamar o endpoint da sua função. Para obter mais informações, consulte Nível de autorização.
Selecione como gostaria de abrir o seu projeto	Escolha `Open in current window`.

Pronta	Seleção
Selecione um idioma	Escolha `Java`.
Selecione uma versão do Java	Escolha `Java 8`, `Java 11Java 17` ou `Java 21`, a versão Java na qual suas funções são executadas no Azure. Escolha uma versão do Java que você verificou localmente.
Fornecer um ID de grupo	Escolha `com.function`.
Fornecer um ID de artefato	Escolha `myFunction`.
Fornecer uma versão	Escolha `1.0-SNAPSHOT`.
Forneça um nome de pacote	Escolha `com.function`.
Fornecer um nome de aplicativo	Escolha `myFunction-12345`.
Selecione um modelo para a primeira função do seu projeto	Escolha `HTTP trigger`.
Selecione a ferramenta de construção para o projeto Java	Escolha `Maven`.
Selecione como gostaria de abrir o seu projeto	Escolha `Open in current window`.

Pronta	Seleção
Selecione um idioma	Escolha `JavaScript`.
Selecione um modelo de programação JavaScript	Escolha `Model V4`.
Selecione um modelo para a primeira função do seu projeto	Escolha `HTTP trigger`.
Fornecer um nome de função	Escreva `HttpExample`.
Nível de autorização	Choose `Function`, que requer uma chave de acesso para chamar o endpoint da sua função. Para obter mais informações, consulte Nível de autorização.
Selecione como gostaria de abrir o seu projeto	Escolha `Open in current window`.

Pronta	Seleção
Selecione um idioma	Escolha `TypeScript`.
Selecione um modelo de programação JavaScript	Escolha `Model V4`.
Selecione um modelo para a primeira função do seu projeto	Escolha `HTTP trigger`.
Fornecer um nome de função	Escreva `HttpExample`.
Nível de autorização	Escolha `Function`, que requer uma chave de acesso para chamar o endpoint da função. Para obter mais informações, consulte Nível de autorização.
Selecione como gostaria de abrir o seu projeto	Escolha `Open in current window`.

Pronta	Seleção
Selecione um idioma	Escolha `Python`.
Selecione um interpretador Python para criar um ambiente virtual	Escolha o seu interpretador Python preferido. Se uma opção não for mostrada, digite o caminho completo para o binário do Python.
Selecione um modelo para a primeira função do seu projeto	Escolha `HTTP trigger`.
Nome da função que pretende criar	Introduza `HttpExample`.
Nível de autorização	Choose `FUNCTION`, que requer uma chave de acesso para chamar o endpoint da função. Para obter mais informações, consulte Nível de autorização.
Selecione como gostaria de abrir o seu projeto	Escolha `Open in current window`.

Pronta	Seleção
Selecione um idioma para o seu projeto de função	Escolha `PowerShell`.
Selecione um modelo para a primeira função do seu projeto	Escolha `HTTP trigger`.
Fornecer um nome de função	Escreva `HttpExample`.
Nível de autorização	Selecione `Function`, que requer uma chave de acesso para chamar o endpoint da função. Para obter mais informações, consulte Nível de autorização.
Selecione como gostaria de abrir o seu projeto	Escolha `Open in current window`.

Pronta	Seleção
Selecione um idioma para o seu projeto de função	Escolha `Custom Handler`.
Selecione um modelo para a primeira função do seu projeto	Escolha `HTTP trigger`.
Fornecer um nome de função	Escreva `HttpExample`.
Nível de autorização	Escolha `Function`, que requer uma chave de acesso para chamar o endpoint da função. Para obter mais informações, consulte Nível de autorização.
Selecione como gostaria de abrir o seu projeto	Escolha `Open in current window`.

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

No arquivo local.settings.json, atualize a AzureWebJobsStorage configuração como no exemplo a seguir:
```
"AzureWebJobsStorage": "UseDevelopmentStorage=true",
```
Esta configuração indica ao host local de Funções para usar o emulador de armazenamento para a ligação de armazenamento exigida pelo modelo Python v2. Quando você publica seu projeto no Azure, essa configuração usa a conta de armazenamento padrão. Se usar uma conta Azure Storage durante o desenvolvimento local, defina aqui a cadeia de ligação da sua conta de armazenamento.

Iniciar o emulador

No Visual Studio Code, pressione F1 para abrir a paleta de comandos. Na paleta de comandos, procure e selecione Azurite: Start.
Verifique a barra inferior e verifique se os serviços de emulação Azurite estão em execução. Em caso afirmativo, agora você pode executar sua função localmente.

Crie e construa a sua função

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

Vá
Ferrugem

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

Em handler.go, adicione o seguinte código e salve o arquivo. Este é o seu manipulador personalizado 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))
}

Pressione Ctrl + Shift + ' ou selecione Novo Terminal no menu Terminal para abrir um novo terminal integrado no VS Code.
Compile seu manipulador personalizado usando o seguinte comando. Um arquivo executável chamado handler (handler.exe no Windows) é gerado na pasta raiz do aplicativo de função.
```
go build handler.go
```

Pressione Ctrl + Shift + ' ou selecione Novo Terminal no menu Terminal para abrir um novo terminal integrado no VS Code.
Na função raiz do aplicativo (a mesma pasta que host.json), inicialize um projeto Rust chamado handler.
```
cargo init --name handler
```
No Cargo.toml, adicione as seguintes dependências necessárias para concluir este início rápido. O exemplo usa a estrutura do servidor Web warp .
```
[dependencies]
warp = "0.3"
tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
```

Em src/main.rs, adicione o seguinte código e salve o arquivo. Este é o seu manipulador personalizado 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
}

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ção.
```
cargo build --release
cp target/release/handler .
```

Configurar seu aplicativo de função

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

Abra host.json.
customHandler.description Na seção , defina o valor de defaultExecutablePath como handler (no Windows, defina-o como handler.exe).
customHandler Na seção , adicione uma propriedade chamada enableForwardingHttpRequest e defina seu valor como true. Para funções que consistem 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 da carga útil da solicitação do manipulador personalizado.

Confirme se customHandler a seção se parece com este exemplo. Salve o arquivo.

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

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

Executar a função localmente

O Visual Studio Code integra-se com as ferramentas principais do Azure Functions para permitir que você execute este projeto em seu computador de desenvolvimento local antes de publicar no Azure.

Para iniciar a função localmente, pressione F5 ou o ícone Executar e Depurar na barra de atividades do lado esquerdo. O painel Terminal exibe a saída das ferramentas principais. Seu aplicativo é iniciado no painel Terminal . Você pode ver o endpoint da URL da sua função acionada por HTTP a ser executada localmente.

Se você tiver problemas para executar no Windows, verifique se o terminal padrão do Visual Studio Code não está definido como WSL Bash.
Com as Ferramentas Principais ainda em execução no Terminal, escolha o ícone do Azure na barra de atividades. Na área Espaço de trabalho, expanda Funções do projeto>local. Clique com o botão direito do mouse (Windows) ou Ctrl - clique em (macOS) na nova função e escolha Executar função agora....
Em Inserir corpo da solicitação , você verá o valor do corpo da mensagem da solicitação de { "name": "Azure" }. Prima Enter para enviar esta mensagem de pedido para a sua função.
Quando a função é executada localmente e retorna uma 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 .
Com o painel Terminal focado, pressione Ctrl + C para parar as Ferramentas Principais e desconectar o depurador.

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

Use a IA para normalizar e validar a entrada

Este prompt de exemplo para o Copilot Chat atualiza o código da função existente para recuperar parâmetros da cadeia de consulta ou do corpo JSON. Aplica formatação ou conversões de tipos e devolve 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.

Pode personalizar o seu prompt para adicionar detalhes conforme necessário. Depois executa a aplicação localmente novamente e verifica se funciona como esperado após as alterações do código. Desta vez, use um corpo de mensagem como:

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

Sugestão

O GitHub Copilot é alimentado por IA, então surpresas e erros são possíveis. Se encontrar algum erro durante a execução, cole a mensagem de erro na janela de chat, selecione o modo Agente e peça ao Copilot para ajudar a resolver o erro. Para obter mais informações, consulte Copilot FAQs.

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

Quando estiver satisfeito com a sua aplicação, use o Visual Studio Code para publicar o projeto diretamente no Azure.

Depois de verificares se a função corre corretamente no teu computador local, usa o Visual Studio Code para publicar o projeto diretamente no Azure.

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

Se ainda não tiver sessão iniciada, na barra de atividades, selecione o ícone do Azure. Em seguida, em Recursos, selecione Entrar no Azure.

Se já tiver sessão iniciada e conseguir ver as suas subscrições existentes, vá para a secção seguinte. Se ainda não tiver uma conta do Azure, selecione Criar uma Conta do Azure. Os alunos podem selecionar Criar uma Conta do Azure para Estudantes.
Quando você for solicitado no navegador, selecione sua conta do Azure e entre usando suas credenciais de conta do Azure. Se criar uma nova conta, pode iniciar sessão depois de a sua conta ser criada.
Depois de iniciar sessão com êxito, pode fechar a nova janela do browser. As assinaturas que pertencem à sua conta do Azure são exibidas na barra lateral.

Criar o aplicativo de função no Azure

Nesta seção, você cria um aplicativo de função no plano Flex Consumption junto com recursos relacionados em sua assinatura do 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ção com opções avançadas.

No Visual Studio Code, selecione F1 para abrir a paleta de comandos. No prompt (>), insira e selecione Azure Functions: Create Function App in Azure.

Nos prompts, forneça as seguintes informações:

Pronta	Ação
Selecionar subscrição	Selecione a assinatura do Azure a ser usada. O prompt não aparece quando você tem apenas uma assinatura visível em Recursos.
Insira um novo nome de aplicativo de função	Insira um nome globalmente exclusivo que seja válido em um caminho de URL. O nome introduzido é validado para garantir que é exclusivo no Azure Functions.
Selecione um local para novos recursos	Selecione uma região do Azure. Para um melhor desempenho, selecione uma região perto de si. Apenas as regiões suportadas pelos planos Flex Consumption são apresentadas.
Selecione uma pilha de tempo de execução	Selecione a versão de idioma que você executa localmente no momento.
Selecionar tipo de autenticação de recurso	Selecione 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 do Azure mostra o status de recursos individuais à medida que são criados no Azure.

Captura de tela que mostra o log de criação de recursos do Azure.

Quando o aplicativo de função é criado, os seguintes recursos relacionados são criados em sua assinatura do Azure. Os recursos são nomeados com base no nome que você inseriu para seu aplicativo de função.
- Um grupo de recursos, que é um contêiner lógico para recursos relacionados.
- Um aplicativo de função, que fornece o ambiente para executar seu código de função. Um aplicativo de função 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 do Serviço de Aplicativo do Azure, que define o host subjacente para seu aplicativo de função.
- Uma conta de Armazenamento do Azure padrão, que é usada pelo host do Functions para manter o estado e outras informações sobre seu aplicativo de função.
- Uma instância do Application Insights conectada ao aplicativo de função e que rastreia o uso de suas funções no aplicativo.
- Uma identidade gerenciada atribuída pelo usuário que é adicionada à função de Colaborador de Dados de Blob de Armazenamento na nova conta de armazenamento de host padrão.
Depois de criar a aplicação de funções, é apresentada uma notificação e o pacote de implementação é aplicado.

Sugestão

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

Compilar o manipulador personalizado para o Azure

Nesta secção, compila o seu projeto para implementação no Azure numa aplicação de funções a correr Linux. Na maioria dos casos, precisas de recompilar o teu binário e ajustar a tua configuração para corresponder à plataforma de destino antes de o publicar no Azure.

Vá
Ferrugem

No terminal integrado, compile o manipulador para Linux/x64.
- macOS
- Linux
- Windows
```
GOOS=linux GOARCH=amd64 go build handler.go
```
```
GOOS=linux GOARCH=amd64 go build handler.go
```
```
set GOOS=linux
set GOARCH=amd64
go build handler.go
```
Altere o defaultExecutablePath in host.json de handler.exe para handler. Esta alteração instrui a aplicação de funções a executar o binário Linux.

Um binário chamado handler é criado na raiz do aplicativo de função.

Crie um arquivo em .cargo/config. Adicione o seguinte conteúdo e salve o arquivo.
```
[target.x86_64-unknown-linux-musl]
linker = "rust-lld"
```

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

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 .

Se estiver a usar Windows, altere a defaultExecutablePath em host.json de handler.exe para handler. Esta alteração instrui a aplicação de funções a executar o binário Linux.
Adicione a seguinte linha ao arquivo .funcignore :
```
target
```
Esta linha impede a publicação do conteúdo da pasta de destino .

Implementar o projeto no Azure

Importante

A implementação numa aplicação de funções existente sempre sobrescreve o conteúdo dessa aplicação no Azure.

Na paleta de comandos, insira e selecione Azure Functions: Deploy to Function App.
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.
Quando a implantação estiver concluída, selecione Exibir Saída para exibir os resultados da criação e da implantação, incluindo os recursos do Azure que você criou. Se você perder a notificação, selecione o ícone de sino no canto inferior direito para vê-lo novamente.

Executar a função no Azure

Pressione F1 para exibir a paleta de comandos, procure e execute o comando Azure Functions:Execute Function Now.... Se solicitado, selecione sua assinatura.
Selecione seu novo recurso de aplicativo de função e HttpExample como sua função.
Em da solicitação e, em seguida, pressione Enter para enviar essa mensagem de solicitação para sua função.
Quando a função é executada no Azure, a resposta é exibida na área de notificação. Expanda a notificação para rever a resposta completa.

Solução de problemas

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

Problema	Solução
Não é possível criar um projeto de função local?	Verifique se você tem a extensão do Azure Functions instalada.
Não é possível executar a função localmente?	Certifique-se de que tem a versão mais recente do Azure Functions Core Tools instalada. Ao executar no Windows, certifique-se de que 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?	Revise a Saída para obter informações de erro. O ícone de sino no canto inferior direito é outra maneira de visualizar a saída. Você publicou em um aplicativo de função existente? Essa ação substitui o conteúdo desse aplicativo no Azure.
Não foi possível executar o aplicativo Function baseado em nuvem?	Lembra-te de usar a string de consulta para enviar parâmetros, ou o corpo da solicitação para controladores personalizados.

Limpeza de recursos

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

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

No Visual Studio Code, selecione o ícone do Azure para abrir o explorador do Azure.
Na secção Grupos de Recursos, localize o seu grupo de recursos.
Clique com o botão direito do mouse no grupo de recursos e selecione Excluir.

Para saber mais sobre os custos do Functions, consulte Estimando os custos do plano de consumo.

Próximos passos

Usaste o Visual Studio Code para criar uma aplicação de funções com uma função simples ativada por HTTP. Nos próximos artigos, você expande essa função conectando-se ao Azure Cosmos DB ou ao Armazenamento do Azure. Para saber mais sobre como se conectar a outros serviços do Azure, consulte Adicionar associações a uma função existente no Azure Functions. Se quiser saber mais sobre segurança, consulte Protegendo o Azure Functions.

Conectar-se ao Azure Cosmos DB

Conectar-se ao Armazenamento de Filas do Azure

Handlers personalizados do Azure Functions

Comentários

Esta página foi útil?

Last updated on 2025-12-04