Schnellstart: Erstellen einer skalierbaren Web-API mit Azure Functions

In dieser Schnellstartanleitung verwenden Sie Azure Developer-Befehlszeilentools, um eine skalierbare Web-API mit Funktionsendpunkten zu erstellen, die auf HTTP-Anforderungen reagieren. Nachdem Sie den Code lokal getestet haben, stellen Sie ihn in einer neuen serverlosen Funktions-App bereit, die Sie in einem Flex-Verbrauchsplan in Azure Functions erstellen.

Die Projektquelle verwendet die Azure Developer CLI (azd), um die Bereitstellung Ihres Codes in Azure zu vereinfachen. Diese Bereitstellung folgt den aktuellen bewährten Methoden für sichere und skalierbare Azure Functions-Bereitstellungen.

Standardmäßig folgt der Flex-Verbrauchsplan einem Abrechnungsmodell nach dem Prinzip 'Bezahlen nach Nutzung'. Dies bedeutet, dass bei diesem Quickstart ein kleiner Betrag von ein paar US-Cent oder weniger in Ihrem Azure-Konto anfallen wird.

Prerequisites

• Ein Azure-Konto mit einem aktiven Abonnement. Sie können kostenlos ein Konto erstellen.

• Azure Developer CLI

• Azure Functions Core Tools

• .NET 8.0 SDK

• Azurite-Speicheremulator

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

• PowerShell 7.2

• .NET 6.0 SDK

• Python 3.11

• Azurite-Speicheremulator

• Ein sicheres HTTP-Testtool zum Senden von Anforderungen mit JSON-Nutzlasten an Ihre Funktionsendpunkte. In diesem Artikel wird curl verwendet.

Initialisieren des Projekts

Verwenden Sie den azd init Befehl, um ein lokales Azure Functions-Codeprojekt aus einer Vorlage zu erstellen.

1. Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

   azd init --template functions-quickstart-dotnet-azd -e httpendpoint-dotnet
   

   Mit diesem Befehl werden die Projektdateien aus dem Vorlagen-Repository abgerufen und das Projekt im aktuellen Ordner initialisiert. Das -e-Flag legt einen Namen für die aktuelle Umgebung fest. In azdder Umgebung wird ein eindeutiger Bereitstellungskontext für Ihre App verwaltet, und Sie können mehrere definieren. Sie wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

2. Führen Sie diesen Befehl aus, um zum App-Ordner „http“ zu navigieren:

   cd http
   

3. Erstellen Sie eine Datei mit dem Namen local.settings.json im Ordner, der http diese JSON-Daten enthält:

   {
       "IsEncrypted": false,
       "Values": {
           "AzureWebJobsStorage": "UseDevelopmentStorage=true",
           "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated"
       }
   }
   

   Diese Datei ist erforderlich, wenn sie lokal ausgeführt wird.

1. Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

   azd init --template azure-functions-java-flex-consumption-azd -e httpendpoint-java 
   

   Mit diesem Befehl werden die Projektdateien aus dem Vorlagen-Repository abgerufen und das Projekt im aktuellen Ordner initialisiert. Das -e-Flag legt einen Namen für die aktuelle Umgebung fest. In azdder Umgebung wird ein eindeutiger Bereitstellungskontext für Ihre App verwaltet, und Sie können mehrere definieren. Sie wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

2. Führen Sie diesen Befehl aus, um zum App-Ordner „http“ zu navigieren:

   cd http
   

3. Erstellen Sie eine Datei mit dem Namen local.settings.json im Ordner, der http diese JSON-Daten enthält:

   {
       "IsEncrypted": false,
       "Values": {
           "AzureWebJobsStorage": "UseDevelopmentStorage=true",
           "FUNCTIONS_WORKER_RUNTIME": "java"
       }
   }
   

   Diese Datei ist erforderlich, wenn sie lokal ausgeführt wird.

1. Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

   azd init --template functions-quickstart-javascript-azd -e httpendpoint-js
   

   Mit diesem Befehl werden die Projektdateien aus dem Vorlagen-Repository abgerufen und das Projekt im Stammordner initialisiert. Das -e-Flag legt einen Namen für die aktuelle Umgebung fest. In azdder Umgebung wird ein eindeutiger Bereitstellungskontext für Ihre App verwaltet, und Sie können mehrere definieren. Sie wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

2. Erstellen Sie eine Datei namens local.settings.json im Stammordner, die diese JSON-Daten enthält:

   {
       "IsEncrypted": false,
       "Values": {
           "AzureWebJobsStorage": "UseDevelopmentStorage=true",
           "FUNCTIONS_WORKER_RUNTIME": "node"
       }
   }
   

   Diese Datei ist erforderlich, wenn sie lokal ausgeführt wird.

1. Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

   azd init --template functions-quickstart-powershell-azd -e httpendpoint-ps
   

   Mit diesem Befehl werden die Projektdateien aus dem Vorlagen-Repository abgerufen und das Projekt im Stammordner initialisiert. Das -e-Flag legt einen Namen für die aktuelle Umgebung fest. In azdder Umgebung wird ein eindeutiger Bereitstellungskontext für Ihre App verwaltet, und Sie können mehrere definieren. Sie wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

2. Führen Sie diesen Befehl aus, um zum App-Ordner „src“ zu navigieren:

   cd src
   

3. Erstellen Sie eine Datei mit dem Namen local.settings.json im Ordner, der src diese JSON-Daten enthält:

   {
       "IsEncrypted": false,
       "Values": {
           "AzureWebJobsStorage": "UseDevelopmentStorage=true",
           "FUNCTIONS_WORKER_RUNTIME": "powershell",
           "FUNCTIONS_WORKER_RUNTIME_VERSION": "7.2"
       }
   }
   

   Diese Datei ist erforderlich, wenn sie lokal ausgeführt wird.

1. Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

   azd init --template functions-quickstart-typescript-azd -e httpendpoint-ts
   

   Mit diesem Befehl werden die Projektdateien aus dem Vorlagen-Repository abgerufen und das Projekt im Stammordner initialisiert. Das -e-Flag legt einen Namen für die aktuelle Umgebung fest. In azdder Umgebung wird ein eindeutiger Bereitstellungskontext für Ihre App verwaltet, und Sie können mehrere definieren. Der Umgebungsname wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

2. Erstellen Sie eine Datei namens local.settings.json im Stammordner, die diese JSON-Daten enthält:

   {
       "IsEncrypted": false,
       "Values": {
           "AzureWebJobsStorage": "UseDevelopmentStorage=true",
           "FUNCTIONS_WORKER_RUNTIME": "node"
       }
   }
   

   Diese Datei ist erforderlich, wenn sie lokal ausgeführt wird.

1. Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

   azd init --template functions-quickstart-python-http-azd -e httpendpoint-py
   

   Mit diesem Befehl werden die Projektdateien aus dem Vorlagen-Repository abgerufen und das Projekt im Stammordner initialisiert. Das -e-Flag legt einen Namen für die aktuelle Umgebung fest. In azdder Umgebung wird ein eindeutiger Bereitstellungskontext für Ihre App verwaltet, und Sie können mehrere definieren. Der Umgebungsname wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

2. Erstellen Sie eine Datei namens local.settings.json im Stammordner, die diese JSON-Daten enthält:

   {
       "IsEncrypted": false,
       "Values": {
           "AzureWebJobsStorage": "UseDevelopmentStorage=true",
           "FUNCTIONS_WORKER_RUNTIME": "python"
       }
   }
   

   Diese Datei ist erforderlich, wenn sie lokal ausgeführt wird.

Erstellen und Aktivieren einer virtuellen Umgebung

