Quickstart: Een functie maken in Azure vanaf de opdrachtregel

In dit artikel gebruikt u lokale opdrachtregelprogramma's om een functie te maken die reageert op HTTP-aanvragen. Nadat u uw code lokaal hebt gecontroleerd, implementeert u deze in een serverloos Flex Consumption-hostingabonnement in Azure Functions.

Het voltooien van deze snelle start brengt kosten met zich mee van een paar dollarcent of minder, die in rekening worden gebracht op uw Azure-account.

Zorg ervoor dat u bovenaan het artikel de gewenste ontwikkeltaal selecteert.

Prerequisites

Een Azure-account met een actief abonnement. Gratis een account maken

Java 17 Developer Kit
- Als u een andere ondersteunde versie van Java gebruikt, moet u het pom.xml-bestand van het project bijwerken.
- De JAVA_HOME omgevingsvariabele moet worden ingesteld op de installatielocatie van de juiste versie van de Java Development Kit (JDK).
Apache Maven 3.8.x

Node.js 20

Go
Roest

Go (nieuwste versie wordt aanbevolen). Gebruik de opdracht go version om uw versie te controleren.

Azure-CLI
De jq opdrachtregel JSON-processor, die wordt gebruikt om JSON-uitvoer te parseren, is ook beschikbaar in Azure Cloud Shell.

Azure Functions Core Tools installeren

De aanbevolen manier om Core Tools te installeren, is afhankelijk van het besturingssysteem van uw lokale ontwikkelcomputer.

In de volgende stappen wordt een Windows Installer (MSI) gebruikt om Core Tools v4.x te installeren. Voor meer informatie over andere installatieprogramma's op basis van pakketten, zie de Core Tools Readme.

Download en voer het Core Tools-installatieprogramma uit op basis van uw versie van Windows:

v4.x - Windows 64-bits (aanbevolen. Visual Studio Code-foutopsporing vereist 64-bits.)
v4.x - Windows 32-bits

Als u eerder Windows Installer (MSI) hebt gebruikt om Core Tools in Windows te installeren, moet u de oude versie verwijderen uit Programma's toevoegen voordat u de nieuwste versie installeert.

In de volgende stappen wordt Homebrew gebruikt om de Core Tools op macOS te installeren.

Installeer Homebrew als deze nog niet is geïnstalleerd.

Installeer het Core Tools-pakket:

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

In de volgende stappen wordt APT gebruikt om Core Tools te installeren op uw Ubuntu/Debian Linux-distributie. Voor andere Linux-distributies, zie de Core Tools readme.

Installeer de GPG-sleutel van de Microsoft-pakketopslagplaats om pakketintegriteit te valideren:

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

Stel de APT-bronlijst in voordat u een APT-update uitvoert.

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'

Controleer het /etc/apt/sources.list.d/dotnetdev.list bestand op een van de juiste Linux-versietekenreeksen in de volgende tabel:

