Guia de início rápido: criar uma função no Azure a partir da linha de comando

Neste artigo, você usa ferramentas de linha de comando local para criar uma função que responde a solicitações HTTP. Depois de verificar seu código localmente, implante-o em um plano de hospedagem do Flex Consumption sem servidor no Azure Functions.

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.

Prerequisites

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

Kit de desenvolvimento Java 17
- Se você usar outra versão suportada do Java, deverá atualizar o arquivo pom.xml do projeto.
- A JAVA_HOME variável de ambiente deve ser definida para o local de instalação da versão correta do Java Development Kit (JDK).
Apache Maven 3.8.x

20Node.js

Vá
Ferrugem

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

CLI do Azure
O jq processador JSON de linha de comando, usado para analisar a saída JSON, também está disponível no Azure Cloud Shell.

Instalar as Ferramentas de Núcleo de Funções do Azure

A maneira recomendada de instalar o Core Tools depende do sistema operacional do seu computador de desenvolvimento local.

As etapas a seguir usam um instalador do Windows (MSI) para instalar o Core Tools v4.x. Para obter mais informações sobre outros instaladores baseados em pacotes, consulte o readme das Ferramentas Core.

Transfira e execute o instalador das Ferramentas Principais, com base na sua versão do Windows:

v4.x - Windows de 64 bits (Recomendado. A depuração de código do Visual Studio requer 64 bits.)
v4.x - Windows de 32 bits

Se você usou anteriormente o instalador do Windows (MSI) para instalar o Core Tools no Windows, você deve desinstalar a versão antiga de Adicionar remover programas antes de instalar a versão mais recente.

As etapas a seguir usam o Homebrew para instalar as ferramentas principais no macOS.

Instale o Homebrew, se ainda não estiver instalado.

Instale o pacote Core Tools:

brew tap azure/functions
brew install azure-functions-core-tools@4
# if upgrading on a machine that has 2.x or 3.x installed:
brew link --overwrite azure-functions-core-tools@4

Os passos seguintes utilizam o APT para instalar as Core Tools na sua distribuição Linux Ubuntu/Debian. Para outras distribuições Linux, consulte o readme das Ferramentas Principais.

Instale a chave GPG do repositório de pacotes da Microsoft para validar a integridade do pacote:

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg

Configure a lista de fontes do APT antes de executar uma atualização do APT.

Ubuntu

sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-$(lsb_release -cs 2>/dev/null)-prod $(lsb_release -cs 2>/dev/null) main" > /etc/apt/sources.list.d/dotnetdev.list'

Debian

sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/debian/$(lsb_release -rs 2>/dev/null | cut -d'.' -f 1)/prod $(lsb_release -cs 2>/dev/null) main" > /etc/apt/sources.list.d/dotnetdev.list'

Verifique o arquivo /etc/apt/sources.list.d/dotnetdev.list para uma string de versão apropriada do Linux na tabela a seguir.

Distribuição Linux	Version
Debian 12	`bookworm`
Debian 11	`bullseye`
Debian 10	`buster`
Debian 9	`stretch`
Ubuntu 24,04	`noble`
Ubuntu 22,04	`jammy`
Ubuntu 20,04	`focal`
Ubuntu 19,04	`disco`
Ubuntu 18.10	`cosmic`
Ubuntu 18.04	`bionic`
Ubuntu 17,04	`zesty`
Ubuntu 16.04/Linux Mint 18	`xenial`

Inicie a atualização do repositório APT:
```
sudo apt-get update
```

Instale o pacote Core Tools:

sudo apt-get install azure-functions-core-tools-4

Criar e ativar um ambiente virtual

Em uma pasta adequada, execute os seguintes comandos para criar e ativar um ambiente virtual chamado .venv. Certifique-se de usar uma das versões do Python suportadas pelo Azure Functions.

python -m venv .venv

source .venv/bin/activate

Se o Python não instalou o pacote venv na sua distribuição Linux, execute o seguinte comando:

