Snabbstart: Skapa en funktion i Azure från kommandoraden

I den här artikeln använder du lokala kommandoradsverktyg för att skapa en funktion som svarar på HTTP-begäranden. När du har verifierat koden lokalt distribuerar du den till en serverlös Flex Consumption-värdplan i Azure Functions.

Slutförande av den här snabbstarten medför en liten kostnad på några USD-cent eller mindre på ditt Azure-konto.

Se till att välja önskat utvecklingsspråk överst i artikeln.

Prerequisites

Ett Azure-konto med en aktiv prenumeration. Skapa ett konto kostnadsfritt.

Java 17 Developer Kit
- Om du använder en annan version av Java som stöds måste du uppdatera projektets pom.xml fil.
- Miljövariabeln JAVA_HOME måste anges till installationsplatsen för rätt version av Java Development Kit (JDK).
Apache Maven 3.8.x

Node.js 20

Gå!
Rost

Go, den senaste versionen rekommenderas. Använd kommandot go version för att kontrollera din version.

Azure CLI
JSON-processornjq för kommandoraden, som används för att parsa JSON-utdata, och är även tillgänglig i Azure Cloud Shell.

Installera Azure Functions Core Tools

Det rekommenderade sättet att installera Core Tools beror på operativsystemet på din lokala utvecklingsdator.

Följande steg använder ett Windows-installationsprogram (MSI) för att installera Core Tools v4.x. Mer information om andra paketbaserade installationsprogram finns i Core Tools readme.

Ladda ned och kör installationsprogrammet för Core Tools baserat på din version av Windows:

v4.x – Windows 64-bit (rekommenderas. Visual Studio Code-felsökning kräver 64-bit.)
v4.x – Windows 32-bit

Om du tidigare använde Windows-installationsprogrammet (MSI) för att installera Core Tools i Windows bör du avinstallera den gamla versionen från Lägg till Ta bort program innan du installerar den senaste versionen.

Följande steg använder Homebrew för att installera Core Tools på macOS.

Installera Homebrew om det inte redan är installerat.

Installera Core Tools-paketet:

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

Följande steg använder APT för att installera Core Tools på din Ubuntu/Debian Linux-distribution. För information om andra Linux-distributioner, se Core Tools readme.

Installera GPG-nyckeln för Microsoft-paketlagringsplatsen för att verifiera paketintegriteten:

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

Konfigurera APT-källlistan innan du gör en APT-uppdatering.

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'

Kontrollera filen /etc/apt/sources.list.d/dotnetdev.list för att se om någon av de lämpliga Linux-versionssträngarna i följande tabell finns där.

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

Initiera uppdateringen av APT-källan:
```
sudo apt-get update
```

Installera Core Tools-paketet:

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

Skapa och aktivera en virtuell miljö

I en lämplig mapp kör du följande kommandon för att skapa och aktivera en virtuell miljö med namnet .venv. Se till att använda någon av De Python-versioner som stöds av Azure Functions.

python -m venv .venv

source .venv/bin/activate

Om Python inte installerade venv-paketet på Linux-distributionen kör du följande kommando:

sudo apt-get install python3-venv

py -m venv .venv

.venv\scripts\activate

py -m venv .venv

.venv\scripts\activate

Du kör alla efterföljande kommandon i den här aktiverade virtuella miljön.

Skapa ett lokalt kodprojekt och en funktion

I Azure Functions är ditt kodprojekt en app som innehåller en eller flera enskilda funktioner som var och en svarar på en specifik utlösare. Alla funktioner i ett projekt delar samma konfigurationer och distribueras som en enhet till Azure. I det här avsnittet skapar du ett kodprojekt som innehåller en enda funktion.

I en terminal eller kommandotolk kör du det här func init kommandot för att skapa ett funktionsappsprojekt i den aktuella mappen:
```
func init --worker-runtime dotnet-isolated 
```

I en terminal eller kommandotolk kör du det här func init kommandot för att skapa ett funktionsappsprojekt i den aktuella mappen:
```
func init --worker-runtime node --language javascript 
```

I en terminal eller kommandotolk kör du det här func init kommandot för att skapa ett funktionsappsprojekt i den aktuella mappen:
```
func init --worker-runtime powershell 
```