Führen Sie im Stammordner die folgenden Befehle aus, um eine virtuelle Umgebung mit dem Namen „.venv“ zu erstellen und zu aktivieren:

Linux/macOS

python3 -m venv .venv
source .venv/bin/activate

Wenn Python das venv-Paket nicht in Ihrer Linux-Verteilung installiert, führen Sie den folgenden Befehl aus:

sudo apt-get install python3-venv

Windows (bash)

py -m venv .venv
source .venv/scripts/activate

Windows (Cmd)

py -m venv .venv
.venv\scripts\activate

Ausführen in Ihrer lokalen Umgebung

1. Führen Sie diesen Befehl in Ihrem App-Ordner in einem Terminal oder einer Eingabeaufforderung aus:

   func start
   

   mvn clean package
   mvn azure-functions:run
   

   npm install
   func start  
   

   npm install
   npm start  
   

   Wenn der Functions-Host in Ihrem lokalen Projektordner gestartet wird, schreibt er die URL-Endpunkte Ihrer von HTTP ausgelösten Funktionen in die Terminalausgabe.

   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.

2. Wechseln Sie in Ihrem Browser zum httpget Endpunkt, der wie diese URL aussehen soll:

   http://localhost:7071/api/httpget

3. Führen Sie in einem neuen Terminal- oder Eingabeaufforderungsfenster diesen curl-Befehl aus, um eine POST-Anforderung mit JSON-Nutzdaten an den httppost-Endpunkt zu senden:

   curl -i http://localhost:7071/api/httppost -H "Content-Type: text/json" -d @testdata.json
   

   curl -i http://localhost:7071/api/httppost -H "Content-Type: text/json" -d "@src/functions/testdata.json"
   

   Mit diesem Befehl werden JSON-Nutzdaten aus der Projektdatei „testdata.json“ gelesen. Beispiele für beide HTTP-Anforderungen finden Sie in der Projektdatei „test.http“.

4. Wenn Sie fertig sind, drücken Sie STRG+C im Terminalfenster, um den func.exe-Hostprozess zu beenden.

5. Führen Sie deactivate aus, um die virtuelle Umgebung zu beenden.

Überprüfen des Codes (optional)

Sie können den Code überprüfen, der die beiden HTTP-Triggerfunktionsendpunkte definiert:

httpget

       [Function("httpget")]
       public IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "get")]
         HttpRequest req,
         string name)
       {
           var returnValue = string.IsNullOrEmpty(name)
               ? "Hello, World."
               : $"Hello, {name}.";

           _logger.LogInformation($"C# HTTP trigger function processed a request for {returnValue}.");

           return new OkObjectResult(returnValue);
       }

@FunctionName("httpget")
public HttpResponseMessage run(
        @HttpTrigger(
            name = "req",
            methods = {HttpMethod.GET},
            authLevel = AuthorizationLevel.FUNCTION)
            HttpRequestMessage<Optional<String>> request,
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a request.");

    // Parse query parameter
    String name = Optional.ofNullable(request.getQueryParameters().get("name")).orElse("World");

    return request.createResponseBuilder(HttpStatus.OK).body("Hello, " + name).build();
}

const { app } = require('@azure/functions');

app.http('httpget', {
    methods: ['GET'],
    authLevel: 'function',
    handler: async (request, context) => {
        context.log(`Http function processed request for url "${request.url}"`);

        const name = request.query.get('name') || await request.text() || 'world';

        return { body: `Hello, ${name}!` };
    }
});

import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";

export async function httpGetFunction(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

    const name = request.query.get('name') || await request.text() || 'world';

    return { body: `Hello, ${name}!` };
};

app.http('httpget', {
    methods: ['GET'],
    authLevel: 'function',
    handler: httpGetFunction
});

Diese function.json-Datei definiert die httpget-Funktion:

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get"
      ],
      "route": "httpget"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    }
  ]
}

