Schnellstart: Erstellen und Bereitstellen von Funktionen in Azure Functions mithilfe der Azure Developer CLI

Artikel
10/19/2024

In diesem Schnellstart verwenden Sie Azure Developer-Befehlszeilentools, um Funktionen 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.

Wichtig

Der Flex-Verbrauchstarif befindet sich derzeit in der Vorschau.

Standardmäßig folgt der Flex-Verbrauchsplan einem nutzungsbasierten Abrechnungsmodell, was bedeutet, dass dieser Schnellstart geringe Kosten von ein paar USD oder weniger in Ihrem Azure-Konto verursacht.

Voraussetzungen

Ein Azure-Konto mit einem aktiven Abonnement. Sie können kostenlos ein Konto erstellen.
Azure Developer CLI.
Azure Functions Core Tools.

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 Umgebungsvariable JAVA_HOME muss auf den Installationsspeicherort der richtigen Version des JDK festgelegt sein.
Apache Maven 3.8.x

Node.js 20

Python 3.11.

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

Initialisieren des Projekts

Mit dem azd init-Befehl können Sie ein lokales Azure Functions-Codeprojekt aus einer Vorlage erstellen.

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 flexquickstart-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 azd wird die Umgebung verwendet, um einen eindeutigen Bereitstellungskontext für Ihre App zu verwalten, und Sie können mehrere definieren. Sie wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.
Führen Sie diesen Befehl aus, um zum App-Ordner „http“ zu navigieren:
```
cd http
```

Erstellen Sie eine Datei mit dem Namen local.settings.json im http-Ordner, der 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.

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 flexquickstart-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 azd wird die Umgebung verwendet, um einen eindeutigen Bereitstellungskontext für Ihre App zu verwalten, und Sie können mehrere definieren. Sie wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.
Führen Sie diesen Befehl aus, um zum App-Ordner „http“ zu navigieren:
```
cd http
```
Erstellen Sie eine Datei mit dem Namen local.settings.json im http-Ordner, der 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.

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 flexquickstart-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 azd wird die Umgebung verwendet, um einen eindeutigen Bereitstellungskontext für Ihre App zu verwalten, und Sie können mehrere definieren. Sie wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.
Erstellen Sie eine Datei namens local.settings.json im Stammordner, der 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.

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 flexquickstart-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 azd wird die Umgebung verwendet, um einen eindeutigen Bereitstellungskontext für Ihre App zu verwalten, und Sie können mehrere definieren. Sie wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.
Führen Sie diesen Befehl aus, um zum App-Ordner „src“ zu navigieren:
```
cd src
```

Erstellen Sie eine Datei mit dem Namen local.settings.json im src-Ordner, der 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.

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 flexquickstart-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 azd wird die Umgebung verwendet, um einen eindeutigen Bereitstellungskontext für Ihre App zu verwalten, und Sie können mehrere definieren. Sie wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.
Erstellen Sie eine Datei namens local.settings.json im Stammordner, der 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.

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 flexquickstart-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 azd wird die Umgebung verwendet, um einen eindeutigen Bereitstellungskontext für Ihre App zu verwalten, und Sie können mehrere definieren. Sie wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

Erstellen Sie eine Datei namens local.settings.json im Stammordner, der 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:

python3 -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
source .venv/scripts/activate

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

Ausführen in Ihrer lokalen Umgebung

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.
Navigieren Sie in Ihrem Browser zum httpget-Endpunkt, der wie diese URL aussehen sollte:

http://localhost:7071/api/httpget
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“.
Wenn Sie fertig sind, drücken Sie STRG+C im Terminalfenster, um den func.exe-Hostprozess zu beenden.

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
httppost

       [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}!")

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

Sie das vollständige Vorlagenprojekt hier überprüfen.

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

Erstellen von Azure-Ressourcen

Dieses Projekt ist so konfiguriert, dass der azd provision-Befehl verwendet wird, um eine Funktions-App in einem Flex-Verbrauchsplan zusammen mit anderen erforderlichen Azure-Ressourcen zu erstellen.

Hinweis

Dieses Projekt enthält eine Reihe von Bicep-Dateien, die azd verwendet, um eine sichere Bereitstellung für einen Flex-Verbrauchsplan, der den bewährten Methoden folgt, zu erstellen.

Die Befehle „azd up“ und „azd deploy“ werden derzeit für Java-Apps nicht unterstützt.