sudo apt-get install python3-venv

py -m venv .venv

.venv\scripts\activate

py -m venv .venv

.venv\scripts\activate

Execute todos os comandos subsequentes neste ambiente virtual ativado.

Criar um projeto e uma função de código local

No Azure Functions, o seu projeto de código é uma aplicação que contém uma ou mais funções individuais, cada uma respondendo a um disparador específico. Todas as funções em um projeto compartilham as mesmas configurações e são implantadas como uma unidade no Azure. Nesta seção, você cria um projeto de código que contém uma única função.

Em um terminal ou prompt de comando, execute este func init comando para criar um projeto de aplicativo de função na pasta atual:
```
func init --worker-runtime dotnet-isolated 
```

Em um terminal ou prompt de comando, execute este func init comando para criar um projeto de aplicativo de função na pasta atual:
```
func init --worker-runtime node --language javascript 
```

Em um terminal ou prompt de comando, execute este func init comando para criar um projeto de aplicativo de função na pasta atual:
```
func init --worker-runtime powershell 
```

Em um terminal ou prompt de comando, execute este func init comando para criar um projeto de aplicativo de função na pasta atual:
```
func init --worker-runtime python 
```

Em um terminal ou prompt de comando, execute este func init comando para criar um projeto de aplicativo de função na pasta atual:
```
func init --worker-runtime node --language typescript 
```

Em um terminal ou prompt de comando, execute este func init comando para criar um projeto de aplicativo de função na pasta atual:
```
func init --worker-runtime custom 
```

Em uma pasta vazia, execute este mvn comando para gerar o projeto de código de um arquétipo do Azure Functions Maven:

mvn archetype:generate -DarchetypeGroupId=com.microsoft.azure -DarchetypeArtifactId=azure-functions-archetype -DjavaVersion=17

mvn archetype:generate "-DarchetypeGroupId=com.microsoft.azure" "-DarchetypeArtifactId=azure-functions-archetype" "-DjavaVersion=17"

mvn archetype:generate "-DarchetypeGroupId=com.microsoft.azure" "-DarchetypeArtifactId=azure-functions-archetype" "-DjavaVersion=17"

Important

Se quiser que as suas funções sejam executadas no Java 11, utilize -DjavaVersion=11. Para saber mais, consulte Versões Java.
Defina a JAVA_HOME variável ambiente para a localização de instalação da versão correta do JDK para completar este artigo.

O Maven solicita os valores necessários para concluir a geração do projeto durante a implantação.
Forneça os seguintes valores quando solicitado:

Prompt	Value	Description
groupId	`com.fabrikam`	Um valor que identifica exclusivamente o seu projeto em relação a todos os outros, seguindo as regras de nomenclatura de pacotes para Java.
artifactId	`fabrikam-functions`	Um valor que é o nome do JAR, sem um número de versão.
version	`1.0-SNAPSHOT`	Escolha o valor padrão.
package	`com.fabrikam`	Um valor que é o pacote Java para o código de função gerado. Utilize a predefinição.

Digite Y ou pressione Enter para confirmar.

Maven cria os arquivos de projeto em uma nova pasta com um nome de artifactId, que neste exemplo é fabrikam-functions.
Navegue até a pasta do projeto:
```
cd fabrikam-functions
```
Você pode revisar o código gerado por modelo para sua nova função de gatilho HTTP em Function.java no diretório do projeto \src\main\java\com\fabrikam .

Use este func new comando para adicionar uma função ao seu projeto:
```
func new --name HttpExample --template "HTTP trigger" --authlevel "function"
```
Um novo arquivo de código é adicionado ao seu projeto. Nesse caso, o --name argumento é o nome exclusivo da sua função (HttpExample) e o argumento especifica um gatilho --template HTTP.

A pasta raiz do projeto contém vários arquivos para o projeto, incluindo arquivos de configuração chamados local.settings.json e host.json. Como local.settings.json pode conter segredos baixados do Azure, o arquivo é excluído do controle do código-fonte por padrão no arquivo .gitignore .

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