I en terminal eller kommandotolk kör du det här func init kommandot för att skapa ett funktionsappsprojekt i den aktuella mappen:
```
func init --worker-runtime python 
```

I en terminal eller kommandotolk kör du det här func init kommandot för att skapa ett funktionsappsprojekt i den aktuella mappen:
```
func init --worker-runtime node --language typescript 
```

I en terminal eller kommandotolk kör du det här func init kommandot för att skapa ett funktionsappsprojekt i den aktuella mappen:
```
func init --worker-runtime custom 
```

I en tom mapp kör du det här mvn kommandot för att generera kodprojektet från en Azure Functions Maven-arketyp:

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

Använd -DjavaVersion=11 om du vill att funktionerna ska köras på Java 11. För mer information, se Java-versioner.
JAVA_HOME Ange miljövariabeln till installationsplatsen för rätt version av JDK för att slutföra den här artikeln.

Maven ber dig om de värden som behövs för att slutföra genereringen av projektet vid distributionen.
Ange följande värden när du uppmanas att göra det:

Prompt	Value	Description
groupId	`com.fabrikam`	Ett värde som unikt identifierar projektet i alla projekt, enligt namngivningsreglerna för paket för Java.
artifactId	`fabrikam-functions`	Ett värde som är namnet på jar-filen, utan ett versionsnummer.
version	`1.0-SNAPSHOT`	Välj standardvärdet.
package	`com.fabrikam`	Ett värde som är Java-paketet för den genererade funktionskoden. Använd standardvärdet.

Skriv Y eller tryck på Retur för att bekräfta.

Maven skapar projektfilerna i en ny mapp med namnet artifactId, som i det här exemplet är fabrikam-functions.
Navigera till projektmappen:
```
cd fabrikam-functions
```
Du kan granska den mallgenererade koden för den nya HTTP-utlösarfunktionen i Function.java i projektkatalogen \src\main\java\com\fabrikam .

Använd det här func new kommandot för att lägga till en funktion i projektet:
```
func new --name HttpExample --template "HTTP trigger" --authlevel "function"
```
En ny kodfil läggs till i projektet. I det här fallet --name är argumentet det unika namnet på din funktion (HttpExample) och --template argumentet anger en HTTP-utlösare.

Projektrotmappen innehåller olika filer för projektet, inklusive konfigurationsfiler med namnet local.settings.json och host.json. Eftersom local.settings.json kan innehålla hemligheter som hämtats från Azure undantas filen som standard från källkontrollen i .gitignore-filen .

Skapa och skapa din funktion

Den function.json filen i mappen HttpExample deklarerar en HTTP-utlösarfunktion. Du slutför funktionen genom att lägga till en hanterare och kompilera den till en körbar fil.

Gå!
Rost

Tryck på Ctrl + N (Cmd + N på macOS) för att skapa en ny fil. Spara den som handler.go i funktionsappens rot (i samma mapp som host.json).

I handler.go lägger du till följande kod och sparar filen. Det här är din anpassade Go-hanterare.

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

Tryck på Ctrl + Skift + ' eller välj Ny terminal på terminalmenyn för att öppna en ny integrerad terminal i VS Code.
Kompilera din anpassade hanterare med hjälp av följande kommando. En körbar fil med namnet handler (handler.exe i Windows) matas ut i funktionsappens rotmapp.
```
go build handler.go
```

Tryck på Ctrl + Skift + ' eller välj Ny terminal på terminalmenyn för att öppna en ny integrerad terminal i VS Code.
Initiera ett Rust-projekt med namnet i funktionsappens rot (samma mapp som handler).
```
cargo init --name handler
```
I Cargo.toml lägger du till följande beroenden som krävs för att slutföra den här snabbstarten. I exemplet används warp-webbserverramverket .
```
[dependencies]
warp = "0.3"
tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
```

I src/main.rs lägger du till följande kod och sparar filen. Det här är din anpassade Rust-hanterare.

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
}

Kompilera en binär fil för din anpassade hanterare. En körbar fil med namnet handler (handler.exe i Windows) matas ut i funktionsappens rotmapp.
```
cargo build --release
cp target/release/handler .
```

Konfigurera funktionsappen