Diese run.ps1-Datei implementiert den Funktionscode:

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with query parameters
$name = $Request.Query.name

$body = "This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response."

if ($name) {
    $body = "Hello, $name. This HTTP triggered function executed successfully."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = [HttpStatusCode]::OK
    Body = $body
})

@app.route(route="httpget", methods=["GET"])
def http_get(req: func.HttpRequest) -> func.HttpResponse:
    name = req.params.get("name", "World")

    logging.info(f"Processing GET request. Name: {name}")

    return func.HttpResponse(f"Hello, {name}!")

httppost

[Function("httppost")]
public IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req,
    [FromBody] Person person)
{
    _logger.LogInformation($"C# HTTP POST trigger function processed a request for url {req.Body}");

    if (string.IsNullOrEmpty(person.Name) | string.IsNullOrEmpty(person.Age.ToString()) | person.Age == 0)
    {
        _logger.LogInformation("C# HTTP POST trigger function processed a request with no name/age provided.");
        return new BadRequestObjectResult("Please provide both name and age in the request body.");
    }

    var returnValue = $"Hello, {person.Name}! You are {person.Age} years old.";
    
    _logger.LogInformation($"C# HTTP POST trigger function processed a request for {person.Name} who is {person.Age} years old.");
    return new OkObjectResult(returnValue);
}

@FunctionName("httppost")
public HttpResponseMessage runPost(
        @HttpTrigger(
            name = "req",
            methods = {HttpMethod.POST},
            authLevel = AuthorizationLevel.FUNCTION)
            HttpRequestMessage<Optional<String>> request,
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a POST request.");

    // Parse request body
    String name;
    Integer age;
    try {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode jsonNode = mapper.readTree(request.getBody().orElse("{}"));
        name = Optional.ofNullable(jsonNode.get("name")).map(JsonNode::asText).orElse(null);
        age = Optional.ofNullable(jsonNode.get("age")).map(JsonNode::asInt).orElse(null);
        if (name == null || age == null) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                    .body("Please provide both name and age in the request body.").build();
        }
    } catch (Exception e) {
        context.getLogger().severe("Error parsing request body: " + e.getMessage());
        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                .body("Error parsing request body").build();
    }

const { app } = require('@azure/functions');

app.http('httppost', {
    methods: ['POST'],
    authLevel: 'function',
    handler: async (request, context) => {
        context.log(`Http function processed request for url "${request.url}"`);

        try {
            const person = await request.json();
            const { name, age } = person;

            if (!name || !age) {
                return {
                    status: 400,
                    body: 'Please provide both name and age in the request body.'
                };
            }

            return {
                status: 200,
                body: `Hello, ${name}! You are ${age} years old.`
            };
        } catch (error) {
            return {
                status: 400,
                body: 'Invalid request body. Please provide a valid JSON object with name and age.'
            };
        }
    }
});

import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";

interface Person {
    name: string;
    age: number;
}

function isPerson(obj: any): obj is Person {
    return typeof obj === 'object' && obj !== null && 
           typeof obj.name === 'string' && 
           typeof obj.age === 'number';
}

export async function httpPostBodyFunction(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

        try {
            const data: any  = await request.json();
    
            if (!isPerson(data)) {
                return {
                    status: 400,
                    body: 'Please provide both name and age in the request body.'
                };
            }

            return {
                status: 200,
                body: `Hello, ${data.name}! You are ${data.age} years old.`
            };
        } catch (error) {
            return {
                status: 400,
                body: 'Invalid request body. Please provide a valid JSON object with name and age.'
            };
        }
};

app.http('httppost', {
    methods: ['POST'],
    authLevel: 'function',
    handler: httpPostBodyFunction
});

Diese function.json-Datei definiert die httppost-Funktion:

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "post"
      ],
      "route": "httppost"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    }
  ]
}

Diese run.ps1-Datei implementiert den Funktionscode:

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with the body of the request.
$name = $Request.Body.name
$age = $Request.Body.age
$status = [HttpStatusCode]::OK