Verifique a sua nova função executando o projeto localmente e chamando o endpoint da função.

Use este comando para iniciar o host de tempo de execução local do Azure Functions na raiz da pasta do projeto:

func start

npm install
npm start

mvn clean package  
mvn azure-functions:run

Perto do final da saída, aparecem as seguintes linhas:

 ...

 Now listening on: http://0.0.0.0:7071
 Application started. Press Ctrl+C to shut down.

 Http Functions:

         HttpExample: [GET,POST] http://localhost:7071/api/HttpExample
 ...

Copie o URL da função HttpExample desta saída para um navegador e abra o URL da função no navegador. Deves receber uma resposta de sucesso com uma mensagem de "olá mundo".

Note

Como a autorização da chave de acesso não é aplicada quando se executa localmente, o URL da função devolvido não inclui o valor da chave de acesso e não precisa dele para chamar a sua função.
Quando terminar, use Ctrl+C e opte por y parar o host de funções.

Criar recursos de suporte do Azure para sua função

Antes de implantar seu código de função no Azure, você precisa criar estes recursos:

Um grupo de recursos, que é um contêiner lógico para recursos relacionados.
Uma conta de armazenamento padrão, que é usada pelo host Functions para manter o estado e outras informações sobre suas funções.
Uma identidade gerenciada atribuída pelo usuário, que o host do Functions usa para se conectar à conta de armazenamento padrão.
Um aplicativo de função, que fornece o ambiente para executar seu código de função. Uma aplicação de funções corresponde ao seu projeto de funções local e permite-lhe agrupar funções como uma unidade lógica para facilitar o gerenciamento, a implantação e o compartilhamento de recursos.

Use os comandos da CLI do Azure nestas etapas para criar os recursos necessários.

Se ainda não o fez, inicie sessão no Azure:
```
az login
```
O az login comando inicia sessão na sua conta do Azure. Ignore esta etapa ao executar no Azure Cloud Shell.
Se você ainda não tiver feito isso, use este az extension add comando para instalar a extensão do Application Insights:
```
az extension add --name application-insights
```
Use este comando az group create para criar um grupo de recursos nomeado AzureFunctionsQuickstart-rg na região escolhida:
```
az group create --name "AzureFunctionsQuickstart-rg" --location "<REGION>"
```
Neste exemplo, substitua <REGION> por uma região perto de você que ofereça suporte ao plano Flex Consumption. Use o comando az functionapp list-flexconsumption-locations para exibir a lista de regiões atualmente suportadas.
Use este comando az storage account create para criar uma conta de armazenamento de uso geral em seu grupo de recursos e região:
```
az storage account create --name <STORAGE_NAME> --location "<REGION>" --resource-group "AzureFunctionsQuickstart-rg" \
--sku "Standard_LRS" --allow-blob-public-access false --allow-shared-key-access false
```
Neste exemplo, substitua <STORAGE_NAME> por um nome apropriado para você e exclusivo no Armazenamento do Azure. Os nomes devem conter de três a 24 caracteres, números e letras minúsculas apenas. Standard_LRS especifica uma conta de uso geral, que é suportada pelo Functions. Essa nova conta só pode ser acessada usando identidades autenticadas pelo Microsoft Entra, que receberam permissões para recursos específicos.
Use este script para criar uma identidade gerenciada atribuída pelo usuário, analisar as propriedades JSON retornadas do objeto usando jqe conceder Storage Blob Data Owner permissões na conta de armazenamento padrão:
```
output=$(az identity create --name "func-host-storage-user" --resource-group "AzureFunctionsQuickstart-rg" --location <REGION> \
--query "{userId:id, principalId: principalId, clientId: clientId}" -o json)

userId=$(echo $output | jq -r '.userId')
principalId=$(echo $output | jq -r '.principalId')
clientId=$(echo $output | jq -r '.clientId')

storageId=$(az storage account show --resource-group "AzureFunctionsQuickstart-rg" --name <STORAGE_NAME> --query 'id' -o tsv)
az role assignment create --assignee-object-id $principalId --assignee-principal-type ServicePrincipal \
--role "Storage Blob Data Owner" --scope $storageId
```
Se você não tiver o jq utilitário em seu shell Bash local, ele estará disponível no Azure Cloud Shell. Neste exemplo, substitua <STORAGE_NAME> e <REGION> pelo nome e região da conta de armazenamento padrão, respectivamente.