Funktionsvärden måste konfigureras för att köra den anpassade hanterarbinärfilen när den startas.

Öppna host.json.
I avsnittet customHandler.description anger du värdet defaultExecutablePath för till handler (i Windows anger du det till handler.exe).
I avsnittet customHandler lägger du till en egenskap med namnet enableForwardingHttpRequest och anger dess värde till true. För funktioner som endast består av en HTTP-utlösare förenklar den här inställningen programmeringen så att du kan arbeta med en typisk HTTP-begäran i stället för nyttolasten för anpassad hanteringsbegäran.

Bekräfta att avsnittet customHandler ser ut så här. Spara filen.

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

Funktionsappen är konfigurerad för att starta den körbara körbara hanteraren.

Kör funktionen lokalt

Verifiera den nya funktionen genom att köra projektet lokalt och anropa funktionsslutpunkten.

Använd det här kommandot för att starta den lokala Azure Functions-körningsvärden i roten i projektmappen:

func start

npm install
npm start

mvn clean package  
mvn azure-functions:run

Mot slutet av utdata visas följande rader:

 ...

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

Kopiera URL:en för din funktion HttpExample från det här resultatet, öppna en webbläsare och besök funktions-URL:en. Du bör få ett lyckat svar med ett "hello world"-meddelande.

Note

Eftersom åtkomstnyckelauktorisering inte framtvingas när den körs lokalt innehåller inte funktions-URL:en som returneras åtkomstnyckelvärdet och du behöver det inte för att anropa funktionen.
När du är klar ska du använda Ctrl+C och välja y för att stoppa värden för funktionerna.

Skapa stödjande Azure-resurser för din funktion

Innan du kan distribuera funktionskoden till Azure måste du skapa följande resurser:

En resursgrupp, som är en logisk container för relaterade resurser.
Ett standardlagringskonto som används av Functions-värden för att underhålla tillstånd och annan information om dina funktioner.
En användartilldelad hanterad identitet som Functions-värden använder för att ansluta till standardlagringskontot.
En funktionsapp som tillhandahåller miljön för att köra funktionskoden. En funktionsapp mappar till ditt lokala funktionsprojekt och låter dig gruppera funktioner som en logisk enhet för enklare hantering, distribution och delning av resurser.

Använd Azure CLI-kommandona i de här stegen för att skapa de resurser som krävs.

Om du inte redan har gjort det loggar du in på Azure:
```
az login
```
Kommandot az login loggar in dig på ditt Azure-konto. Hoppa över det här steget när du kör i Azure Cloud Shell.
Om du inte redan har gjort det använder du det här az extension add kommandot för att installera Application Insights-tillägget:
```
az extension add --name application-insights
```
Använd det här kommandot az group create för att skapa en resursgrupp med namnet AzureFunctionsQuickstart-rg i din valda region:
```
az group create --name "AzureFunctionsQuickstart-rg" --location "<REGION>"
```
I det här exemplet ersätter <REGION> du med en region nära dig som stöder Flex Consumption-planen. Använd kommandot az functionapp list-flexconsumption-locations för att visa listan över regioner som stöds för närvarande.
Använd kommandot az storage account create för att skapa ett allmänt lagringskonto i din resursgrupp och region:
```
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
```
I det här exemplet ersätter du <STORAGE_NAME> med ett namn som är lämpligt för dig och unikt i Azure Storage. Namn får endast innehålla gemener och siffror och måste vara mellan tre och 24 tecken långa. Standard_LRS anger ett konto för generell användning som stöds av Functions. Det nya kontot kan bara nås med hjälp av Microsoft Entra-autentiserade identiteter som har beviljats behörighet till specifika resurser.
Använd det här skriptet för att skapa en användartilldelad hanterad identitet, parsa de returnerade JSON-egenskaperna för objektet med hjälp jqav och bevilja Storage Blob Data Owner behörigheter i standardlagringskontot:
```
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
```
Om du inte har jq verktyget i ditt lokala Bash-gränssnitt är det tillgängligt i Azure Cloud Shell. I det här exemplet ersätter du <STORAGE_NAME> och <REGION> med namnet på ditt standardlagringskonto respektive din region.

