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

2025-08-02

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

U kunt de azd init opdracht gebruiken 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 azdwordt de omgeving gebruikt om een unieke implementatiecontext voor uw app te 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 azdwordt de omgeving gebruikt om een unieke implementatiecontext voor uw app te 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 azdwordt de omgeving gebruikt om een unieke implementatiecontext voor uw app te 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 azdwordt de omgeving gebruikt om een unieke implementatiecontext voor uw app te 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 azdwordt de omgeving gebruikt om een unieke implementatiecontext voor uw app te 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-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 azdwordt de omgeving gebruikt om een unieke implementatiecontext voor uw app te 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": "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 heeft geïnstalleerd 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.
Navigeer 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.

Azure-resources maken

Dit project is geconfigureerd voor het gebruik van de opdracht voor het azd provision maken van een functie-app in een Flex Consumption-abonnement, samen met andere vereiste Azure-resources.

Note

Dit project bevat een set Bicep-bestanden die azd wordt gebruikt om een veilige implementatie te maken voor een Flex-verbruiksplan dat de aanbevolen procedures volgt.

De azd up en azd deploy opdrachten worden momenteel niet ondersteund voor Java-apps.

Voer in de hoofdmap van het project deze opdracht uit om de vereiste Azure-resources te maken:
```
azd provision
```
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.

De azd provision opdracht gebruikt uw reactie op deze prompts met de Bicep-configuratiebestanden om deze vereiste Azure-resources te maken en te configureren:

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)
Virtueel netwerk om zowel de functie-app als de andere Azure-resources veilig uit te voeren

Nadat de opdracht is voltooid, kunt u uw projectcode implementeren in deze nieuwe functie-app in Azure.

Implementeren op Azure

U kunt Core Tools gebruiken om uw code in te pakken en in Azure te implementeren vanuit de target uitvoermap.

Navigeer naar het equivalent van de app-map in de target uitvoermap:
```
cd http/target/azure-functions/contoso-functions
```
Deze map moet een host.json-bestand hebben, wat aangeeft dat het de hoofdmap is van uw gecompileerde Java-functie-app.
Voer deze opdrachten uit om uw gecompileerde Java-codeproject te implementeren in de nieuwe functie-app-resource in Azure met behulp van Core Tools:
- bash
- Cmd
```
APP_NAME=$(azd env get-value AZURE_FUNCTION_NAME)
func azure functionapp publish $APP_NAME
```
```
for /f "tokens=*" %i in ('azd env get-value AZURE_FUNCTION_NAME') do set APP_NAME=%i
func azure functionapp publish %APP_NAME% 
```
Met de azd env get-value opdracht wordt de naam van uw functie-app opgehaald uit de lokale omgeving, die vereist is voor implementatie met behulp van func azure functionapp publish. Nadat het publiceren is voltooid, ziet u koppelingen naar de HTTP-triggereindpunten in 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

Dit project bevat een set Bicep-bestanden die azd wordt gebruikt om een veilige implementatie te maken 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.

De azd up opdracht gebruikt uw reactie 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)
- 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 te verkrijgen van uw functies 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. Als u de --show-keys optie gebruikt, betekent func azure functionapp list-functions dit dat de geretourneerde aanroep-URL: waarde voor elk eindpunt een toegangssleutel op functieniveau bevat.

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

U kunt de azd up opdracht zo vaak uitvoeren als nodig is om uw Azure-resources in te richten en code-updates te implementeren in 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 zijn gebruikt bij het maken van Azure-resources.

Resources opschonen

Wanneer u klaar bent met het werken met uw functie-app en gerelateerde resources, kunt u deze opdracht gebruiken om de functie-app en de bijbehorende resources uit Azure te verwijderen en eventuele verdere kosten te voorkomen:

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?