O comando az identity create cria uma identidade chamada func-host-storage-user. O retornado principalId é usado para atribuir permissões a essa nova identidade na conta de armazenamento padrão usando o az role assignment create comando. O az storage account show comando é usado para obter o ID da conta de armazenamento.

Use este comando az functionapp create para criar o aplicativo de função no Azure:

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime dotnet-isolated --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime java --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime node --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime python --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime python --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime other --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

Neste exemplo, substitua esses espaços reservados pelos valores apropriados:

<APP_NAME>: um nome globalmente exclusivo apropriado para você. O <APP_NAME> também é o domínio DNS predefinido para a aplicação de funções.
<STORAGE_NAME>: o nome da conta que você usou na etapa anterior.
<REGION>: a sua região atual.
<LANGUAGE_VERSION>: usar a mesma versão suportada da pilha de linguagem que verificou localmente, quando aplicável.

Este comando cria um aplicativo funcional em execução em seu tempo de execução de linguagem especificado no Linux no Plano de Consumo Flex, que é gratuito para a quantidade de uso que você incorre aqui. O comando também cria uma instância associada do Azure Application Insights no mesmo grupo de recursos, com a qual você pode usar para monitorar suas execuções de aplicativo de função e exibir logs. Para obter mais informações, consulte Monitorizar Azure Functions. A instância não incorre em custos até que você a ative.

Use este script para adicionar sua identidade gerenciada atribuída pelo usuário à função Monitoring Metrics Publisher em sua instância do Application Insights:
```
appInsights=$(az monitor app-insights component show --resource-group "AzureFunctionsQuickstart-rg" \
    --app <APP_NAME> --query "id" --output tsv)
principalId=$(az identity show --name "func-host-storage-user" --resource-group "AzureFunctionsQuickstart-rg" \
    --query principalId -o tsv)
az role assignment create --role "Monitoring Metrics Publisher" --assignee $principalId --scope $appInsights
```
Neste exemplo, substitua <APP_NAME> pelo nome do seu aplicativo de função. O comando az role assignment create adiciona seu usuário à função. O ID de recurso da sua instância do Application Insights e o ID principal do seu utilizador são obtidos usando os comandos az monitor app-insights component show e az identity show, respetivamente.

Atualizar configurações do aplicativo

Para permitir que o host de Funções se ligue à conta de armazenamento predefinida usando segredos partilhados, substitua a definição da string de ligação AzureWebJobsStorage por várias definições que tenham o prefixo AzureWebJobsStorage__. Essas configurações definem uma configuração complexa que seu aplicativo usa para se conectar ao armazenamento e ao Application Insights com uma identidade gerenciada atribuída pelo usuário.

Use este script para obter a ID de cliente da identidade gerida atribuída pelo utilizador e utilizá-la para definir conexões de identidades geridas tanto para o armazenamento como para o Application Insights.

clientId=$(az identity show --name func-host-storage-user \
    --resource-group AzureFunctionsQuickstart-rg --query 'clientId' -o tsv)
az functionapp config appsettings set --name <APP_NAME> --resource-group "AzureFunctionsQuickstart-rg" \
    --settings AzureWebJobsStorage__accountName=<STORAGE_NAME> \
    AzureWebJobsStorage__credential=managedidentity AzureWebJobsStorage__clientId=$clientId \
    APPLICATIONINSIGHTS_AUTHENTICATION_STRING="ClientId=$clientId;Authorization=AAD"

