Schnellstart: Erstellen einer Funktion in Azure über die Befehlszeile

In diesem Artikel verwenden Sie lokale Befehlszeilentools, um eine Funktion zu erstellen, die auf HTTP-Anforderungen antwortet. Nachdem Sie Ihren Code lokal überprüft haben, stellen Sie ihn in Azure Functions in einem serverlosen Flex-Verbrauch-Hostingplan bereit.

Im Rahmen dieser Schnellstartanleitung fallen in Ihrem Azure-Konto ggf. geringfügige Kosten im Centbereich an.

Stellen Sie sicher, dass Sie oben im Artikel Ihre bevorzugte Programmiersprache auswählen.

Prerequisites

Ein Azure-Konto mit einem aktiven Abonnement. Kostenlos ein Konto erstellen.

Java 17 Developer Kit
- Wenn Sie eine andere unterstützte Version von Java verwenden, müssen Sie die pom.xml-Datei des Projekts aktualisieren.
- Die JAVA_HOME Umgebungsvariable muss auf den Installationsspeicherort der richtigen Version des Java Development Kit (JDK) festgelegt werden.
Apache Maven 3.8.x

Node.js 20+

Los geht's
Rust

Go (aktuelle Version empfohlen). Verwenden Sie den Befehl go version, um Ihre Version zu überprüfen.

Azure CLI
Der JSON-Prozessor der Befehlszeile, der zum Analysieren der jqJSON-Ausgabe verwendet wird und auch in Azure Cloud Shell verfügbar ist.

Installieren von Azure Functions Core Tools

Die empfohlene Methode zum Installieren von Core Tools hängt vom Betriebssystem Ihres lokalen Entwicklungscomputers ab.

In den folgenden Schritten wird ein Windows Installer (MSI) zum Installieren der Core Tools v4.x verwendet. Weitere Informationen zu anderen paketbasierten Installationsprogrammen finden Sie in der Infodatei zu Core Tools.

Laden Sie den Core Tools-Installer basierend auf Ihrer Version von Windows herunter, und führen Sie ihn aus:

v4.x: Windows 64-Bit (Empfohlen. Visual Studio Code-Debuggen erfordert 64-Bit.)
v4.x: Windows 32-Bit

Wenn Sie zuvor das Windows-Installationsprogramm (MSI) zum Installieren von Core Tools auf Windows verwendet haben, sollten Sie die alte Version unter „Programme hinzufügen oder entfernen“ deinstallieren, bevor Sie die neuste Version installieren.

Die folgenden Schritte verwenden Homebrew zum Installieren der Core Tools unter macOS.

Installieren Sie Homebrew, sofern dies noch nicht geschehen ist.

Installieren Sie das Core Tools-Paket:

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

Die folgenden Schritte verwenden APT zum Installieren der Core Tools unter Ihrer Ubuntu/Debian Linux-Distribution. Informationen zu anderen Linux-Distributionen finden Sie in der Infodatei zu den Core Tools.

Installieren Sie den GPG-Schlüssel des Microsoft-Paketrepositorys, um die Paketintegrität zu überprüfen:

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

Richten Sie die Liste der APT-Quellen ein, bevor Sie ein APT-Update ausführen.

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'

Überprüfen Sie die Datei /etc/apt/sources.list.d/dotnetdev.list auf eine der entsprechenden Linux-Versionszeichenfolgen, die in der folgenden Tabelle aufgeführt sind:

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

Starten Sie das Update der APT-Quelle:
```
sudo apt-get update
```

Installieren Sie das Core Tools-Paket:

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

Erstellen und Aktivieren einer virtuellen Umgebung

Führen Sie die folgenden Befehle in einem geeigneten Ordner aus, um eine virtuelle Umgebung mit dem Namen .venv zu erstellen und zu aktivieren. Stellen Sie sicher, eine der von Azure Functions unterstützten Python-Versionen zu verwenden.

python -m venv .venv

source .venv/bin/activate

Führen Sie den folgenden Befehl aus, wenn über Python das venv-Paket auf Ihrer Linux-Distribution nicht installiert wurde:

