Rychlý start: Vytvoření škálovatelného webového rozhraní API pomocí Azure Functions

V tomto rychlém startu použijete nástroje příkazového řádku Azure Developer k vytvoření škálovatelného webového rozhraní API s koncovými body funkcí, které reagují na požadavky HTTP. Po místním otestování kódu ho nasadíte do nové aplikace funkcí bez serveru, kterou vytvoříte v plánu Flex Consumption ve službě Azure Functions.

Zdroj projektu používá Azure Developer CLI (azd) ke zjednodušení nasazení kódu do Azure. Toto nasazení se řídí aktuálními osvědčenými postupy pro zabezpečená a škálovatelná nasazení Azure Functions.

Ve výchozím nastavení se plán Flex Consumption řídí fakturačním modelem platíš za to, co používáš, což znamená, že dokončení tohoto rychlého průvodce způsobuje malé náklady ve výši několika centů USD nebo méně na vašem účtu Azure.

Prerequisites

• Účet Azure s aktivním předplatným. Vytvoření účtu zdarma

• Azure Developer CLI

• Azure Functions Core Tools

• Sada .NET 8.0 SDK

• Emulátor úložiště Azurite

• Java 17 Developer Kit
  • Pokud používáte jinou podporovanou verzi Javy, musíte aktualizovat soubor pom.xml projektu.
  • Proměnná JAVA_HOME prostředí musí být nastavená na umístění instalace správné verze sady Java Development Kit (JDK).
• Apache Maven 3.8.x

• Node.js 20

• PowerShell 7.2

• Sada .NET 6.0 SDK

• Python 3.11

• Emulátor úložiště Azurite

• Zabezpečený testovací nástroj HTTP pro odesílání požadavků s datovými částmi JSON do koncových bodů funkce. Tento článek používá curl.

Inicializace projektu

azd init Pomocí příkazu vytvořte místní projekt kódu Azure Functions ze šablony.

1. V místním terminálu nebo příkazovém řádku spusťte tento azd init příkaz v prázdné složce:

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

   Tento příkaz načte soubory projektu z úložiště šablony a inicializuje projekt v aktuální složce. Příznak -e nastaví název aktuálního prostředí. V azdprostředí udržuje jedinečný kontext nasazení pro vaši aplikaci a můžete definovat více než jeden. Používá se také v názvu skupiny prostředků, kterou vytvoříte v Azure.

2. Spuštěním tohoto příkazu přejděte do http složky aplikace:

   cd http
   

3. Ve složce, která obsahuje tato data JSON, vytvořte soubor s názvem local.settings.jsonhttp :

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

   Tento soubor se vyžaduje při místním spuštění.

1. V místním terminálu nebo příkazovém řádku spusťte tento azd init příkaz v prázdné složce:

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

   Tento příkaz načte soubory projektu z úložiště šablony a inicializuje projekt v aktuální složce. Příznak -e nastaví název aktuálního prostředí. V azdprostředí udržuje jedinečný kontext nasazení pro vaši aplikaci a můžete definovat více než jeden. Používá se také v názvu skupiny prostředků, kterou vytvoříte v Azure.

2. Spuštěním tohoto příkazu přejděte do http složky aplikace:

   cd http
   

3. Ve složce, která obsahuje tato data JSON, vytvořte soubor s názvem local.settings.jsonhttp :

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

   Tento soubor se vyžaduje při místním spuštění.

1. V místním terminálu nebo příkazovém řádku spusťte tento azd init příkaz v prázdné složce:

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

   Tento příkaz načte soubory projektu z úložiště šablon a inicializuje projekt v kořenové složce. Příznak -e nastaví název aktuálního prostředí. V azdprostředí udržuje jedinečný kontext nasazení pro vaši aplikaci a můžete definovat více než jeden. Používá se také v názvu skupiny prostředků, kterou vytvoříte v Azure.

2. V kořenové složce vytvořte soubor s názvem local.settings.json , který obsahuje tato data JSON:

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

   Tento soubor se vyžaduje při místním spuštění.

1. V místním terminálu nebo příkazovém řádku spusťte tento azd init příkaz v prázdné složce:

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

   Tento příkaz načte soubory projektu z úložiště šablon a inicializuje projekt v kořenové složce. Příznak -e nastaví název aktuálního prostředí. V azdprostředí udržuje jedinečný kontext nasazení pro vaši aplikaci a můžete definovat více než jeden. Používá se také v názvu skupiny prostředků, kterou vytvoříte v Azure.