Neste script, substitua <APP_NAME> e <STORAGE_NAME> pelos nomes do seu aplicativo de função e conta de armazenamento, respectivamente.

Execute o comando az functionapp config appsettings delete para remover a configuração da cadeia de conexão existente AzureWebJobsStorage , que contém uma chave de segredo compartilhado:
```
az functionapp config appsettings delete --name <APP_NAME> --resource-group "AzureFunctionsQuickstart-rg" --setting-names AzureWebJobsStorage
```
Neste exemplo, substitua <APP_NAME> pelos nomes do seu aplicativo de função.

Neste ponto, o anfitrião de Funções pode ligar-se à conta de armazenamento de forma segura usando identidades geridas em vez de segredos partilhados. Agora você pode implantar seu código de projeto nos recursos do Azure.

Implantar o projeto de função no Azure

Depois de criar com êxito seu aplicativo de função no Azure, você está pronto para implantar seu projeto de funções locais usando o func azure functionapp publish comando.

Na pasta raiz do projeto, execute este func azure functionapp publish comando:

func azure functionapp publish <APP_NAME>

Neste exemplo, substitua <APP_NAME> pelo nome do seu aplicativo. Uma implantação bem-sucedida mostra resultados semelhantes à seguinte saída (truncada para simplificar):

 ...

 Getting site publishing info...
 Creating archive for current directory...
 Performing remote build for functions project.

 ...

 Deployment successful.
 Remote build succeeded!
 Syncing triggers...
 Functions in msdocs-azurefunctions-qs:
     HttpExample - [httpTrigger]
         Invoke url: https://msdocs-azurefunctions-qs.azurewebsites.net/api/httpexample

No seu terminal local ou no prompt de comandos, execute este comando para obter o valor do endpoint URL, incluindo a chave de acesso:
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
Neste exemplo, substitua <APP_NAME> novamente pelo nome da sua aplicação.
Copie o URL e a chave do endpoint devolvidos, que usa para invocar o endpoint da função.

Atualizar o arquivo pom.xml

Depois de criares com sucesso a tua app de funções no Azure, atualiza o ficheiro pom.xml para que o Maven possa ser implementado na tua nova aplicação. Caso contrário, o Maven cria um novo conjunto de recursos Azure durante a implementação.

No Azure Cloud Shell, use este az functionapp show comando para obter a URL e a ID do contêiner de implantação da nova identidade gerenciada atribuída pelo usuário:

az functionapp show --name <APP_NAME> --resource-group AzureFunctionsQuickstart-rg  \
    --query "{userAssignedIdentityResourceId: properties.functionAppConfig.deployment.storage.authentication.userAssignedIdentityResourceId, \
    containerUrl: properties.functionAppConfig.deployment.storage.value}"

Neste exemplo, substitua <APP_NAME> pelos nomes do seu aplicativo de função.

No diretório raiz do projeto, abra o ficheiro pom.xml num editor de texto, localize o properties elemento e atualize estes valores específicos de propriedade:

Nome da propriedade	Value
`java.version`	Use a mesma versão da pilha de idiomas suportada que você verificou localmente, como `17`.
`azure.functions.maven.plugin.version`	`1.37.1`
`azure.functions.java.library.version`	`3.1.0`
`functionAppName`	O nome do seu aplicativo de função no Azure.

Encontre a configuration seção do azure-functions-maven-plugin e substitua-a por este fragmento XML azure-functions-maven-plugin.