Linux-distributie	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`

Begin met het bijwerken van de APT-bron.
```
sudo apt-get update
```

Installeer het Core Tools-pakket:

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

Een virtuele omgeving maken en activeren

Voer de volgende opdrachten uit in een geschikte map om een virtuele omgeving met de naam .venv te maken en te activeren. Zorg ervoor dat u een van de Python-versies gebruikt die worden ondersteund door Azure Functions.

python -m venv .venv

source .venv/bin/activate

Als Python het venv-pakket niet heeft geïnstalleerd in uw Linux-distributie, voert u de volgende opdracht uit:

sudo apt-get install python3-venv

py -m venv .venv

.venv\scripts\activate

py -m venv .venv

.venv\scripts\activate

U voert alle volgende opdrachten uit in deze geactiveerde virtuele omgeving.

Een lokaal codeproject en een functie maken

In Azure Functions is uw codeproject een app die een of meer afzonderlijke functies bevat die elk reageren op een specifieke trigger. Alle functies in een project delen dezelfde configuraties en worden geïmplementeerd als een eenheid in Azure. In deze sectie maakt u een codeproject dat één functie bevat.

Voer in een terminal of opdrachtprompt deze func init opdracht uit om een functie-app-project te maken in de huidige map:
```
func init --worker-runtime dotnet-isolated 
```

Voer in een terminal of opdrachtprompt deze func init opdracht uit om een functie-app-project te maken in de huidige map:
```
func init --worker-runtime node --language javascript 
```

Voer in een terminal of opdrachtprompt deze func init opdracht uit om een functie-app-project te maken in de huidige map:
```
func init --worker-runtime powershell 
```

Voer in een terminal of opdrachtprompt deze func init opdracht uit om een functie-app-project te maken in de huidige map:
```
func init --worker-runtime python 
```

Voer in een terminal of opdrachtprompt deze func init opdracht uit om een functie-app-project te maken in de huidige map:
```
func init --worker-runtime node --language typescript 
```

Voer in een terminal of opdrachtprompt deze func init opdracht uit om een functie-app-project te maken in de huidige map:
```
func init --worker-runtime custom 
```

Voer in een lege map deze mvn opdracht uit om het codeproject te genereren op basis van een Maven-archetype van Azure Functions:

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

Gebruik -DjavaVersion=11 als u uw functies wilt uitvoeren in Java 11. Zie Java-versies voor meer informatie.
Stel de JAVA_HOME omgevingsvariabele in op de installatielocatie van de juiste versie van de JDK om dit artikel te voltooien.

Maven vraagt u om de waarden die nodig zijn om het project tijdens de implementatie te voltooien.
Geef de volgende waarden op als daarom wordt gevraagd:

Prompt	Value	Description
groupId	`com.fabrikam`	Een waarde die uw project uniek identificeert binnen alle projecten, overeenkomstig de regels voor de naamgeving van pakketten voor Java.
artifactId	`fabrikam-functions`	Een waarde die bestaat uit de naam van het JAR-bestand, zonder een versienummer.
version	`1.0-SNAPSHOT`	Kies de standaardwaarde.
package	`com.fabrikam`	Een waarde die het Java-pakket aangeeft voor de gegenereerde functiecode. Gebruik de standaard.

Typ Y of druk op Enter om te bevestigen.

Maven maakt de projectbestanden in een nieuwe map met de naam van artifactId; in dit voorbeeld is dat fabrikam-functions.
Navigeer naar de projectmap:
```
cd fabrikam-functions
```
U kunt de door de sjabloon gegenereerde code voor uw nieuwe HTTP-triggerfunctie bekijken in Function.java in de projectdirectory \src\main\java\com\fabrikam .

Gebruik deze func new opdracht om een functie toe te voegen aan uw project:
```
func new --name HttpExample --template "HTTP trigger" --authlevel "function"
```
Er wordt een nieuw codebestand toegevoegd aan uw project. In dit geval is het --name argument de unieke naam van uw functie (HttpExample) en het --template argument geeft een HTTP-trigger op.

De hoofdmap van het project bevat verschillende bestanden voor het project, waaronder configuratiebestanden met de naamlocal.settings.json en host.json. Omdat local.settings.json geheimen kan bevatten die zijn gedownload vanuit Azure, wordt het bestand standaard uitgesloten van broncodebeheer in het bestand .gitignore.

Uw functie maken en compileren

Het bestand function.json in de map HttpExample declareert een HTTP-triggerfunctie. U voltooit de functie door een handler toe te voegen en deze te compileren in een uitvoerbaar bestand.

Go
Roest

Druk op Ctrl+N (Cmd+N in macOS) om een nieuw bestand te maken. Sla het bestand op als handler.go in de hoofdmap van de functie-app (in dezelfde map als host.json).

Voeg de volgende code toe aan handler.go en sla het bestand op. Dit is uw aangepaste handler in 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))
}

Druk op Ctrl+Shift+` of selecteer Nieuwe terminal in het menu Terminal om een nieuwe geïntegreerde terminal te openen in Visual Studio Code.
Compileer uw aangepaste handler met de volgende opdracht. Een uitvoerbaar bestand met de naam handler (handler.exe in Windows) wordt uitgevoerd in de hoofdmap van de functie-app.
```
go build handler.go
```