$body = "This HTTP triggered function executed successfully. Pass a name in the request body for a personalized response."

if ( -not ($name -and $age)){
    $body = "Please provide both 'name' and 'age' in the request body."
    $status = [HttpStatusCode]::BadRequest
}
else {
    <# Action when all if and elseif conditions are false #>
    $body = "Hello, ${name}! You are ${age} years old."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = $status
    Body = $body
})

@app.route(route="httppost", methods=["POST"])
def http_post(req: func.HttpRequest) -> func.HttpResponse:
    try:
        req_body = req.get_json()
        name = req_body.get('name')
        age = req_body.get('age')
        
        logging.info(f"Processing POST request. Name: {name}")

        if name and isinstance(name, str) and age and isinstance(age, int):
            return func.HttpResponse(f"Hello, {name}! You are {age} years old!")
        else:
            return func.HttpResponse(
                "Please provide both 'name' and 'age' in the request body.",
                status_code=400
            )
    except ValueError:
        return func.HttpResponse(
            "Invalid JSON in request body",
            status_code=400
        )

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

Nachdem Sie Ihre Funktionen lokal überprüft haben, ist es an der Zeit, sie in Azure zu veröffentlichen.

Bereitstellung in Azure

Dieses Projekt ist so konfiguriert, dass der azd up-Befehl verwendet wird, um dieses Projekt in einer neuen Funktions-App in einem Flex-Verbrauchsplan in Azure bereitzustellen.

Tip

Das Projekt enthält eine Reihe von Bicep-Dateien (im infra-Ordner), die azd verwendet, um eine sichere Bereitstellung für einen Flex-Verbrauchsplan zu erstellen, der den bewährten Verfahren entspricht.

1. Führen Sie diesen Befehl aus, damit azd die erforderlichen Azure-Ressourcen in Azure erstellt und Ihr Codeprojekt in der neuen Funktions-App bereitstellt:

   azd up
   

   Der Stammordner enthält die azure.yaml-Definitionsdatei, die azd erfordert.

   Wenn Sie noch nicht angemeldet sind, werden Sie aufgefordert, sich mit Ihrem Azure-Konto zu authentifizieren.

2. Wenn Sie dazu aufgefordert werden, stellen Sie die folgenden erforderlichen Bereitstellungsparameter bereit:

   Parameter	Description
   Azure-Abonnement	Das Abonnement, in dem Ihre Ressourcen erstellt werden.
   Azure-Standort	Die Azure-Region, in der die Ressourcengruppe erstellt werden soll, die die neuen Azure-Ressourcen enthält. Es werden nur Regionen angezeigt, die den Flex-Verbrauchsplan derzeit unterstützen.
   vnetEnabled	Wählen Sie "False" aus. Bei Festlegung auf "True " erstellt die Bereitstellung Ihre Funktions-App in einem neuen virtuellen Netzwerk.

   Der azd up Befehl verwendet Ihre Antworten auf diese Eingabeaufforderungen mit den Bicep-Konfigurationsdateien, um diese Bereitstellungsaufgaben auszuführen:

   • Erstellen und Konfigurieren dieser erforderlichen Azure-Ressourcen (entspricht azd provision):

     • Flex-Verbrauchsplan und Funktions-App
     • Azure Storage (erforderlich) und Application Insights (empfohlen)
     • Zugriffsrichtlinien und -rollen für Ihr Konto
     • Dienst-zu-Dienst-Verbindungen mit verwalteten Identitäten (anstelle gespeicherter Verbindungszeichenfolgen)
     • (Option) Virtuelles Netzwerk zum sicheren Ausführen der Funktions-App und der anderen Azure-Ressourcen

   • Packen und Bereitstellen des Codes im Bereitstellungscontainer (entspricht azd deploy). Die App wird dann gestartet und im bereitgestellten Paket ausgeführt.

   Nachdem der Befehl erfolgreich abgeschlossen wurde, werden Links zu den von Ihnen erstellten Ressourcen angezeigt.

