Quickstart: Een schaalbare web-API bouwen met behulp van Azure Functions

In deze quickstart gebruikt u opdrachtregelprogramma's van Azure Developer om een schaalbare web-API te bouwen met functie-eindpunten die reageren op HTTP-aanvragen. Nadat u de code lokaal hebt getest, implementeert u deze in een nieuwe serverloze functie-app die u maakt in een Flex Consumption-abonnement in Azure Functions.

De projectbron maakt gebruik van de Azure Developer CLI (azd) om de implementatie van uw code in Azure te vereenvoudigen. Deze implementatie volgt de huidige aanbevolen procedures voor veilige en schaalbare Azure Functions-implementaties.

Het Flex Consumption-abonnement volgt standaard een factureringsmodel met betalen voor wat u gebruikt . Dit betekent dat voor het voltooien van deze quickstart een kleine kosten van een paar cent of minder in uw Azure-account in rekening worden gebracht.

Prerequisites

Een Azure-account met een actief abonnement. Gratis een account maken
Azure Developer CLI
Azure Functions Core Tools

Java 17 Developer Kit
- Als u een andere ondersteunde versie van Java gebruikt, moet u het pom.xml-bestand van het project bijwerken.
- De JAVA_HOME omgevingsvariabele moet worden ingesteld op de installatielocatie van de juiste versie van de Java Development Kit (JDK).
Apache Maven 3.8.x

Node.js 20

Een beveiligd HTTP-testprogramma voor het verzenden van aanvragen met JSON-nettoladingen naar uw functie-eindpunten. In dit artikel wordt gebruikgemaakt van curl.

Het project initialiseren

Gebruik de azd init opdracht om een lokaal Azure Functions-codeproject te maken op basis van een sjabloon.

Voer in uw lokale terminal of opdrachtprompt deze azd init opdracht uit in een lege map:
```
azd init --template functions-quickstart-dotnet-azd -e httpendpoint-dotnet
```
Met deze opdracht worden de projectbestanden opgehaald uit de sjabloonopslagplaats en wordt het project in de huidige map geïnitialiseerd. Met -e de vlag wordt een naam ingesteld voor de huidige omgeving. In azdde omgeving wordt een unieke implementatiecontext voor uw app onderhouden en kunt u meer dan één definiëren. Deze wordt ook gebruikt in de naam van de resourcegroep die u in Azure maakt.
Voer deze opdracht uit om naar de http app-map te navigeren:
```
cd http
```

Maak een bestand met de naam local.settings.json in de http map die deze JSON-gegevens bevat:

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

Dit bestand is vereist wanneer het lokaal wordt uitgevoerd.

Voer in uw lokale terminal of opdrachtprompt deze azd init opdracht uit in een lege map:
```
azd init --template azure-functions-java-flex-consumption-azd -e httpendpoint-java 
```
Met deze opdracht worden de projectbestanden opgehaald uit de sjabloonopslagplaats en wordt het project in de huidige map geïnitialiseerd. Met -e de vlag wordt een naam ingesteld voor de huidige omgeving. In azdde omgeving wordt een unieke implementatiecontext voor uw app onderhouden en kunt u meer dan één definiëren. Deze wordt ook gebruikt in de naam van de resourcegroep die u in Azure maakt.
Voer deze opdracht uit om naar de http app-map te navigeren:
```
cd http
```

Maak een bestand met de naam local.settings.json in de http map die deze JSON-gegevens bevat:

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

Dit bestand is vereist wanneer het lokaal wordt uitgevoerd.

Voer in uw lokale terminal of opdrachtprompt deze azd init opdracht uit in een lege map:
```
azd init --template functions-quickstart-javascript-azd -e httpendpoint-js
```
Met deze opdracht worden de projectbestanden opgehaald uit de sjabloonopslagplaats en wordt het project geïnitialiseerd in de hoofdmap. Met -e de vlag wordt een naam ingesteld voor de huidige omgeving. In azdde omgeving wordt een unieke implementatiecontext voor uw app onderhouden en kunt u meer dan één definiëren. Deze wordt ook gebruikt in de naam van de resourcegroep die u in Azure maakt.

Maak een bestand met de naam local.settings.json in de hoofdmap die deze JSON-gegevens bevat:

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

Dit bestand is vereist wanneer het lokaal wordt uitgevoerd.

Voer in uw lokale terminal of opdrachtprompt deze azd init opdracht uit in een lege map:
```
azd init --template functions-quickstart-powershell-azd -e httpendpoint-ps
```
Met deze opdracht worden de projectbestanden opgehaald uit de sjabloonopslagplaats en wordt het project geïnitialiseerd in de hoofdmap. Met -e de vlag wordt een naam ingesteld voor de huidige omgeving. In azdde omgeving wordt een unieke implementatiecontext voor uw app onderhouden en kunt u meer dan één definiëren. Deze wordt ook gebruikt in de naam van de resourcegroep die u in Azure maakt.
Voer deze opdracht uit om naar de src app-map te navigeren:
```
cd src
```