Druk op Ctrl+Shift+` of selecteer Nieuwe terminal in het menu Terminal om een nieuwe geïntegreerde terminal te openen in Visual Studio Code.
Initialiseer een Rust-project met de naam in de hoofdmap van de functie-app (dezelfde map als handler).
```
cargo init --name handler
```
Voeg in Cargo.toml de volgende afhankelijkheden toe die nodig zijn om deze quickstart te voltooien. In het voorbeeld wordt het webserverframework warp gebruikt.
```
[dependencies]
warp = "0.3"
tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
```

Voeg de volgende code toe aan src/main.rs en sla het bestand op. Dit is uw aangepaste handler in 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
}

Compileer een binair bestand voor uw aangepaste handler. Een uitvoerbaar bestand met de naam handler (handler.exe in Windows) wordt uitgevoerd in de hoofdmap van de functie-app.
```
cargo build --release
cp target/release/handler .
```

Uw functie-app configureren

De functiehost moet worden geconfigureerd om het binaire bestand van uw aangepaste handler uit te voeren wanneer deze wordt gestart.

Open host.json.
Stel in de sectie customHandler.description de waarde van defaultExecutablePath in op handler (in Windows moet u deze waarde instellen op handler.exe).
Voeg in de sectie customHandler een eigenschap toe met de naam enableForwardingHttpRequest en stel de waarde ervan in op true. Deze maakt het programmeren voor functies die uitsluitend bestaan uit een HTTP-trigger eenvoudiger, omdat u een typische HTTP-aanvraag kunt gebruiken in plaats van de aangepaste handler request payload.

Controleer of de sectie customHandler eruitziet als in dit voorbeeld. Sla het bestand op.

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

De functie-app is geconfigureerd om het uitvoerbare bestand van de aangepaste handler te starten.

De functie lokaal uitvoeren

Controleer de nieuwe functie door het project lokaal uit te voeren en het functie-eindpunt aan te roepen.

Gebruik deze opdracht om de lokale Azure Functions Runtime-host te starten in de hoofdmap van de projectmap:

func start

npm install
npm start

mvn clean package  
mvn azure-functions:run

Aan het einde van de uitvoer worden de volgende regels weergegeven:

 ...

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

Kopieer de URL van uw HttpExample functie uit deze uitvoer naar een browser en blader naar de functie-URL. Je zou een succesreactie moeten ontvangen met een bericht: 'hallo wereld'.

Note

Omdat autorisatie van toegangssleutels niet wordt afgedwongen wanneer deze lokaal wordt uitgevoerd, bevat de geretourneerde functie-URL niet de waarde van de toegangssleutel en hoeft u de functie niet aan te roepen.
Wanneer u klaar bent, gebruikt u Ctrl+C en kiest u y om de functiehost te stoppen.

Ondersteunende Azure-resources maken voor uw functie

Voordat u uw functiecode in Azure kunt implementeren, moet u deze resources maken:

Een resourcegroep, een logische container voor gerelateerde resources.
Een standaardopslagaccount dat wordt gebruikt door de Functions-host voor het onderhouden van status en andere informatie over uw functies.
Een door de gebruiker toegewezen beheerde identiteit, die de Functions-host gebruikt om verbinding te maken met het standaardopslagaccount.
Een functie-app, die de omgeving biedt voor het uitvoeren van uw functiecode. Een functie-app wordt gekoppeld aan uw lokale functieproject en maakt het mogelijk om functies te groeperen als een logische eenheid, zodat u resources eenvoudiger kunt beheren, implementeren en delen.

Gebruik de Azure CLI-opdrachten in deze stappen om de vereiste resources te maken.

Als u dit nog niet hebt gedaan, meldt u zich aan bij Azure:
```
az login
```
Met de az login opdracht meldt u zich aan bij uw Azure-account. Sla deze stap over wanneer u deze stap uitvoert in Azure Cloud Shell.
Als u dit nog niet hebt gedaan, gebruikt u deze az extension add opdracht om de Application Insights-extensie te installeren:
```
az extension add --name application-insights
```
Gebruik deze opdracht az group create om een resourcegroep te maken met de naam AzureFunctionsQuickstart-rg in uw gekozen regio:
```
az group create --name "AzureFunctionsQuickstart-rg" --location "<REGION>"
```
Vervang in dit voorbeeld door <REGION> een regio bij u in de buurt die ondersteuning biedt voor het Flex Consumption-abonnement. Gebruik de opdracht az functionapp list-flexconsumption-locations om de lijst met momenteel ondersteunde regio's weer te geven.
Gebruik deze opdracht az storage account create om een algemeen opslagaccount in uw resourcegroep en regio te maken:
```
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
```
Vervang in dit voorbeeld door <STORAGE_NAME> een naam die geschikt is voor u en uniek in Azure Storage. Namen mogen drie tot 24 tekens bevatten en u mag alleen kleine letters gebruiken. Met Standard_LRS geeft u een account voor algemeen gebruik op dat wordt ondersteund door Functions. Dit nieuwe account kan alleen worden geopend met behulp van door Microsoft Entra geverifieerde identiteiten waaraan machtigingen zijn verleend voor specifieke resources.
Gebruik dit script om een door de gebruiker toegewezen beheerde identiteit te maken, de geretourneerde JSON-eigenschappen van het object te parseren met behulp jqvan en machtigingen te verlenen Storage Blob Data Owner in het standaardopslagaccount:
```
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
```
Als u het jq hulpprogramma niet in uw lokale Bash-shell hebt, is deze beschikbaar in Azure Cloud Shell. Vervang in dit voorbeeld <STORAGE_NAME> respectievelijk de <REGION> naam en regio van uw standaardopslagaccount.

Met de opdracht az identity create maakt u een identiteit met de naam func-host-storage-user. Het geretourneerde principalId bestand wordt gebruikt om machtigingen toe te wijzen aan deze nieuwe identiteit in het standaardopslagaccount met behulp van de az role assignment create opdracht. De az storage account show opdracht wordt gebruikt om de id van het opslagaccount op te halen.

Gebruik deze opdracht az functionapp create om de functie-app te maken in 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"

Vervang in dit voorbeeld deze tijdelijke aanduidingen door de juiste waarden:

<APP_NAME>: een wereldwijd unieke naam die geschikt is voor u. De <APP_NAME> is ook het standaard DNS-domein voor de functie-app.
<STORAGE_NAME>: de naam van het account dat u in de vorige stap hebt gebruikt.
<REGION>: uw huidige regio.
<LANGUAGE_VERSION>: gebruik dezelfde ondersteunde taalstackversie die u lokaal hebt geverifieerd, indien van toepassing.

Met deze opdracht maakt u een functie-app die wordt uitgevoerd in uw opgegeven taalruntime op Linux in het Flex Consumption-abonnement. Dit is gratis voor de hoeveelheid gebruik die u hier maakt. Met de opdracht maakt u ook een gekoppeld Azure Application Insights-exemplaar in dezelfde resourcegroep, waarmee u de uitvoeringen van uw functie-app kunt bewaken en logboeken kunt bekijken. Zie Monitor Azure Functions voor meer informatie. Er worden geen kosten gerekend voor de instantie tot u deze activeert.

Gebruik dit script om uw door de gebruiker toegewezen beheerde identiteit toe te voegen aan de rol Monitoring Metrics Publisher in uw Application Insights-exemplaar:
```
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
```
Vervang in dit voorbeeld <APP_NAME> door de naam van de functie-app. Met de opdracht az role assignment create voegt u uw gebruiker toe aan de rol. De resource-id van uw Application Insights-exemplaar en de principal-id van uw gebruiker worden verkregen met behulp van respectievelijk de az monitor app-insights-component show en az identity show opdrachten.

Toepassingsinstellingen bijwerken

Als u wilt dat de Functions-host verbinding maakt met het standaardopslagaccount met behulp van gedeelde geheimen, vervangt u de instelling van de AzureWebJobsStorage verbindingsreeks door verschillende instellingen die voorafgegaan worden door AzureWebJobsStorage__. Deze instellingen definiëren een complexe instelling die uw app gebruikt om verbinding te maken met opslag en Application Insights met een door de gebruiker toegewezen beheerde identiteit.

Gebruik dit script om de client-id op te halen van de door de gebruiker toegewezen beheerde identiteit en gebruikt dit om beheerde identiteitverbindingen met zowel opslag als Application Insights te definiëren:

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"

Vervang in dit script <APP_NAME> respectievelijk <STORAGE_NAME> de namen van uw functie-app en opslagaccount.

Voer de opdracht az functionapp config appsettings delete uit om de bestaande AzureWebJobsStorage instelling voor de verbindingsreeks te verwijderen, die een gedeelde geheime sleutel bevat:
```
az functionapp config appsettings delete --name <APP_NAME> --resource-group "AzureFunctionsQuickstart-rg" --setting-names AzureWebJobsStorage
```
Vervang in dit voorbeeld <APP_NAME> door de namen van uw functie-app.

Op dit moment kan de Functions-host veilig verbinding maken met het opslagaccount met behulp van beheerde identiteiten in plaats van gedeelde geheimen. U kunt nu uw projectcode implementeren in de Azure-resources.

Het functieproject implementeren in Azure

Nadat u uw functie-app in Azure hebt gemaakt, bent u nu klaar om uw lokale functions-project te implementeren met behulp van de func azure functionapp publish opdracht.

Voer deze func azure functionapp publish opdracht uit in de hoofdprojectmap:

func azure functionapp publish <APP_NAME>

Vervang in dit voorbeeld door <APP_NAME> de naam van uw app. Een geslaagde implementatie toont resultaten die vergelijkbaar zijn met de volgende uitvoer (afgekapt voor eenvoud):

 ...

 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

Voer in uw lokale terminal of opdrachtprompt deze opdracht uit om de URL-eindpuntwaarde op te halen, inclusief de toegangssleutel:
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
Vervang in dit voorbeeld opnieuw door <APP_NAME> de naam van uw app.
Kopieer de geretourneerde eindpunt-URL en -sleutel die u gebruikt om het functie-eindpunt aan te roepen.

Het pom.xml-bestand bijwerken

Nadat u uw functie-app in Azure hebt gemaakt, werkt u het pom.xml-bestand bij zodat Maven kan implementeren in uw nieuwe app. Anders maakt Maven een nieuwe set Azure-resources tijdens de implementatie.

Gebruik deze az functionapp show opdracht in Azure Cloud Shell om de URL en id van de implementatiecontainer op te halen van de nieuwe door de gebruiker toegewezen beheerde identiteit:

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

Vervang in dit voorbeeld <APP_NAME> door de namen van uw functie-app.

Open in de hoofdmap van het project het bestand pom.xml in een teksteditor, zoek het properties element en werk deze specifieke eigenschapswaarden bij:

Naam van de eigenschap	Value
`java.version`	Gebruik dezelfde ondersteunde taalstackversie die u lokaal hebt geverifieerd, zoals `17`.
`azure.functions.maven.plugin.version`	`1.37.1`
`azure.functions.java.library.version`	`3.1.0`
`functionAppName`	De naam van uw functie-app in Azure.

Zoek de configuration sectie van de azure-functions-maven-plugin en vervang deze door dit XML-fragment:

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

Breng in het nieuwe configuration-element deze specifieke vervangingen van de beletseltekens (...) waarden aan:

Configuration	Value
`region`	De regiocode van uw bestaande functie-app, zoals `eastus`.
`deploymentStorageAccount`	De naam van uw opslagaccount.
`deploymentStorageContainer`	De naam van de implementatieshare, die volgt op de `\containerUrl` waarde die u hebt verkregen.
`userAssignedIdentityResourceId`	De volledig gekwalificeerde resource-ID van uw beheerde identiteit die u hebt verkregen.

Sla de wijzigingen op in het pom.xml-bestand .

U kunt nu Maven gebruiken om uw codeproject te implementeren in uw bestaande app.

Het functieproject implementeren in Azure

Voer deze opdracht uit vanaf de opdrachtprompt:
```
mvn clean package azure-functions:deploy
```
Nadat de implementatie is voltooid, voert u deze Core Tools-opdracht uit om de URL-eindpuntwaarde op te halen, inclusief de toegangssleutel:
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
Vervang in dit voorbeeld opnieuw door <APP_NAME> de naam van uw app.
Kopieer de geretourneerde eindpunt-URL en -sleutel die u gebruikt om het functie-eindpunt aan te roepen.

De functie aanroepen in Azure

Omdat uw functie gebruikmaakt van een HTTP-trigger en GET-aanvragen ondersteunt, roept u deze aan door een HTTP-aanvraag naar de URL te verzenden met behulp van de toegangssleutel op functieniveau. Het is het eenvoudigst om een GET-aanvraag uit te voeren in een browser.

Plak de URL en de toegangssleutel die u hebt gekopieerd in een adresbalk van de browser.

De eindpunt-URL moet er ongeveer als volgt uitzien:

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

In dit geval moet u ook een toegangssleutel opgeven in de querytekenreeks bij het indienen van een GET-aanvraag naar de eindpunt-URL. Het gebruik van een toegangssleutel wordt aanbevolen om de toegang van willekeurige clients te beperken. Wanneer u een POST-aanvraag maakt met behulp van een HTTP-client, moet u in plaats daarvan de toegangssleutel in de x-functions-key header opgeven.

Wanneer u naar deze URL navigeert, moet de browser vergelijkbare uitvoer weergeven als toen u de functie lokaal uitvoerde.

De hulpbronnen opschonen

Als u naar de volgende stap gaat en een uitvoerbinding voor een Azure Storage-wachtrij toevoegt, laat dan al uw resources op hun plaats staan, aangezien u verder zult bouwen op wat u al gedaan heeft.

Gebruik anders de volgende opdracht om de resourcegroep en alle bijbehorende resources te verwijderen om te voorkomen dat er verdere kosten in rekening worden gebracht.

Azure-CLI
Azure PowerShell

az group delete --name AzureFunctionsQuickstart-rg

Remove-AzResourceGroup -Name AzureFunctionsQuickstart-rg

Volgende stappen

Verbinding maken met Azure Queue Storage

Feedback

Is deze pagina nuttig?

Last updated on 2025-12-04

Delen via

Quickstart: Een functie maken in Azure vanaf de opdrachtregel

Prerequisites

Azure Functions Core Tools installeren

Een virtuele omgeving maken en activeren

Een lokaal codeproject en een functie maken

Uw functie maken en compileren

Uw functie-app configureren

De functie lokaal uitvoeren

Ondersteunende Azure-resources maken voor uw functie

Toepassingsinstellingen bijwerken

Het functieproject implementeren in Azure

Het pom.xml-bestand bijwerken

Het functieproject implementeren in Azure

De functie aanroepen in Azure

De hulpbronnen opschonen

Volgende stappen

Feedback

Aanvullende resources