sudo apt-get install python3-venv

py -m venv .venv

.venv\scripts\activate

py -m venv .venv

.venv\scripts\activate

Sie führen alle nachfolgenden Befehle in dieser aktivierten virtuellen Umgebung aus.

Erstellen eines lokalen Codeprojekts und einer lokalen Funktion

In Azure Functions ist Ihr Codeprojekt eine App, die eine oder mehrere einzelne Funktionen enthält, die jeweils auf einen bestimmten Trigger reagieren. Alle Funktionen in einem Projekt verwenden dieselben Konfigurationen und werden als Einheit für Azure bereitgestellt. In diesem Abschnitt erstellen Sie ein Codeprojekt, das eine einzelne Funktion enthält.

Führen Sie in einer Terminal- oder Eingabeaufforderung diesen func init Befehl aus, um ein Funktions-App-Projekt im aktuellen Ordner zu erstellen:
```
func init --worker-runtime dotnet-isolated 
```

Führen Sie in einer Terminal- oder Eingabeaufforderung diesen func init Befehl aus, um ein Funktions-App-Projekt im aktuellen Ordner zu erstellen:
```
func init --worker-runtime node --language javascript 
```

Führen Sie in einer Terminal- oder Eingabeaufforderung diesen func init Befehl aus, um ein Funktions-App-Projekt im aktuellen Ordner zu erstellen:
```
func init --worker-runtime powershell 
```

Führen Sie in einer Terminal- oder Eingabeaufforderung diesen func init Befehl aus, um ein Funktions-App-Projekt im aktuellen Ordner zu erstellen:
```
func init --worker-runtime python 
```

Führen Sie in einer Terminal- oder Eingabeaufforderung diesen func init Befehl aus, um ein Funktions-App-Projekt im aktuellen Ordner zu erstellen:
```
func init --worker-runtime node --language typescript 
```

Führen Sie in einer Terminal- oder Eingabeaufforderung diesen func init Befehl aus, um ein Funktions-App-Projekt im aktuellen Ordner zu erstellen:
```
func init --worker-runtime custom 
```

Führen Sie in einem leeren Ordner diesen mvn Befehl aus, um das Codeprojekt aus einem Azure Functions Maven-Archetyp zu generieren:
- Bash
- PowerShell
- Cmd
```
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
- Verwenden Sie -DjavaVersion=11, wenn Sie Ihre Funktionen in Java 11 ausführen möchten. Weitere Informationen finden Sie unter Java-Versionen.
- Legen Sie die JAVA_HOME Umgebungsvariable auf den Installationsspeicherort der richtigen Version des JDK fest, um diesen Artikel abzuschließen.

Maven fordert Sie zur Eingabe von Werten auf, die erforderlich sind, um die Generierung des Projekts bei der Bereitstellung abzuschließen.
Geben Sie die folgenden Werte ein, wenn Sie dazu aufgefordert werden:

Prompt	Value	Description
groupId	`com.fabrikam`	Ein Wert, der Ihr Projekt projektübergreifend eindeutig identifiziert. Für den Wert müssen die Paketbenennungsregeln für Java eingehalten werden.
artifactId	`fabrikam-functions`	Der Name des Behälters (ohne Versionsnummer).
version	`1.0-SNAPSHOT`	Wählen Sie den Standardwert aus.
package	`com.fabrikam`	Das Java-Paket für den generierten Funktionscode. Verwenden Sie den Standardwert.

Geben Sie zur Bestätigung Y ein, oder drücken Sie die EINGABETASTE.

Maven erstellt die Projektdateien in einem neuen Ordner und benennt ihn mit dem Wert von artifactId (in diesem Beispiel: fabrikam-functions).
Navigieren Sie zum Projektordner:
```
cd fabrikam-functions
```
Sie können den vom Vorlagen generierten Code für Ihre neue HTTP-Triggerfunktion in Function.java im Projektverzeichnis \src\main\java\com\fabrikam überprüfen.

Verwenden Sie diesen func new Befehl, um Ihrem Projekt eine Funktion hinzuzufügen:
```
func new --name HttpExample --template "HTTP trigger" --authlevel "function"
```
Ihrem Projekt wird eine neue Codedatei hinzugefügt. In diesem Fall ist das --name Argument der eindeutige Name Ihrer Funktion (HttpExample) und das --template Argument gibt einen HTTP-Trigger an.

Der Projektstammordner enthält verschiedene Dateien für das Projekt, einschließlich Konfigurationsdateien mit dem Namen local.settings.json und host.json. Da local.settings.json aus Azure heruntergeladene Geheimnisse enthalten kann, wird die Datei in der GITIGNORE-Datei standardmäßig aus der Quellcodeverwaltung ausgeschlossen.

Erstellen und Kompilieren Ihrer Funktion

Mit der Datei function.json im Ordner HttpExample wird eine HTTP-Triggerfunktion deklariert. Sie erstellen die Funktion, indem Sie einen Handler hinzufügen und die Kompilierung in eine ausführbare Datei durchführen.

Los geht's
Rust

Drücken Sie STRG+N (macOS: BEFEHLSTASTE+N), um eine neue Datei zu erstellen. Speichern Sie sie als handler.go im Stammverzeichnis der Funktions-App (in demselben Ordner wie host.json).

Fügen Sie in handler.go den folgenden Code hinzu, und speichern Sie die Datei. Dies ist Ihr benutzerdefinierter Go-Handler.

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

Drücken Sie STRG+UMSCHALT+`, oder wählen Sie im Menü Terminal die Option Neues Terminal aus, um in VS Code ein neues integriertes Terminal zu öffnen.
Kompilieren Sie Ihren benutzerdefinierten Handler mit dem folgenden Befehl. Im Stammverzeichnis der Funktions-App wird eine ausführbare Datei mit dem Namen handler (Windows: handler.exe) ausgegeben.
```
go build handler.go
```