<configuration>
    <appName>${functionAppName}</appName>
    <resourceGroup>AzureFunctionsQuickstart-rg</resourceGroup>
    <pricingTier>Flex Consumption</pricingTier>
    <region>....</region>
    <runtime>
        <os>linux</os>
        <javaVersion>${java.version}</javaVersion>
    </runtime>
    <deploymentStorageAccount>...</deploymentStorageAccount>
    <deploymentStorageResourceGroup>AzureFunctionsQuickstart-rg</deploymentStorageResourceGroup>
    <deploymentStorageContainer>...</deploymentStorageContainer>
    <storageAuthenticationMethod>UserAssignedIdentity</storageAuthenticationMethod>
    <userAssignedIdentityResourceId>...</userAssignedIdentityResourceId>
    <appSettings>
        <property>
            <name>FUNCTIONS_EXTENSION_VERSION</name>
            <value>~4</value>
        </property>
    </appSettings>
</configuration>

No novo configuration elemento, faça estas substituições específicas dos valores de elipses (...):

Configuration	Value
`region`	O código de região do seu aplicativo de função existente, como `eastus`.
`deploymentStorageAccount`	O nome da sua conta de armazenamento.
`deploymentStorageContainer`	O nome da partilha de implementação, que vem depois do `\` no valor `containerUrl` que obtiveste.
`userAssignedIdentityResourceId`	O ID de recurso totalmente qualificado da sua identidade gerenciada, que você obteve.

Salve as alterações no arquivo pom.xml .

Agora você pode usar o Maven para implantar seu projeto de código em seu aplicativo existente.

Implantar o projeto de função no Azure

Na linha de comandos, execute este comando:
```
mvn clean package azure-functions:deploy
```
Depois de a sua implementação ter sucesso, execute este comando Core Tools para obter o valor do endpoint URL, incluindo a chave de acesso:
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
Neste exemplo, substitua <APP_NAME> novamente pelo nome da sua aplicação.
Copie o URL e a chave do endpoint devolvidos, que usa para invocar o endpoint da função.

Invoque a função no Azure

Como a sua função usa um gatilho HTTP e suporta pedidos GET, invoca-a fazendo um pedido HTTP ao seu URL usando a chave de acesso ao nível da função. É mais fácil executar um pedido GET num navegador.

Cola o URL e a chave de acesso que copiaste numa barra de endereços do navegador.

A URL do endpoint deve ser semelhante a este exemplo:

https://contoso-app.azurewebsites.net/api/httpexample?code=aabbccdd...

Neste caso, deve também fornecer uma chave de acesso na cadeia de consulta ao fazer um pedido GET à URL do endpoint. Recomenda-se o uso de uma chave de acesso para limitar o acesso de clientes aleatórios. Ao fazer um pedido POST usando um cliente HTTP, deve em vez disso fornecer a chave de acesso no x-functions-key cabeçalho.

Quando você navega para esse URL, o navegador deve exibir uma saída semelhante à de quando você executou a função localmente.

Limpeza de recursos

Se continuares para a próxima etapa e adicionares uma ligação de saída de fila do Armazenamento do Azure, mantém todos os teus recursos no lugar, porque assim aproveitarás o que já fizeste.

Caso contrário, use o comando a seguir para excluir o grupo de recursos e todos os recursos contidos para evitar incorrer em custos adicionais.

CLI do Azure
Azure PowerShell

az group delete --name AzureFunctionsQuickstart-rg

Remove-AzResourceGroup -Name AzureFunctionsQuickstart-rg

Próximos passos

Conectar-se ao Armazenamento de Filas do Azure

Comentários

Esta página foi útil?

Last updated on 2025-12-04

Partilhar via

Guia de início rápido: criar uma função no Azure a partir da linha de comando

Prerequisites

Instalar as Ferramentas de Núcleo de Funções do Azure

Criar e ativar um ambiente virtual

Criar um projeto e uma função de código local

Crie e construa a sua função

Configurar seu aplicativo de função

Executar a função localmente

Criar recursos de suporte do Azure para sua função

Atualizar configurações do aplicativo

Implantar o projeto de função no Azure

Atualizar o arquivo pom.xml

Implantar o projeto de função no Azure

Invoque a função no Azure

Limpeza de recursos

Próximos passos

Comentários

Recursos adicionais