Rövid útmutató: Méretezhető webes API létrehozása az Azure Functions használatával

Ebben a rövid útmutatóban az Azure Developer parancssori eszközeivel skálázható webes API-t hozhat létre a HTTP-kérelmekre reagáló függvényvégpontok használatával. A kód helyi tesztelése után üzembe helyezi azt egy új kiszolgáló nélküli függvényalkalmazásban, amelyet egy Flex Consumption-csomagban hoz létre az Azure Functionsben.

A projektforrás az Azure Developer CLI (azd) használatával egyszerűsíti a kód Azure-ban való üzembe helyezését. Ez az üzembe helyezés a biztonságos és méretezhető Azure Functions-környezetek jelenlegi ajánlott eljárásait követi.

Alapértelmezés szerint a Flex Consumption csomag egy használatalapú fizetéses számlázási modellt követ, ami azt jelenti, hogy ennek a rövid útmutatónak a végrehajtása néhány USD cent vagy annál kisebb költséggel jár az Azure-fiókjában.

Prerequisites

Egy Azure-fiók, aktív előfizetéssel. Fiók ingyenes létrehozása.
Azure Developer CLI
Azure Functions Core Tools

Java 17 Fejlesztői készlet
- Ha a Java egy másik támogatott verzióját használja, frissítenie kell a projekt pom.xml fájlját.
- A JAVA_HOME környezeti változót a Java Development Kit (JDK) megfelelő verziójának telepítési helyére kell állítani.
Apache Maven 3.8.x

Node.js 20

Biztonságos HTTP-teszteszköz , amellyel JSON-hasznos adatokkal küldhet kérelmeket a függvényvégpontoknak. Ez a cikk a .curl

A projekt inicializálása

azd init A parancs használatával helyi Azure Functions-kódprojektet hozhat létre egy sablonból.

A helyi terminálban vagy parancssorban futtassa ezt a azd init parancsot egy üres mappában:
```
azd init --template functions-quickstart-dotnet-azd -e httpendpoint-dotnet
```
Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet az aktuális mappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. Az Azure-ban létrehozott erőforráscsoport nevében is használatos.
Futtassa ezt a parancsot az http alkalmazásmappához való navigáláshoz:
```
cd http
```

Hozzon létre egy local.settings.json nevű fájlt a http JSON-adatokat tartalmazó mappában:

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

Ez a fájl helyi futtatáskor szükséges.

A helyi terminálban vagy parancssorban futtassa ezt a azd init parancsot egy üres mappában:
```
azd init --template azure-functions-java-flex-consumption-azd -e httpendpoint-java 
```
Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet az aktuális mappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. Az Azure-ban létrehozott erőforráscsoport nevében is használatos.
Futtassa ezt a parancsot az http alkalmazásmappához való navigáláshoz:
```
cd http
```

Hozzon létre egy local.settings.json nevű fájlt a http JSON-adatokat tartalmazó mappában:

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

Ez a fájl helyi futtatáskor szükséges.

A helyi terminálban vagy parancssorban futtassa ezt a azd init parancsot egy üres mappában:
```
azd init --template functions-quickstart-javascript-azd -e httpendpoint-js
```
Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet a gyökérmappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. Az Azure-ban létrehozott erőforráscsoport nevében is használatos.

Hozzon létre egy local.settings.json nevű fájlt a JSON-adatokat tartalmazó gyökérmappában:

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

Ez a fájl helyi futtatáskor szükséges.

A helyi terminálban vagy parancssorban futtassa ezt a azd init parancsot egy üres mappában:
```
azd init --template functions-quickstart-powershell-azd -e httpendpoint-ps
```
Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet a gyökérmappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. Az Azure-ban létrehozott erőforráscsoport nevében is használatos.
Futtassa ezt a parancsot az src alkalmazásmappához való navigáláshoz:
```
cd src
```

Hozzon létre egy local.settings.json nevű fájlt a src JSON-adatokat tartalmazó mappában:

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

Ez a fájl helyi futtatáskor szükséges.

A helyi terminálban vagy parancssorban futtassa ezt a azd init parancsot egy üres mappában:
```
azd init --template functions-quickstart-typescript-azd -e httpendpoint-ts
```
Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet a gyökérmappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. A környezet nevét az Azure-ban létrehozott erőforráscsoport nevében is használja a rendszer.