Drücken Sie STRG+UMSCHALT+`, oder wählen Sie im Menü Terminal die Option Neues Terminal aus, um in VS Code ein neues integriertes Terminal zu öffnen.
Initialisieren Sie im Stammverzeichnis der Funktions-App (derselbe Ordner wie host.json) ein Rust-Projekt mit dem Namen handler.
```
cargo init --name handler
```
Fügen Sie in Cargo.toml die folgenden Abhängigkeiten hinzu, die für die Durcharbeitung dieser Schnellstartanleitung benötigt werden. Im Beispiel wird das warp-Webserver-Framework verwendet.
```
[dependencies]
warp = "0.3"
tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
```

Fügen Sie in src/main.rs den folgenden Code hinzu, und speichern Sie die Datei. Dies ist Ihr benutzerdefinierter Rust-Handler.

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
}

Kompilieren Sie eine Binärdatei für Ihren benutzerdefinierten Handler. Im Stammverzeichnis der Funktions-App wird eine ausführbare Datei mit dem Namen handler (Windows: handler.exe) ausgegeben.
```
cargo build --release
cp target/release/handler .
```

Konfigurieren Ihrer Funktions-App

Der Funktionshost muss so konfiguriert werden, dass beim Starten die Binärdatei mit Ihrem benutzerdefinierten Handler ausgeführt wird.

Öffnen Sie host.json.
Legen Sie im Abschnitt customHandler.description den Wert von defaultExecutablePath auf handler fest (Windows: handler.exe).
Fügen Sie im Abschnitt customHandler eine Eigenschaft mit dem Namen enableForwardingHttpRequest hinzu, und legen Sie den Wert dafür auf true fest. Für Funktionen, die nur einen HTTP-Trigger umfassen, wird mit dieser Einstellung die Programmierung vereinfacht. Hierfür wird es Ihnen ermöglicht, anstelle der Anforderungsnutzdaten des benutzerdefinierten Handlers eine normale HTTP-Anforderung zu verwenden.

Vergewissern Sie sich, dass der Abschnitt customHandler wie in diesem Beispiel aussieht. Speichern Sie die Datei.

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

Die Funktions-App ist so konfiguriert, dass die ausführbare Datei für Ihren benutzerdefinierten Handler gestartet wird.

Lokales Ausführen der Funktion

Überprüfen Sie Ihre neue Funktion, indem Sie das Projekt lokal ausführen und den Funktionsendpunkt aufrufen.

Verwenden Sie diesen Befehl, um den lokalen Azure Functions-Laufzeithost im Stammverzeichnis des Projektordners zu starten:

func start

npm install
npm start

mvn clean package  
mvn azure-functions:run

Am Ende der Ausgabe werden die folgenden Zeilen angezeigt:

 ...

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

Kopieren Sie die URL Ihrer HttpExample Funktion aus dieser Ausgabe in einen Browser, und navigieren Sie zur Funktions-URL. Sie sollten eine Erfolgsantwort mit einer "Hallo Welt"-Nachricht erhalten.

Note

Da die Zugriffstastenautorisierung bei der lokalen Ausführung nicht erzwungen wird, enthält die zurückgegebene Funktions-URL nicht den Zugriffstastenwert, und Sie benötigen sie nicht, um Ihre Funktion aufzurufen.
Wenn Sie fertig sind, drücken Sie STRG+C, und wählen Sie y aus, um den Funktionshost zu beenden.

Erstellen von unterstützenden Azure-Ressourcen für Ihre Funktion

Bevor Sie Ihren Funktionscode in Azure bereitstellen können, müssen Sie diese Ressourcen erstellen:

Eine Ressourcengruppe, bei der es sich um einen logischen Container für verwandte Ressourcen handelt.
Ein Standardspeicherkonto, das vom Funktionenhost verwendet wird, um den Zustand und andere Informationen zu Ihren Funktionen zu verwalten.
Eine vom Benutzer zugewiesene verwaltete Identität, die der Funktionenhost zum Herstellen einer Verbindung mit dem Standardspeicherkonto verwendet.
Eine Funktions-App, die als Umgebung zum Ausführen Ihres Funktionscodes dient. Eine Funktions-App ist Ihrem lokalen Funktionsprojekt zugeordnet und ermöglicht Ihnen das Gruppieren von Funktionen als logische Einheit, um die Verwaltung, Bereitstellung und Freigabe von Ressourcen zu vereinfachen.

Verwenden Sie die Azure CLI-Befehle in diesen Schritten, um die erforderlichen Ressourcen zu erstellen.

Melden Sie sich bei Azure an, falls dies noch nicht geschehen ist:
```
az login
```
Der az login Befehl meldet Sie bei Ihrem Azure-Konto an. Überspringen Sie diesen Schritt, wenn Sie in der Azure Cloud Shell arbeiten.
Wenn Sie dies noch nicht getan haben, verwenden Sie diesen az extension add Befehl, um die Application Insights-Erweiterung zu installieren:
```
az extension add --name application-insights
```
Verwenden Sie diesen Befehl " az group create " zum Erstellen einer Ressourcengruppe, die in Ihrer ausgewählten Region benannt ist AzureFunctionsQuickstart-rg :
```
az group create --name "AzureFunctionsQuickstart-rg" --location "<REGION>"
```
Ersetzen Sie <REGION> in diesem Beispiel durch eine Region in ihrer Nähe, die den Flex-Verbrauchsplan unterstützt. Verwenden Sie den Befehl "az functionapp list-flexconsumption-locations" , um die Liste der aktuell unterstützten Regionen anzuzeigen.
Verwenden Sie diesen Befehl zum Erstellen eines az-Speicherkontos , um ein allgemeines Speicherkonto in Ihrer Ressourcengruppe und Region zu erstellen:
```
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
```
Ersetzen Sie <STORAGE_NAME> in diesem Beispiel durch einen Namen, der für Sie geeignet ist und in Azure Storage eindeutig ist. Namen dürfen nur 3 bis 24 Zeichen und ausschließlich Kleinbuchstaben enthalten. Mit Standard_LRS wird ein universelles Konto angegeben, das von Functions unterstützt wird. Auf dieses neue Konto kann nur mithilfe von microsoft entra-authentifizierten Identitäten zugegriffen werden, denen Berechtigungen für bestimmte Ressourcen erteilt wurden.
Verwenden Sie dieses Skript, um eine vom Benutzer zugewiesene verwaltete Identität zu erstellen, analysieren Sie die zurückgegebenen JSON-Eigenschaften des Objekts mit jq und erteilen Sie Berechtigungen im Standardspeicherkonto Storage Blob Data Owner.
```
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
```
Wenn Sie nicht über das jq Dienstprogramm in Ihrer lokalen Bash-Shell verfügen, ist es in Azure Cloud Shell verfügbar. Ersetzen Sie in diesem Beispiel <STORAGE_NAME> durch den Namen Ihres Standardspeicherkontos und <REGION> durch die Region.

Der Befehl "az identity create " erstellt eine Identität mit dem Namen func-host-storage-user. Die zurückgegebene principalId wird verwendet, um Berechtigungen für diese neue Identität im Standardspeicherkonto mithilfe des az role assignment create-Befehls zuzuweisen. Der az storage account show Befehl wird verwendet, um die Speicherkonto-ID abzurufen.

Verwenden Sie diesen Befehl "az functionapp create ", um die Funktions-App in Azure zu erstellen:

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"

Ersetzen Sie in diesem Beispiel diese Platzhalter durch die entsprechenden Werte:

<APP_NAME>: ein global eindeutiger Name, der für Sie geeignet ist. <APP_NAME> ist gleichzeitig die DNS-Standarddomäne für die Funktions-App.
<STORAGE_NAME>: der Name des Kontos, das Sie im vorherigen Schritt verwendet haben.
<REGION>: Ihre aktuelle Region.
<LANGUAGE_VERSION>: Verwenden Sie bei Bedarf die gleiche unterstützte Sprachstapelversion , die Sie lokal überprüft haben.

Mit diesem Befehl wird eine Funktions-App erstellt, die in Ihrer angegebenen Sprachlaufzeitumgebung unter Linux im Flex-Verbrauchsplan ausgeführt wird, welcher für das Nutzungsausmaß, das Sie hier haben, kostenlos ist. Mit dem Befehl wird auch eine zugeordnete Azure Application Insights-Instanz in derselben Ressourcengruppe erstellt, mit der Sie Ihre Funktions-App-Ausführungen überwachen und Protokolle anzeigen können. Weitere Informationen finden Sie unter Überwachen von Azure-Funktionen. Für die Instanz fallen erst Kosten an, wenn Sie sie aktivieren.

Verwenden Sie dieses Skript, um Ihre vom Benutzer zugewiesene verwaltete Identität zur Rolle "Monitoring Metrics Publisher " in Ihrer Application Insights-Instanz hinzuzufügen:
```
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
```
In diesem Beispiel ersetzen Sie <APP_NAME> durch den Namen Ihrer Funktions-App. Der Befehl "az role assignment create" fügt Den Benutzer zur Rolle hinzu. Die Ressourcen-ID Ihrer Application Insights-Instanz und die Prinzipal-ID Ihrer benutzenden Person werden mithilfe der Befehle az monitor app-insights component show bzw. az identity show abgerufen.

Aktualisieren der Anwendungseinstellungen

Um dem Funktionshost die Verbindung mit dem Standardspeicherkonto mithilfe freigegebener geheimer Schlüssel zu ermöglichen, ersetzen Sie die AzureWebJobsStorage-Verbindungszeichenfolgeneinstellung durch mehrere Einstellungen, die mit AzureWebJobsStorage__ versehen sind. Diese Einstellungen definieren eine komplexe Einstellung, die Ihre App zum Herstellen einer Verbindung mit Speicher und Application Insights mit einer vom Benutzer zugewiesenen verwalteten Identität verwendet.

Verwenden Sie dieses Skript, um die Client-ID der vom Benutzer zugewiesenen verwalteten Identität abzurufen, und verwendet es, um verwaltete Identitätsverbindungen für Speicher und Application Insights zu definieren:

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"

Ersetzen Sie in diesem Skript <APP_NAME> und <STORAGE_NAME> durch die Namen Ihrer Funktions-App bzw. Ihres Speicherkontos.

Führen Sie den Befehl "az functionapp config appsettings delete" aus, um die vorhandene AzureWebJobsStorage Verbindungszeichenfolgeneinstellung zu entfernen, die einen freigegebenen geheimen Schlüssel enthält:
```
az functionapp config appsettings delete --name <APP_NAME> --resource-group "AzureFunctionsQuickstart-rg" --setting-names AzureWebJobsStorage
```
Ersetzen Sie <APP_NAME> in diesem Beispiel durch die Namen Ihrer Funktions-App.

An diesem Punkt kann der Funktionenhost eine sichere Verbindung mit dem Speicherkonto herstellen, indem verwaltete Identitäten anstelle von freigegebenen Geheimschlüsseln verwendet werden. Sie können ihren Projektcode jetzt in den Azure-Ressourcen bereitstellen.

Bereitstellen des Funktionsprojekts in Azure

Nach erfolgreicher Erstellung Ihrer Funktions-App in Azure können Sie Ihr lokales Funktionsprojekt bereitstellen. Verwenden Sie dazu den func azure functionapp publish-Befehl.

Führen Sie im Stammordner des Projekts diesen func azure functionapp publish-Befehl aus:

func azure functionapp publish <APP_NAME>

Ersetzen Sie in diesem Beispiel <APP_NAME> durch den Namen Ihrer App. Bei einer erfolgreichen Bereitstellung werden Ergebnisse wie in der folgenden (gekürzten) Ausgabe angezeigt:

 ...

 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

Führen Sie in Ihrer lokalen Terminal- oder Eingabeaufforderung diesen Befehl aus, um den URL-Endpunktwert abzurufen, einschließlich der Zugriffstaste:
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
Ersetzen Sie in diesem Beispiel erneut <APP_NAME> durch den Namen Ihrer App.
Kopieren Sie die zurückgegebene Endpunkt-URL und den Schlüssel, die Sie zum Aufrufen des Funktionsendpunkts verwenden.

Aktualisieren der pom.xml-Datei

Nachdem Sie Ihre Funktions-App in Azure erfolgreich erstellt haben, aktualisieren Sie die pom.xml Datei, damit Maven in Ihrer neuen App bereitstellen kann. Andernfalls erstellt Maven während der Bereitstellung eine neue Gruppe von Azure-Ressourcen.

Verwenden Sie in Azure Cloud Shell diesen az functionapp show Befehl, um die Url und ID des Bereitstellungscontainers der neuen vom Benutzer zugewiesenen verwalteten Identität abzurufen:

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

Ersetzen Sie <APP_NAME> in diesem Beispiel durch die Namen Ihrer Funktions-App.

Öffnen Sie im Stammverzeichnis des Projekts die pom.xml Datei in einem Text-Editor, suchen Sie das properties Element, und aktualisieren Sie diese spezifischen Eigenschaftswerte:

Eigenschaftsname	Value
`java.version`	Verwenden Sie dieselbe unterstützte Sprachstapelversion, die Sie lokal überprüft haben, z. B. `17`.
`azure.functions.maven.plugin.version`	`1.37.1`
`azure.functions.java.library.version`	`3.1.0`
`functionAppName`	Der Name Ihrer Funktions-App in Azure.

Suchen Sie den configuration Abschnitt des azure-functions-maven-plugin Abschnitts, und ersetzen Sie ihn durch dieses 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>

Nehmen Sie im neuen configuration Element diese spezifischen Ersetzungen der Ellipsenwerte (...) vor:

Configuration	Value
`region`	Der Regionscode Ihrer vorhandenen Funktions-App, z. B. `eastus`.
`deploymentStorageAccount`	Der Name Ihres Speicherkontos.
`deploymentStorageContainer`	Der Name der Bereitstellungsfreigabe, der nach dem `\` im `containerUrl`-Wert erscheint, den Sie abgerufen haben.
`userAssignedIdentityResourceId`	Die vollqualifizierte Ressourcen-ID Ihrer verwalteten Identität, die Sie erhalten haben.

Speichern Sie Ihre Änderungen in der pom.xml Datei.

Sie können jetzt Maven verwenden, um Ihr Codeprojekt für Ihre vorhandene App bereitzustellen.

Bereitstellen des Funktionsprojekts in Azure

Führen Sie in der Eingabeaufforderung den folgenden Befehl aus:
```
mvn clean package azure-functions:deploy
```
Nachdem die Bereitstellung erfolgreich war, führen Sie diesen Befehl "Kerntools" aus, um den URL-Endpunktwert abzurufen, einschließlich des Zugriffsschlüssels:
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
Ersetzen Sie in diesem Beispiel erneut <APP_NAME> durch den Namen Ihrer App.
Kopieren Sie die zurückgegebene Endpunkt-URL und den Schlüssel, die Sie zum Aufrufen des Funktionsendpunkts verwenden.

Aufrufen der Funktion in Azure

Da Ihre Funktion einen HTTP-Trigger verwendet und GET-Anforderungen unterstützt, rufen Sie sie auf, indem Sie eine HTTP-Anforderung an die URL mithilfe des Zugriffsschlüssels auf Funktionsebene vornehmen. Es ist am einfachsten, eine GET-Anforderung in einem Browser auszuführen.

Fügen Sie die URL und die Zugriffstaste ein, die Sie in eine Browseradressleiste kopiert haben.

Die Endpunkt-URL sollte etwa wie in diesem Beispiel aussehen:

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

In diesem Fall müssen Sie auch einen Zugriffsschlüssel in der Abfragezeichenfolge bereitstellen, wenn Sie eine GET-Anforderung an die Endpunkt-URL senden. Die Verwendung eines Zugriffsschlüssels wird empfohlen, um den Zugriff von beliebigen Clients zu beschränken. Wenn Sie eine POST-Anforderung mit einem HTTP-Client durchführen, sollten Sie stattdessen den Zugriffsschlüssel im x-functions-key Header bereitstellen.

Wenn Sie zu dieser URL navigieren, sollte der Browser eine ähnliche Ausgabe anzeigen wie bei der lokalen Ausführung der Funktion.

Bereinigen von Ressourcen

Gehen Sie wie folgt vor, falls Sie mit dem nächsten Schritt fortfahren möchten: Fügen Sie eine Ausgabebindung für die Azure Storage-Warteschlange hinzu, und behalten Sie alle Ressourcen bei, weil der nächste Schritt auf der bisherigen Arbeit aufbaut.

Verwenden Sie andernfalls den unten angegebenen Befehl, um die Ressourcengruppe und alle darin enthaltenen Ressourcen zu löschen, damit keine weiteren Kosten anfallen.

Azure CLI
Azure PowerShell

az group delete --name AzureFunctionsQuickstart-rg

Remove-AzResourceGroup -Name AzureFunctionsQuickstart-rg

Nächste Schritte

Verbindungsherstellung mit Azure Queue Storage

Feedback

War diese Seite hilfreich?

Last updated on 2025-12-04

Freigeben über

Schnellstart: Erstellen einer Funktion in Azure über die Befehlszeile

Prerequisites

Installieren von Azure Functions Core Tools

Erstellen und Aktivieren einer virtuellen Umgebung

Erstellen eines lokalen Codeprojekts und einer lokalen Funktion

Erstellen und Kompilieren Ihrer Funktion

Konfigurieren Ihrer Funktions-App

Lokales Ausführen der Funktion

Erstellen von unterstützenden Azure-Ressourcen für Ihre Funktion

Aktualisieren der Anwendungseinstellungen

Bereitstellen des Funktionsprojekts in Azure

Aktualisieren der pom.xml-Datei

Bereitstellen des Funktionsprojekts in Azure

Aufrufen der Funktion in Azure

Bereinigen von Ressourcen

Nächste Schritte

Feedback

Zusätzliche Ressourcen