Kommandot az identity create skapar en identitet med namnet func-host-storage-user. Den returnerade principalId används för att tilldela behörigheter till den nya identiteten i standardlagringskontot med hjälp av az role assignment create kommandot. Kommandot az storage account show används för att hämta lagringskontots ID.

Använd det här kommandot az functionapp create för att skapa funktionsappen i 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"

I det här exemplet ersätter du dessa platshållare med lämpliga värden:

<APP_NAME>: ett globalt unikt namn som passar dig. <APP_NAME> är även DNS-standarddomänen för funktionsappen.
<STORAGE_NAME>: namnet på det konto som du använde i föregående steg.
<REGION>: aktuell region för dig.
<LANGUAGE_VERSION>: Använd samma språkstackversion som stöds som du verifierade lokalt, när det är tillämpligt.

Det här kommandot skapar en funktionsapp som körs i din angivna språkkörning i Linux i Flex Consumption Plan, vilket är kostnadsfritt för den mängd användning som du får här. Kommandot skapar också en associerad Azure Application Insights-instans i samma resursgrupp, som du kan använda för att övervaka funktionsappens körningar och visa loggar. Mer information finns i Övervaka Azure Functions. Instansen genererar inga kostnader förrän du aktiverar den.

Använd det här skriptet för att lägga till din användartilldelade hanterade identitet i rollen Monitoring Metrics Publisher i Application Insights-instansen:
```
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
```
I det här exemplet ersätter du <APP_NAME> med namnet på funktionsappen. Kommandot az role assignment create lägger till användaren i rollen. Resurs-ID:n för din Application Insights-instans och huvud-ID:t för din användare hämtas med hjälp av kommandot az monitor app-insights component show och az identity show, respektive.

Uppdatera programinställningar

Om du vill göra det möjligt för Functions-värden att ansluta till standardlagringskontot med hjälp av delade hemligheter ersätter du inställningen för anslutningssträngen AzureWebJobsStorage med flera inställningar som är prefixade med AzureWebJobsStorage__. De här inställningarna definierar en komplex inställning som appen använder för att ansluta till lagring och Application Insights med en användartilldelad hanterad identitet.

Använd det här skriptet för att hämta klient-ID för den användartilldelade hanterade identiteten och använder det för att definiera hanterade identitetsanslutningar till både lagring och 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"

I det här skriptet ersätter du <APP_NAME> och <STORAGE_NAME> med namnen på din funktionsapp respektive ditt lagringskonto.

Kör kommandot az functionapp config appsettings delete för att ta bort den befintliga AzureWebJobsStorage inställningen för anslutningssträngen, som innehåller en delad hemlighetsnyckel:
```
az functionapp config appsettings delete --name <APP_NAME> --resource-group "AzureFunctionsQuickstart-rg" --setting-names AzureWebJobsStorage
```
I det här exemplet ersätter du <APP_NAME> med namnen på funktionsappen.

Nu kan Functions-värdtjänsten ansluta till lagringskontot på ett säkert sätt med hjälp av hanterade identiteter i stället för delade hemligheter. Nu kan du distribuera projektkoden till Azure-resurserna.

Distribuera funktionsprojektet till Azure

När du har skapat funktionsappen func azure functionapp publish i Azure är du nu redo att distribuera ditt lokala funktionsprojekt med hjälp av kommandot .

Kör det här func azure functionapp publish kommandot i rotprojektmappen:

func azure functionapp publish <APP_NAME>

I det här exemplet ersätter du <APP_NAME> med namnet på din app. En lyckad distribution visar resultat som liknar följande utdata (trunkerade för enkelhetens skull):

 ...

 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

I den lokala terminalen eller kommandotolken kör du det här kommandot för att hämta URL-slutpunktsvärdet, inklusive åtkomstnyckeln:
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
I det här exemplet ersätter du <APP_NAME> igen med namnet på din app.
Kopiera den returnerade slutpunkts-URL:en och -nyckeln som du använder för att anropa funktionsslutpunkten.

Uppdatera filen pom.xml

När du har skapat funktionsappen i Azure uppdaterar du pom.xml-filen så att Maven kan distribuera till din nya app. Annars skapar Maven en ny uppsättning Azure-resurser under distributionen.