Hozzon létre egy local.settings.json nevű fájlt a JSON-adatokat tartalmazó gyökérmappában:

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

Ez a fájl helyi futtatáskor szükséges.

A helyi terminálban vagy parancssorban futtassa ezt a azd init parancsot egy üres mappában:
```
azd init --template functions-quickstart-python-http-azd -e httpendpoint-py
```
Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet a gyökérmappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. A környezet nevét az Azure-ban létrehozott erőforráscsoport nevében is használja a rendszer.

Hozzon létre egy local.settings.json nevű fájlt a JSON-adatokat tartalmazó gyökérmappában:

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

Ez a fájl helyi futtatáskor szükséges.

Virtuális környezet létrehozása és aktiválása

A gyökérmappában futtassa ezeket a parancsokat a következő nevű .venvvirtuális környezet létrehozásához és aktiválásához:

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

Ha a Python nem telepíti a venv-csomagot a Linux-disztribúcióra, futtassa a következő parancsot:

sudo apt-get install python3-venv

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

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

Futtatás a helyi környezetben

Futtassa ezt a parancsot az alkalmazásmappából egy terminálban vagy parancssorban:
```
func start
```
```
mvn clean package
mvn azure-functions:run
```
```
npm install
func start  
```
```
npm install
npm start  
```
Amikor a Functions-gazdagép elindul a helyi projektmappában, a HTTP által aktivált függvények URL-végpontjait írja a terminál kimenetére.

Note

Mivel a hozzáférési kulcs engedélyezése helyi futtatáskor nincs kényszerítve, a visszaadott függvény URL-címe nem tartalmazza a hozzáférési kulcs értékét, és nincs rá szüksége a függvény meghívásához.
A böngészőben lépjen a httpget végpontra, amelynek az alábbi URL-címhez hasonlóan kell kinéznie:

http://localhost:7071/api/httpget
Egy új terminál vagy parancssori ablakban futtassa ezt a curl parancsot egy JSON hasznos adattal rendelkező POST-kérés végpontra való httppost küldéséhez:
```
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"
```
Ez a parancs beolvassa a JSON hasznos adatait a testdata.json projektfájlból. Mindkét HTTP-kérésre találhat példákat a test.http projektfájlban.
Ha elkészült, a gazdafolyamat leállításához nyomja le a Ctrl+C billentyűkombinációt a func.exe terminálablakban.

Futtassa deactivate a virtuális környezet leállítását.

A kód áttekintése (nem kötelező)

Áttekintheti a két HTTP-eseményindító függvényvégpontot meghatározó kódot:

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

Ez a function.json fájl határozza meg a függvényt httpget :

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

Ez a run.ps1 fájl implementálja a függvénykódot:

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

Ez a function.json fájl határozza meg a függvényt httppost :

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

Ez a run.ps1 fájl implementálja a függvénykódot:

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
        )

A teljes sablonprojektet itt tekintheti át.

A teljes sablonprojektet itt tekintheti át.

A teljes sablonprojektet itt tekintheti át.

A teljes sablonprojektet itt tekintheti át.

A teljes sablonprojektet itt tekintheti át.

A teljes sablonprojektet itt tekintheti át.

Miután helyben ellenőrizte a függvényeket, ideje közzétenni őket az Azure-ban.

Üzembe helyezés az Azure-ban

Ez a projekt úgy van konfigurálva, hogy a parancs használatával telepítse ezt a azd up projektet egy új függvényalkalmazásban egy Rugalmas használatú csomagban az Azure-ban.

Tip

A projekt egy sor Bicep-fájlt tartalmaz (a infra mappában), amelyet azd arra használ, hogy az ajánlott eljárásokat követve biztonságos telepítést hozzon létre egy rugalmas fogyasztási tervben.

Futtassa ezt a parancsot, hogy azd létrehozza a szükséges Azure-erőforrásokat az Azure-ban, és üzembe helyezze a kódprojektet az új függvényalkalmazásban:
```
azd up
```
A gyökérmappa tartalmazza a azure.yaml szükséges definíciófájlt azd.