Maak een bestand met de naam local.settings.json in de src map die deze JSON-gegevens bevat:

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

Dit bestand is vereist wanneer het lokaal wordt uitgevoerd.

Voer in uw lokale terminal of opdrachtprompt deze azd init opdracht uit in een lege map:
```
azd init --template functions-quickstart-typescript-azd -e httpendpoint-ts
```
Met deze opdracht worden de projectbestanden opgehaald uit de sjabloonopslagplaats en wordt het project geïnitialiseerd in de hoofdmap. Met -e de vlag wordt een naam ingesteld voor de huidige omgeving. In azdde omgeving wordt een unieke implementatiecontext voor uw app onderhouden en kunt u meer dan één definiëren. De omgevingsnaam wordt ook gebruikt in de naam van de resourcegroep die u in Azure maakt.

Maak een bestand met de naam local.settings.json in de hoofdmap die deze JSON-gegevens bevat:

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

Dit bestand is vereist wanneer het lokaal wordt uitgevoerd.

Voer in uw lokale terminal of opdrachtprompt deze azd init opdracht uit in een lege map:
```
azd init --template functions-quickstart-python-http-azd -e httpendpoint-py
```
Met deze opdracht worden de projectbestanden opgehaald uit de sjabloonopslagplaats en wordt het project geïnitialiseerd in de hoofdmap. Met -e de vlag wordt een naam ingesteld voor de huidige omgeving. In azdde omgeving wordt een unieke implementatiecontext voor uw app onderhouden en kunt u meer dan één definiëren. De omgevingsnaam wordt ook gebruikt in de naam van de resourcegroep die u in Azure maakt.

Maak een bestand met de naam local.settings.json in de hoofdmap die deze JSON-gegevens bevat:

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

Dit bestand is vereist wanneer het lokaal wordt uitgevoerd.

Een virtuele omgeving maken en activeren

Voer in de hoofdmap deze opdrachten uit om een virtuele omgeving met de naam .venv:

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

Als Python het venv-pakket niet installeert in uw Linux-distributie, voert u de volgende opdracht uit:

sudo apt-get install python3-venv

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

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

Uitvoeren in uw lokale omgeving

Voer deze opdracht uit vanuit uw app-map in een terminal of opdrachtprompt:
```
func start
```
```
mvn clean package
mvn azure-functions:run
```
```
npm install
func start  
```
```
npm install
npm start  
```
Wanneer de Functions-host in uw lokale projectmap wordt gestart, worden de URL-eindpunten van uw door HTTP geactiveerde functies naar de terminaluitvoer geschreven.

Note

Omdat autorisatie van toegangssleutels niet wordt afgedwongen wanneer deze lokaal wordt uitgevoerd, bevat de geretourneerde functie-URL niet de waarde van de toegangssleutel en hoeft u de functie niet aan te roepen.
Ga in uw browser naar het httpget eindpunt, dat eruit moet zien als deze URL:

http://localhost:7071/api/httpget
Voer vanuit een nieuw terminal- of opdrachtpromptvenster deze curl opdracht uit om een POST-aanvraag met een JSON-nettolading naar het httppost eindpunt te verzenden:
```
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"
```
Met deze opdracht worden JSON-nettoladinggegevens uit het testdata.json projectbestand gelezen. U vindt voorbeelden van beide HTTP-aanvragen in het test.http projectbestand.
Wanneer u klaar bent, drukt u op Ctrl+C in het terminalvenster om het func.exe hostproces te stoppen.

Voer deactivate uit om de virtuele omgeving af te sluiten.

De code bekijken (optioneel)

U kunt de code controleren waarmee de twee HTTP-triggerfunctieeindpunten worden gedefinieerd:

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

Dit function.json bestand definieert de httpget functie:

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

Met dit run.ps1 bestand wordt de functiecode geïmplementeerd:

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

Dit function.json bestand definieert de httppost functie:

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

Met dit run.ps1 bestand wordt de functiecode geïmplementeerd:

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
        )

U kunt hier het volledige sjabloonproject bekijken.

U kunt hier het volledige sjabloonproject bekijken.

U kunt hier het volledige sjabloonproject bekijken.

U kunt hier het volledige sjabloonproject bekijken.

U kunt hier het volledige sjabloonproject bekijken.

U kunt hier het volledige sjabloonproject bekijken.

