Szybki start: tworzenie i wdrażanie funkcji w usłudze Azure Functions przy użyciu interfejsu wiersza polecenia dla deweloperów platformy Azure

W tym przewodniku Szybki start użyjesz narzędzi wiersza polecenia dla deweloperów platformy Azure, aby utworzyć funkcje, które odpowiadają na żądania HTTP. Po przetestowaniu kodu lokalnie wdrożysz go w nowej aplikacji funkcji bezserwerowej utworzonej w planie Flex Consumption w usłudze Azure Functions.

Źródło projektu używa interfejsu wiersza polecenia dla deweloperów platformy Azure (azd), aby uprościć wdrażanie kodu na platformie Azure. To wdrożenie jest zgodne z bieżącymi najlepszymi rozwiązaniami dotyczącymi bezpiecznych i skalowalnych wdrożeń usługi Azure Functions.

Domyślnie plan Flex Consumption jest zgodny z modelem rozliczeń z płatnością za to, co jest używane , co oznacza, że ukończenie tego przewodnika Szybki start wiąże się z niewielkimi kosztami co najmniej kilku centów w usd na koncie platformy Azure.

Wymagania wstępne

• Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.

• Interfejs wiersza polecenia dla deweloperów platformy Azure.

• Podstawowe narzędzia usługi Azure Functions.

• Zestaw SDK platformy .NET 8.0

• Emulator magazynu Azurite

• Java 17 Developer Kit
  • Jeśli używasz innej obsługiwanej wersji języka Java, musisz zaktualizować plik pom.xml projektu.
  • Zmienna JAVA_HOME środowiskowa musi być ustawiona na lokalizację instalacji prawidłowej wersji zestawu JDK.
• Apache Maven 3.8.x

• Node.js 20

• PowerShell 7.2

• Zestaw SDK dla platformy .NET 6.0

• Python 3.11.

• Bezpieczne narzędzie do testowania HTTP do wysyłania żądań przy użyciu ładunków JSON do punktów końcowych funkcji. W tym artykule jest używany program curl.

Inicjowanie projektu

Możesz użyć azd init polecenia , aby utworzyć lokalny projekt kodu usługi Azure Functions na podstawie szablonu.

1. W lokalnym terminalu lub wierszu polecenia uruchom to azd init polecenie w pustym folderze:

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

   To polecenie ściąga pliki projektu z repozytorium szablonów i inicjuje projekt w bieżącym folderze. Flaga -e ustawia nazwę bieżącego środowiska. W azdsystemie środowisko jest używane do obsługi unikatowego kontekstu wdrażania dla aplikacji i można zdefiniować więcej niż jeden. Jest ona również używana w nazwie grupy zasobów utworzonej na platformie Azure.

2. Uruchom to polecenie, aby przejść do http folderu aplikacji:

   cd http
   

3. Utwórz plik o nazwie local.settings.json w http folderze zawierającym te dane JSON:

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

   Ten plik jest wymagany podczas uruchamiania lokalnego.

1. W lokalnym terminalu lub wierszu polecenia uruchom to azd init polecenie w pustym folderze:

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

   To polecenie ściąga pliki projektu z repozytorium szablonów i inicjuje projekt w bieżącym folderze. Flaga -e ustawia nazwę bieżącego środowiska. W azdsystemie środowisko jest używane do obsługi unikatowego kontekstu wdrażania dla aplikacji i można zdefiniować więcej niż jeden. Jest ona również używana w nazwie grupy zasobów utworzonej na platformie Azure.

2. Uruchom to polecenie, aby przejść do http folderu aplikacji:

   cd http
   

3. Utwórz plik o nazwie local.settings.json w http folderze zawierającym te dane JSON:

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

   Ten plik jest wymagany podczas uruchamiania lokalnego.

1. W lokalnym terminalu lub wierszu polecenia uruchom to azd init polecenie w pustym folderze:

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

   To polecenie ściąga pliki projektu z repozytorium szablonów i inicjuje projekt w folderze głównym. Flaga -e ustawia nazwę bieżącego środowiska. W azdsystemie środowisko jest używane do obsługi unikatowego kontekstu wdrażania dla aplikacji i można zdefiniować więcej niż jeden. Jest ona również używana w nazwie grupy zasobów utworzonej na platformie Azure.