Aufrufen der Funktion in Azure

Sie können nun Ihre Funktionsendpunkte in Azure aufrufen, indem Sie HTTP-Anforderungen an ihre URLs mithilfe Ihres HTTP-Testtools oder aus dem Browser (für GET-Anforderungen) senden. Wenn Ihre Funktionen in Azure ausgeführt werden, wird die Autorisierung mit Zugriffsschlüsseln erzwungen, und Sie müssen mit ihrer Anforderung einen Funktionszugriffsschlüssel bereitstellen.

Sie können die Kerntools verwenden, um die URL-Endpunkte Ihrer Funktionen abzurufen, die in Azure ausgeführt werden.

1. Führen Sie in Ihrer lokalen Terminal- oder Eingabeaufforderung die folgenden Befehle aus, um die URL-Endpunktwerte abzurufen:

   bash

   SET APP_NAME=$(azd env get-value AZURE_FUNCTION_NAME)
   func azure functionapp list-functions $APP_NAME --show-keys
   

   Cmd

   for /f "tokens=*" %i in ('azd env get-value AZURE_FUNCTION_NAME') do set APP_NAME=%i
   func azure functionapp list-functions %APP_NAME% --show-keys 
   

   PowerShell

   $APP_NAME = azd env get-value AZURE_FUNCTION_NAME
   func azure functionapp list-functions $APP_NAME --show-keys
   

   Cmd

   for /f "tokens=*" %i in ('azd env get-value AZURE_FUNCTION_NAME') do set APP_NAME=%i
   func azure functionapp list-functions %APP_NAME% --show-keys 
   

   Der azd env get-value-Befehl ruft ihren Funktions-App-Namen aus der lokalen Umgebung ab. Wenn Sie die --show-keys Option mit func azure functionapp list-functionsverwenden, enthält der zurückgegebene Aufruf-URL: Wert für jeden Endpunkt einen Zugriffsschlüssel auf Funktionsebene.

2. Verwenden Sie wie zuvor Ihr HTTP-Testtool, um diese URLs in Ihrer Funktions-App, die in Azure ausgeführt wird, zu überprüfen.

Erneutes Bereitstellen Ihres Codes

Führen Sie den azd up Befehl so oft aus, wie Sie ihre Azure-Ressourcen bereitstellen und Codeupdates für Ihre Funktions-App bereitstellen müssen.

Note

Bereitgestellte Codedateien werden immer vom neuesten Bereitstellungspaket überschrieben.

Ihre anfänglichen Antworten auf azd-Eingabeaufforderungen und alle von Ihnen generierten azd-Umgebungsvariablen werden lokal in Ihrer benannten Umgebung gespeichert. Verwenden Sie den azd env get-values Befehl, um alle Variablen in Ihrer Umgebung zu überprüfen, die Sie beim Erstellen von Azure-Ressourcen verwendet haben.

Bereinigen von Ressourcen

Wenn Sie mit der Arbeit mit Ihrer Funktions-App und verwandten Ressourcen fertig sind, verwenden Sie diesen Befehl, um die Funktions-App und die zugehörigen Ressourcen aus Azure zu löschen und weitere Kosten zu vermeiden:

azd down --no-prompt

Note

Die --no-prompt-Option weist azd an, Ihre Ressourcengruppe ohne Bestätigung von Ihnen zu löschen.

Dieser Befehl wirkt sich nicht auf Ihr lokales Codeprojekt aus.

Verwandte Inhalte

• Azure Functions-Szenarien
• Flex-Verbrauchstarif
• Azure Developer CLI (azd)
• azd-Referenz
• Verweis zu Azure Functions Core Tools
• Lokales Codieren und Testen von Azure Functions