Führen Sie im Stammordner des Projekts diesen Befehl aus, um die erforderlichen Azure-Ressourcen zu erstellen:
```
azd provision
```
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.

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

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

Der azd provision-Befehl verwendet Ihre Antwort auf diese Eingabeaufforderungen mit den Bicep-Konfigurationsdateien, um diese erforderlichen Azure-Ressourcen zu erstellen und zu konfigurieren:

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)
Virtuelles Netzwerk zum sicheren Ausführen der Funktions-App und der anderen Azure-Ressourcen

Nachdem der Befehl erfolgreich abgeschlossen wurde, können Sie Ihren Projektcode in dieser neuen Funktions-App in Azure bereitstellen.

Bereitstellung in Azure

Sie können Core Tools verwenden, um Ihren Code zu packen und aus dem target-Ausgabeordner in Azure bereitzustellen.

Navigieren Sie zum Äquivalent des App-Ordners im target-Ausgabeordner:
```
cd http/target/azure-functions/contoso-functions
```
Dieser Ordner sollte über eine host.json-Datei verfügen, die angibt, dass es sich um den Stamm ihrer kompilierten Java-Funktions-App handelt.
Führen Sie die folgenden Befehle aus, um Ihr kompiliertes Java-Codeprojekt mithilfe von Core Tools in Azure in der neuen Funktions-App-Ressource bereitzustellen:
- Bash
- Cmd
```
APP_NAME=$(azd env get-value AZURE_FUNCTION_NAME)
func azure functionapp publish $APP_NAME
```
```
for /f "tokens=*" %i in ('azd env get-value AZURE_FUNCTION_NAME') do set APP_NAME=%i
func azure functionapp publish %APP_NAME% 
```
Der azd env get-value-Befehl ruft ihren Funktions-App-Namen aus der lokalen Umgebung ab, die für die Bereitstellung mit func azure functionapp publish erforderlich ist. Nachdem die Veröffentlichung erfolgreich abgeschlossen wurde, werden Links zu den HTTP-Triggerendpunkten in Azure angezeigt.

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.

Tipp

Dieses Projekt enthält eine Reihe von Bicep-Dateien, die azd verwendet, um eine sichere Bereitstellung für einen Flex-Verbrauchsplan, der den bewährten Methoden folgt, zu erstellen.

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.

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

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

Der azd up-Befehl verwendet Ihre Antwort 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)
- 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 Core Tools verwenden, um die URL-Endpunkte Ihrer Funktionen abzurufen, die in Azure ausgeführt werden.

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

Bash
Cmd

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

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
Cmd

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

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. Die Verwendung der --show-keys-Option mit func azure functionapp list-functions, bedeutet dass die zurückgegebene Wert Aufruf-URL: für jeden Endpunkt einen Zugriffsschlüssel auf Funktionsebene enthält.

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

Sie können den azd up-Befehl beliebig oft ausführen, um sowohl Ihre Azure-Ressourcen als auch Codeupdates für Ihre Funktions-App bereitzustellen.

Hinweis

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 beim Erstellen von Azure-Ressourcen verwendet wurden.

Bereinigen von Ressourcen

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

azd down --no-prompt

Hinweis

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.

Freigeben über

Schnellstart: Erstellen und Bereitstellen von Funktionen in Azure Functions mithilfe der Azure Developer CLI

Voraussetzungen

Initialisieren des Projekts

Erstellen und Aktivieren einer virtuellen Umgebung

Ausführen in Ihrer lokalen Umgebung

Überprüfen des Codes (optional)

Erstellen von Azure-Ressourcen

Bereitstellung in Azure

Bereitstellung in Azure

Aufrufen der Funktion in Azure

Erneutes Bereitstellen Ihres Codes

Bereinigen von Ressourcen

Feedback

Zusätzliche Ressourcen

Freigeben über

Schnellstart: Erstellen und Bereitstellen von Funktionen in Azure Functions mithilfe der Azure Developer CLI

Voraussetzungen

Initialisieren des Projekts

Erstellen und Aktivieren einer virtuellen Umgebung

Ausführen in Ihrer lokalen Umgebung

Überprüfen des Codes (optional)

Erstellen von Azure-Ressourcen

Bereitstellung in Azure

Bereitstellung in Azure

Aufrufen der Funktion in Azure

Erneutes Bereitstellen Ihres Codes

Bereinigen von Ressourcen

Zugehöriger Inhalt

Feedback

Zusätzliche Ressourcen