2. Utwórz plik o nazwie local.settings.json w folderze głównym zawierającym następujące dane JSON:

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

   Ten plik jest wymagany podczas uruchamiania lokalnego.

1. W lokalnym terminalu lub wierszu polecenia uruchom to azd init polecenie w pustym folderze:

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

   To polecenie ściąga pliki projektu z repozytorium szablonów i inicjuje projekt w folderze głównym. Flaga -e ustawia nazwę bieżącego środowiska. W azdsystemie środowisko jest używane do obsługi unikatowego kontekstu wdrażania dla aplikacji i można zdefiniować więcej niż jeden. Jest ona również używana w nazwie grupy zasobów utworzonej na platformie Azure.

2. Uruchom to polecenie, aby przejść do src folderu aplikacji:

   cd src
   

3. Utwórz plik o nazwie local.settings.json w src folderze zawierającym te dane JSON:

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

   Ten plik jest wymagany podczas uruchamiania lokalnego.

1. W lokalnym terminalu lub wierszu polecenia uruchom to azd init polecenie w pustym folderze:

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

   To polecenie ściąga pliki projektu z repozytorium szablonów i inicjuje projekt w folderze głównym. Flaga -e ustawia nazwę bieżącego środowiska. W azdsystemie środowisko jest używane do obsługi unikatowego kontekstu wdrażania dla aplikacji i można zdefiniować więcej niż jeden. Jest ona również używana w nazwie grupy zasobów utworzonej na platformie Azure.

2. Utwórz plik o nazwie local.settings.json w folderze głównym zawierającym następujące dane JSON:

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

   Ten plik jest wymagany podczas uruchamiania lokalnego.

1. W lokalnym terminalu lub wierszu polecenia uruchom to azd init polecenie w pustym folderze:

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

   To polecenie ściąga pliki projektu z repozytorium szablonów i inicjuje projekt w folderze głównym. Flaga -e ustawia nazwę bieżącego środowiska. W azdsystemie środowisko jest używane do obsługi unikatowego kontekstu wdrażania dla aplikacji i można zdefiniować więcej niż jeden. Jest ona również używana w nazwie grupy zasobów utworzonej na platformie Azure.

2. Utwórz plik o nazwie local.settings.json w folderze głównym zawierającym następujące dane JSON:

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

   Ten plik jest wymagany podczas uruchamiania lokalnego.

Tworzenie i aktywowanie środowiska wirtualnego

W folderze głównym uruchom następujące polecenia, aby utworzyć i aktywować środowisko wirtualne o nazwie .venv:

Linux/macOS

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

Jeśli język Python nie zainstalował pakietu venv w dystrybucji systemu Linux, uruchom następujące polecenie:

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

Uruchamianie w środowisku lokalnym

1. Uruchom to polecenie z folderu aplikacji w terminalu lub wierszu polecenia:

   func start
   

   mvn clean package
   mvn azure-functions:run
   

   npm install
   func start  
   

   npm install
   npm start  
   

   Po uruchomieniu hosta usługi Functions w lokalnym folderze projektu zapisuje on punkty końcowe adresu URL funkcji wyzwalanych przez protokół HTTP do danych wyjściowych terminalu.

2. W przeglądarce przejdź do punktu końcowego httpget , który powinien wyglądać następująco:

   http://localhost:7071/api/httpget

3. W nowym oknie terminalu lub wiersza polecenia uruchom to curl polecenie, aby wysłać żądanie POST z ładunkiem JSON do punktu końcowego httppost :

   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"
   

   To polecenie odczytuje dane ładunku testdata.json JSON z pliku projektu. Przykłady obu żądań HTTP można znaleźć w test.http pliku projektu.

4. Po zakończeniu naciśnij Ctrl+C w oknie terminalu func.exe , aby zatrzymać proces hosta.

5. Uruchom polecenie deactivate , aby zamknąć środowisko wirtualne.

Przejrzyj kod (opcjonalnie)

Możesz przejrzeć kod definiujący dwa punkty końcowe funkcji wyzwalacza HTTP:

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

Ten function.json plik definiuje httpget funkcję:

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

Ten run.ps1 plik implementuje kod funkcji:

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

Ten function.json plik definiuje httppost funkcję:

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

Ten run.ps1 plik implementuje kod funkcji:

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
        )