Ha még nem jelentkezett be, a rendszer arra kéri, hogy hitelesítse az Azure-fiókjával.

Amikor a rendszer kéri, adja meg a szükséges üzembehelyezési paramétereket:

Parameter	Description
Azure-előfizetés	Előfizetés, amelyben az erőforrások létrejönnek.
Azure-hely	Azure-régió, amelyben létre kell hozni az új Azure-erőforrásokat tartalmazó erőforráscsoportot. Csak azok a régiók jelennek meg, amelyek jelenleg támogatják a Rugalmas felhasználás csomagot.
vnetEnabled	Válassza a Hamis lehetőséget. Igaz értékre állítva az üzembe helyezés létrehozza a függvényalkalmazást egy új virtuális hálózaton.

A azd up parancs az alábbi kérdésekre adott válaszokat használja a Bicep konfigurációs fájljaival az üzembehelyezési feladatok elvégzéséhez:

Hozza létre és konfigurálja ezeket a szükséges Azure-erőforrásokat (a következőnek felel meg azd provision):
- Rugalmas kihasználtságú csomag és függvényalkalmazás
- Azure Storage (kötelező) és Application Insights (ajánlott)
- Hozzáférési szabályzatok és szerepkörök a fiókhoz
- Szolgáltatásközi kapcsolatok felügyelt identitásokkal (tárolt kapcsolati sztring helyett)
- (Beállítás) Virtuális hálózat a függvényalkalmazás és a többi Azure-erőforrás biztonságos futtatásához
Csomagolja és telepítse a kódot az üzembehelyezési tárolóba (ez egyenértékű a következőval azd deploy). Az alkalmazás ezután elindul, és az üzembe helyezett csomagban fut.

A parancs sikeres végrehajtása után megjelennek a létrehozott erőforrásokra mutató hivatkozások.

A függvény meghívása az Azure-ban

Mostantól meghívhatja a függvényvégpontokat az Azure-ban, ha HTTP-kéréseket küld az URL-címekre a HTTP-teszteszközzel vagy a böngészőből (GET-kérelmek esetén). Amikor a függvények az Azure-ban futnak, a hozzáférési kulcs engedélyezése kötelező, és a kéréshez meg kell adnia egy függvényhozzáférési kulcsot.

A Core Tools használatával lekérheti az Azure-ban futó függvények URL-végpontjait.

A helyi terminálban vagy parancssorban futtassa az alábbi parancsokat az URL-végpont értékeinek lekéréséhez:

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

A azd env get-value parancs lekéri a függvényalkalmazás nevét a helyi környezetből. Ha ezt a --show-keys lehetőséget func azure functionapp list-functionshasználja, a visszaadott meghívási URL-cím: az egyes végpontok értéke tartalmaz egy függvényszintű hozzáférési kulcsot.

A korábbiakhoz hasonlóan a HTTP-teszteszköz használatával ellenőrizze ezeket az URL-címeket az Azure-ban futó függvényalkalmazásban.

A kód ismételt üzembe helyezése

Futtassa a azd up parancsot annyiszor, amennyi szükséges az Azure-erőforrások kiépítéséhez és a kódfrissítések üzembe helyezéséhez a függvényalkalmazásban.

Note

Az üzembe helyezett kódfájlokat mindig felülírja a legújabb üzembehelyezési csomag.

A kérésekre adott kezdeti válaszokat azd és az általuk azd létrehozott környezeti változókat a rendszer helyileg tárolja a nevesített környezetben. azd env get-values A paranccsal áttekintheti a környezetben az Azure-erőforrások létrehozásakor használt összes változót.

Az erőforrások eltávolítása

Ha végzett a függvényalkalmazással és a kapcsolódó erőforrásokkal, ezzel a paranccsal törölheti a függvényalkalmazást és annak kapcsolódó erőforrásait az Azure-ból, és elkerülheti a további költségek felmerülését:

azd down --no-prompt

Note

A --no-prompt beállítás arra utasítja azd , hogy az erőforráscsoportot anélkül törölje, hogy ön megerősítést kap.

Ez a parancs nincs hatással a helyi kódprojektre.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-12-04