2. Spuštěním tohoto příkazu přejděte do src složky aplikace:

   cd src
   

3. Ve složce, která obsahuje tato data JSON, vytvořte soubor s názvem local.settings.jsonsrc :

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

   Tento soubor se vyžaduje při místním spuštění.

1. V místním terminálu nebo příkazovém řádku spusťte tento azd init příkaz v prázdné složce:

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

   Tento příkaz načte soubory projektu z úložiště šablon a inicializuje projekt v kořenové složce. Příznak -e nastaví název aktuálního prostředí. V azdprostředí udržuje jedinečný kontext nasazení pro vaši aplikaci a můžete definovat více než jeden. Název prostředí se používá také v názvu skupiny prostředků, kterou vytvoříte v Azure.

2. V kořenové složce vytvořte soubor s názvem local.settings.json , který obsahuje tato data JSON:

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

   Tento soubor se vyžaduje při místním spuštění.

1. V místním terminálu nebo příkazovém řádku spusťte tento azd init příkaz v prázdné složce:

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

   Tento příkaz načte soubory projektu z úložiště šablon a inicializuje projekt v kořenové složce. Příznak -e nastaví název aktuálního prostředí. V azdprostředí udržuje jedinečný kontext nasazení pro vaši aplikaci a můžete definovat více než jeden. Název prostředí se používá také v názvu skupiny prostředků, kterou vytvoříte v Azure.

2. V kořenové složce vytvořte soubor s názvem local.settings.json , který obsahuje tato data JSON:

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

   Tento soubor se vyžaduje při místním spuštění.

Vytvoření a aktivace virtuálního prostředí

Spuštěním těchto příkazů v kořenové složce vytvořte a aktivujte virtuální prostředí s názvem .venv:

Linux/macOS

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

Pokud Python neinstaluje balíček venv do distribuce Linuxu, spusťte následující příkaz:

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

Spuštění v místním prostředí

1. Spusťte tento příkaz ze složky aplikace v terminálu nebo na příkazovém řádku:

   func start
   

   mvn clean package
   mvn azure-functions:run
   

   npm install
   func start  
   

   npm install
   npm start  
   

   Když se hostitel Functions spustí ve složce místního projektu, zapíše koncové body adresy URL funkcí aktivovaných protokolem HTTP do výstupu terminálu.

   Note

   Protože se autorizace přístupového klíče nevynucuje při místním spuštění, vrácená adresa URL funkce neobsahuje hodnotu přístupového klíče a k volání funkce ji nepotřebujete.

2. V prohlížeči přejděte na httpget koncový bod, který by měl vypadat jako tato adresa URL:

   http://localhost:7071/api/httpget

3. V novém okně terminálu nebo příkazového řádku spusťte tento curl příkaz, kterým odešlete požadavek POST s datovou částí JSON do koncového httppost bodu:

   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"
   

   Tento příkaz načte data datové části JSON ze testdata.json souboru projektu. Příklady obou požadavků HTTP najdete v test.http souboru projektu.

4. Až budete hotovi, ukončete proces hostitele stisknutím ctrl+C v okně func.exe terminálu.

5. Spuštěním deactivate ukončete virtuální prostředí.

Kontrola kódu (volitelné)

Můžete si projít kód, který definuje dva koncové body funkce triggeru 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
});

Tento function.json soubor definuje httpget funkci:

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

Tento run.ps1 soubor implementuje kód funkce:

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

Tento function.json soubor definuje httppost funkci:

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

Tento run.ps1 soubor implementuje kód funkce:

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
        )

Tady si můžete projít kompletní projekt šablony.

Tady si můžete projít kompletní projekt šablony.

Tady si můžete projít kompletní projekt šablony.

Tady si můžete projít kompletní projekt šablony.

Tady si můžete projít kompletní projekt šablony.

Tady si můžete projít kompletní projekt šablony.

Po místním ověření funkcí je čas je publikovat do Azure.

Nasazení do Azure

Tento projekt je nakonfigurovaný tak, aby pomocí azd up příkazu nasadil tento projekt do nové aplikace funkcí v plánu Flex Consumption v Azure.

Tip

Projekt obsahuje jednu sadu souborů Bicep (ve infra složce), které se používají k vytvoření zabezpečeného nasazení do plánu Flex spotřeby, který azd dodržuje osvědčené postupy.