I Azure Cloud Shell använder du det här az functionapp show kommandot för att hämta distributionscontainerns URL och ID för den nya användartilldelade hanterade identiteten:

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

I det här exemplet ersätter du <APP_NAME> med namnen på funktionsappen.

Öppna filen pom.xml i en textredigerare i projektrotkatalogen, leta upp elementet properties och uppdatera dessa specifika egenskapsvärden:

Egenskapsnamn	Value
`java.version`	Använd samma språkstackversion som stöds som du verifierade lokalt, till exempel `17`.
`azure.functions.maven.plugin.version`	`1.37.1`
`azure.functions.java.library.version`	`3.1.0`
`functionAppName`	Namnet på funktionsappen i Azure.

Leta upp configuration avsnittet i azure-functions-maven-plugin och ersätt det med det här XML-fragmentet:

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

I det nya configuration elementet gör du följande specifika ersättningar av ellipsvärdena (...):

Configuration	Value
`region`	Regionkoden för din befintliga funktionsapp, till exempel `eastus`.
`deploymentStorageAccount`	Namnet på ditt lagringskonto.
`deploymentStorageContainer`	Namnet på distributionsresursen, som kommer efter `\` i `containerUrl`-värdet som du har fått.
`userAssignedIdentityResourceId`	Det fullständigt kvalificerade resurs-ID:t för din hanterade identitet, som du fick.

Spara ändringarna i filenpom.xml .

Nu kan du använda Maven för att distribuera kodprojektet till din befintliga app.

Distribuera funktionsprojektet till Azure

Kör följande kommando från kommandotolken:
```
mvn clean package azure-functions:deploy
```
När distributionen har slutförts kör du det här Core Tools-kommandot för att hämta URL-slutpunktsvärdet, inklusive åtkomstnyckeln:
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
I det här exemplet ersätter du <APP_NAME> igen med namnet på din app.
Kopiera den returnerade slutpunkts-URL:en och -nyckeln som du använder för att anropa funktionsslutpunkten.

Anropa funktionen på Azure

Eftersom funktionen använder en HTTP-utlösare och stöder GET-begäranden anropar du den genom att göra en HTTP-begäran till dess URL med hjälp av åtkomstnyckeln på funktionsnivå. Det är enklast att köra en GET-begäran i en webbläsare.

Klistra in URL:en och åtkomstnyckeln som du kopierade till ett webbläsaradressfält.

Slutpunkts-URL:en bör se ut ungefär så här:

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

I det här fallet måste du också ange en åtkomstnyckel i frågesträngen när du gör en GET-begäran till slutpunkts-URL:en. Du rekommenderar att du använder en åtkomstnyckel för att begränsa åtkomsten från slumpmässiga klienter. När du gör en POST-begäran med hjälp av en HTTP-klient bör du i stället ange åtkomstnyckeln x-functions-key i rubriken.

När du navigerar till den här URL:en bör webbläsaren visa liknande utdata som när du körde funktionen lokalt.

Rensa resurser

Om du fortsätter till nästa steg och lägger till en Azure Storage-köutdatabindning behåller du alla resurser på plats när du bygger vidare på det du redan har gjort.

Annars använder du följande kommando för att ta bort resursgruppen och alla dess inneslutna resurser för att undvika ytterligare kostnader.

Azure CLI
Azure PowerShell

az group delete --name AzureFunctionsQuickstart-rg

Remove-AzResourceGroup -Name AzureFunctionsQuickstart-rg

Nästa steg

Ansluta till Azure Queue Storage

Feedback

Var den här sidan till hjälp?

Last updated on 2025-12-04

Dela via

Snabbstart: Skapa en funktion i Azure från kommandoraden

Prerequisites

Installera Azure Functions Core Tools

Skapa och aktivera en virtuell miljö

Skapa ett lokalt kodprojekt och en funktion

Skapa och skapa din funktion

Konfigurera funktionsappen

Kör funktionen lokalt

Skapa stödjande Azure-resurser för din funktion

Uppdatera programinställningar

Distribuera funktionsprojektet till Azure

Uppdatera filen pom.xml

Distribuera funktionsprojektet till Azure

Anropa funktionen på Azure

Rensa resurser

Nästa steg

Feedback

Ytterligare resurser