Pełny projekt szablonu można przejrzeć tutaj.

Pełny projekt szablonu można przejrzeć tutaj.

Pełny projekt szablonu można przejrzeć tutaj.

Pełny projekt szablonu można przejrzeć tutaj.

Pełny projekt szablonu można przejrzeć tutaj.

Pełny projekt szablonu można przejrzeć tutaj.

Po zweryfikowaniu funkcji lokalnie nadszedł czas, aby opublikować je na platformie Azure.

Tworzenie zasobów platformy Azure

Ten projekt jest skonfigurowany do używania azd provision polecenia w celu utworzenia aplikacji funkcji w planie Flex Consumption wraz z innymi wymaganymi zasobami platformy Azure.

Uwaga

Ten projekt zawiera zestaw plików Bicep używanych azd do tworzenia bezpiecznego wdrożenia w planie zużycia Flex, który jest zgodny z najlepszymi rozwiązaniami.

Polecenia azd up i azd deploy nie są obecnie obsługiwane w przypadku aplikacji Java.

1. W folderze głównym projektu uruchom następujące polecenie, aby utworzyć wymagane zasoby platformy Azure:

   azd provision
   

   Folder główny zawiera azure.yaml plik definicji wymagany przez azdprogram .

   Jeśli jeszcze nie zalogowano się, zostanie wyświetlony monit o uwierzytelnienie przy użyciu konta platformy Azure.

2. Po wyświetleniu monitu podaj następujące wymagane parametry wdrożenia:

   Parametr	Opis
   Subskrypcja platformy Azure	Subskrypcja, w której są tworzone zasoby.
   Lokalizacja platformy Azure	Region platformy Azure, w którym ma zostać utworzona grupa zasobów zawierająca nowe zasoby platformy Azure. Wyświetlane są tylko regiony, które obecnie obsługują plan Flex Consumption.

   Polecenie azd provision używa odpowiedzi na te monity z plikami konfiguracji Bicep w celu utworzenia i skonfigurowania tych wymaganych zasobów platformy Azure:

   • Flex Consumption plan i aplikacja funkcji
   • Azure Storage (wymagane) i Application Insights (zalecane)
   • Zasady dostępu i role dla twojego konta
   • Połączenia między usługami przy użyciu tożsamości zarządzanych (zamiast przechowywanych parametry połączenia)
   • Sieć wirtualna do bezpiecznego uruchamiania aplikacji funkcji i innych zasobów platformy Azure

   Po pomyślnym zakończeniu polecenia możesz wdrożyć kod projektu w tej nowej aplikacji funkcji na platformie Azure.

Wdróż na platformie Azure

Za pomocą narzędzi Core Tools możesz spakować kod i wdrożyć go na platformie Azure z folderu wyjściowego target .

1. Przejdź do folderu aplikacji równoważnego w folderze wyjściowym target :

   cd http/target/azure-functions/contoso-functions
   

   Ten folder powinien mieć plik host.json, który wskazuje, że jest to katalog główny skompilowanej aplikacji funkcji Java.

2. Uruchom następujące polecenia, aby wdrożyć skompilowany projekt kodu Java w nowym zasobie aplikacji funkcji na platformie Azure przy użyciu narzędzi Core Tools:

   Bash

   APP_NAME=$(azd env get-value AZURE_FUNCTION_NAME)
   func azure functionapp publish $APP_NAME
   

   Cmd

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

   Polecenie azd env get-value pobiera nazwę aplikacji funkcji ze środowiska lokalnego, które jest wymagane do wdrożenia przy użyciu polecenia func azure functionapp publish. Po pomyślnym zakończeniu publikowania zobaczysz linki do punktów końcowych wyzwalacza HTTP na platformie Azure.

Wdróż na platformie Azure

Ten projekt jest skonfigurowany do użycia azd up polecenia w celu wdrożenia tego projektu w nowej aplikacji funkcji w planie Flex Consumption na platformie Azure.

Napiwek

Ten projekt zawiera zestaw plików Bicep używanych azd do tworzenia bezpiecznego wdrożenia w planie zużycia Flex, który jest zgodny z najlepszymi rozwiązaniami.