1. Spuštěním tohoto příkazu vytvořte azd požadované prostředky Azure v Azure a nasaďte projekt kódu do nové aplikace funkcí:

   azd up
   

   Kořenová složka obsahuje azure.yaml definiční soubor vyžadovaný azd.

   Pokud ještě nejste přihlášení, zobrazí se výzva k ověření pomocí účtu Azure.

2. Po zobrazení výzvy zadejte tyto požadované parametry nasazení:

   Parameter	Description
   Předplatné Azure	Předplatné, ve kterém se vaše prostředky vytvářejí.
   Umístění Azure	Oblast Azure, ve které se má vytvořit skupina prostředků, která obsahuje nové prostředky Azure. Zobrazí se pouze oblasti, které aktuálně podporují plán Flex Consumption.
   vnetEnabled	Zvolte False. Pokud nastavíte na hodnotu True, nasazení vytvoří vaši funkční aplikaci v nové virtuální síti.

   Příkaz azd up využívá vaše odpovědi na tyto výzvy spolu s konfiguračními soubory Bicep k dokončení následujících úkolů nasazení:

   • Vytvořte a nakonfigurujte tyto požadované prostředky Azure (ekvivalentní azd provision):

     • Plán Flex Consumption a aplikace funkcí
     • Azure Storage (povinné) a Application Insights (doporučeno)
     • Zásady přístupu a role pro váš účet
     • Připojení mezi službami pomocí spravovaných identit (místo uložených připojovací řetězec)
     • (Možnost) Virtuální síť pro bezpečné spuštění aplikace funkcí i dalších prostředků Azure

   • Zabalte a nasaďte kód do kontejneru nasazení (ekvivalentní).azd deploy Aplikace se pak spustí a spustí v nasazeném balíčku.

   Po úspěšném dokončení příkazu se zobrazí odkazy na prostředky, které jste vytvořili.

Vyvolání funkce v Azure

Koncové body funkcí v Azure teď můžete vyvolat tak, že na jejich adresy URL odešlete požadavky HTTP pomocí testovacího nástroje HTTP nebo z prohlížeče (pro požadavky GET). Při spuštění funkcí v Azure se vynucuje autorizace přístupového klíče a vy musíte zadat přístupový klíč funkce s vaším požadavkem.

Pomocí nástrojů Core Tools můžete získat koncové body adresy URL vašich funkcí spuštěných v Azure.

1. V místním terminálu nebo příkazovém řádku spusťte tyto příkazy, abyste získali hodnoty koncového bodu adresy 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 
   

   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 
   

   Příkaz azd env get-value získá název aplikace funkcí z místního prostředí. Při použití možnosti --show-keys s func azure functionapp list-functions je vrácená hodnota adresy URL vyvolání: pro každý koncový bod obsahuje přístupový klíč na úrovni funkce.

2. Stejně jako předtím pomocí testovacího nástroje HTTP ověřte tyto adresy URL ve vaší aplikaci funkcí spuštěné v Azure.

Opětovné nasazení kódu

azd up Spusťte příkaz tolikrát, kolikrát potřebujete zřizovat prostředky Azure a nasazovat aktualizace kódu do aplikace funkcí.

Note

Nasazené soubory kódu se vždy přepíšou nejnovějším balíčkem pro nasazení.

Vaše počáteční odpovědi na azd výzvy a všechny proměnné prostředí vygenerované azd pomocí se ukládají místně ve vašem pojmenovaném prostředí. azd env get-values Pomocí příkazu zkontrolujte všechny proměnné ve vašem prostředí, které jste použili při vytváření prostředků Azure.

Vyčištění prostředků

Po dokončení práce s aplikací funkcí a souvisejícími prostředky pomocí tohoto příkazu odstraňte aplikaci funkcí a související prostředky z Azure a vyhněte se dalším nákladům:

azd down --no-prompt

Note

Tato --no-prompt možnost dává azd pokyn k odstranění skupiny prostředků bez potvrzení od vás.

Tento příkaz nemá vliv na místní projekt kódu.

Související obsah

• Scénáře Azure Functions
• Plán Flex Consumption
• Azure Developer CLI (azd)
• azd – referenční dokumentace
• Referenční informace ke službě Azure Functions Core Tools
• Místní psaní kódu a testování funkcí Azure Functions