Nadat u uw functies lokaal hebt gecontroleerd, is het tijd om ze te publiceren naar Azure.

Implementeren op Azure

Dit project is geconfigureerd om de azd up opdracht te gebruiken om dit project te implementeren in een nieuwe functie-app in een Flex Consumption-abonnement in Azure.

Tip

Het project bevat een set Bicep-bestanden (in de infra directory) die azd gebruikt om een veilige implementatie te realiseren voor een Flex-verbruiksplan dat de aanbevolen procedures volgt.

Voer deze opdracht uit om de vereiste Azure-resources in Azure te maken azd en uw codeproject te implementeren in de nieuwe functie-app:
```
azd up
```
De hoofdmap bevat het azure.yaml definitiebestand dat vereist is voor azd.

Als u nog niet bent aangemeld, wordt u gevraagd om u te verifiëren met uw Azure-account.

Geef de volgende vereiste implementatieparameters op wanneer u hierom wordt gevraagd:

Parameter	Description
Azure-abonnement	Abonnement waarin uw resources worden gemaakt.
Azure-locatie	Azure-regio waarin de resourcegroep wordt gemaakt die de nieuwe Azure-resources bevat. Alleen regio's die momenteel ondersteuning bieden voor het Flex Consumption-abonnement, worden weergegeven.
vnetEnabled	Kies Onwaar. Wanneer ingesteld op True, maakt de implementatie uw functie-app in een nieuw virtueel netwerk.

De azd up opdracht gebruikt uw antwoorden op deze prompts met de Bicep-configuratiebestanden om deze implementatietaken te voltooien:

Maak en configureer deze vereiste Azure-resources (equivalent aan azd provision):
- Flex Consumption-abonnement en functie-app
- Azure Storage (vereist) en Application Insights (aanbevolen)
- Toegangsbeleid en rollen voor uw account
- Service-naar-service-verbindingen met behulp van beheerde identiteiten (in plaats van opgeslagen verbindingsreeks s)
- (Optie) Virtueel netwerk om zowel de functie-app als de andere Azure-resources veilig uit te voeren
Verpakt en implementeer uw code in de implementatiecontainer (equivalent aan azd deploy). De app wordt vervolgens gestart en uitgevoerd in het geïmplementeerde pakket.

Nadat de opdracht is voltooid, ziet u koppelingen naar de resources die u hebt gemaakt.

De functie aanroepen in Azure

U kunt nu uw functie-eindpunten in Azure aanroepen door HTTP-aanvragen naar hun URL's te verzenden met behulp van uw HTTP-testhulpprogramma of vanuit de browser (voor GET-aanvragen). Wanneer uw functies worden uitgevoerd in Azure, wordt autorisatie van toegangssleutels afgedwongen en moet u een functietoegangssleutel opgeven bij uw aanvraag.

U kunt de Core Tools gebruiken om de URL-eindpunten van uw functies op te halen die worden uitgevoerd in Azure.

Voer in uw lokale terminal of opdrachtprompt deze opdrachten uit om de URL-eindpuntwaarden op te halen:

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

Met azd env get-value de opdracht wordt de naam van uw functie-app opgehaald uit de lokale omgeving. Wanneer u de --show-keys optie gebruikt, func azure functionapp list-functionsbevat de geretourneerde aanroep-URL: waarde voor elk eindpunt een toegangssleutel op functieniveau.

Net als voorheen gebruikt u uw HTTP-testhulpprogramma om deze URL's te valideren in uw functie-app die wordt uitgevoerd in Azure.

Uw code opnieuw implementeren

Voer de azd up opdracht zo vaak uit als nodig is om uw Azure-resources in te richten en code-updates te implementeren voor uw functie-app.

Note

Geïmplementeerde codebestanden worden altijd overschreven door het nieuwste implementatiepakket.

Uw eerste antwoorden op azd prompts en eventuele omgevingsvariabelen die worden azd gegenereerd, worden lokaal opgeslagen in uw benoemde omgeving. Gebruik de azd env get-values opdracht om alle variabelen in uw omgeving te controleren die u hebt gebruikt bij het maken van Azure-resources.

Resources opschonen

Wanneer u klaar bent met het werken met uw functie-app en gerelateerde resources, gebruikt u deze opdracht om de functie-app en de bijbehorende resources uit Azure te verwijderen en te voorkomen dat er verdere kosten in rekening worden gebracht:

azd down --no-prompt

Note

Met de --no-prompt optie krijgt u de opdracht azd om uw resourcegroep te verwijderen zonder een bevestiging van u.

Deze opdracht heeft geen invloed op uw lokale codeproject.

Feedback

Is deze pagina nuttig?

Last updated on 2025-12-04