1. Uruchom to polecenie, aby azd utworzyć wymagane zasoby platformy Azure na platformie Azure i wdrożyć projekt kodu w nowej aplikacji funkcji:

   azd up
   

   Folder główny zawiera azure.yaml plik definicji wymagany przez azdprogram .

   Jeśli jeszcze nie zalogowano się, zostanie wyświetlony monit o uwierzytelnienie przy użyciu konta platformy Azure.

2. Po wyświetleniu monitu podaj następujące wymagane parametry wdrożenia:

   Parametr	Opis
   Subskrypcja platformy Azure	Subskrypcja, w której są tworzone zasoby.
   Lokalizacja platformy Azure	Region platformy Azure, w którym ma zostać utworzona grupa zasobów zawierająca nowe zasoby platformy Azure. Wyświetlane są tylko regiony, które obecnie obsługują plan Flex Consumption.

   Polecenie azd up używa odpowiedzi na te monity z plikami konfiguracji Bicep, aby wykonać następujące zadania wdrażania:

   • Utwórz i skonfiguruj te wymagane zasoby platformy Azure (równoważne ):azd provision

     • Flex Consumption plan i aplikacja funkcji
     • Azure Storage (wymagane) i Application Insights (zalecane)
     • Zasady dostępu i role dla twojego konta
     • Połączenia między usługami przy użyciu tożsamości zarządzanych (zamiast przechowywanych parametry połączenia)
     • Sieć wirtualna do bezpiecznego uruchamiania aplikacji funkcji i innych zasobów platformy Azure

   • Spakuj i wdróż kod w kontenerze wdrażania (odpowiednik azd deploy). Aplikacja jest następnie uruchamiana i uruchamiana w wdrożonym pakiecie.

   Po pomyślnym zakończeniu działania polecenia zobaczysz linki do utworzonych zasobów.

Wywoływanie funkcji na platformie Azure

Teraz możesz wywołać punkty końcowe funkcji na platformie Azure, wysyłając żądania HTTP do ich adresów URL przy użyciu narzędzia testowego HTTP lub z przeglądarki (w przypadku żądań GET). Po uruchomieniu funkcji na platformie Azure wymuszana jest autoryzacja klucza dostępu i musisz podać klucz dostępu funkcji wraz z żądaniem.

Aby uzyskać punkty końcowe adresów URL funkcji działających na platformie Azure, możesz użyć narzędzi Core Tools.

1. W lokalnym terminalu lub wierszu polecenia uruchom następujące polecenia, aby uzyskać wartości punktu końcowego adresu URL:

   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 
   

   Program 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 
   

   Polecenie azd env get-value pobiera nazwę aplikacji funkcji ze środowiska lokalnego. Użycie opcji z opcją --show-keys func azure functionapp list-functions oznacza, że zwrócony adres URL wywołania: wartość dla każdego punktu końcowego zawiera klucz dostępu na poziomie funkcji.

2. Tak jak wcześniej użyj narzędzia testowego HTTP, aby zweryfikować te adresy URL w aplikacji funkcji uruchomionej na platformie Azure.

Ponowne wdrażanie kodu

Możesz uruchomić azd up polecenie tyle razy, ile potrzebujesz aprowizować zasoby platformy Azure i wdrażać aktualizacje kodu w aplikacji funkcji.

Uwaga

Wdrożone pliki kodu są zawsze zastępowane przez najnowszy pakiet wdrożeniowy.

Początkowe odpowiedzi na azd monity i wszystkie zmienne środowiskowe wygenerowane przez azd program są przechowywane lokalnie w nazwanym środowisku. Użyj polecenia , azd env get-values aby przejrzeć wszystkie zmienne w środowisku, które zostały użyte podczas tworzenia zasobów platformy Azure.

Czyszczenie zasobów

Po zakończeniu pracy z aplikacją funkcji i powiązanymi zasobami możesz użyć tego polecenia, aby usunąć aplikację funkcji i powiązane z nią zasoby z platformy Azure i uniknąć ponoszenia dodatkowych kosztów:

azd down --no-prompt

Uwaga

Opcja --no-prompt powoduje azd usunięcie grupy zasobów bez potwierdzenia.

To polecenie nie ma wpływu na lokalny projekt kodu.

Powiązana zawartość

• Plan Flex Consumption
• Azure Developer CLI (azd)
• azd — odwołanie
• Dokumentacja podstawowych narzędzi usługi Azure Functions
• Kodowanie i testowanie usługi Azure Functions lokalnie