Snabbstart: Skapa ett skalbart webb-API med Hjälp av Azure Functions

2025-08-02

I den här snabbstarten använder du kommandoradsverktyg för Azure Developer för att skapa ett skalbart webb-API med funktionsslutpunkter som svarar på HTTP-begäranden. När du har testat koden lokalt distribuerar du den till en ny serverlös funktionsapp som du skapar som körs i en Flex Consumption-plan i Azure Functions.

Projektkällan använder Azure Developer CLI (azd) för att förenkla distributionen av din kod till Azure. Den här distributionen följer aktuella metodtips för säkra och skalbara Azure Functions-distributioner.

Som standard följer Flex Consumption-planen en faktureringsmodell för att betala för vad du använder , vilket innebär att den här snabbstarten medför en liten kostnad på några USD cent eller mindre i ditt Azure-konto.

Prerequisites

Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.
Azure Developer CLI
Azure Functions Core Tools

Java 17 Developer Kit
- Om du använder en annan version av Java som stöds måste du uppdatera projektets pom.xml fil.
- Miljövariabeln JAVA_HOME måste anges till installationsplatsen för rätt version av Java Development Kit (JDK).
Apache Maven 3.8.x

Node.js 20

Ett säkert HTTP-testverktyg för att skicka begäranden med JSON-nyttolaster till funktionsslutpunkterna. Den här artikeln använder curl.

Initiera projektet

Du kan använda azd init kommandot för att skapa ett lokalt Azure Functions-kodprojekt från en mall.

Kör det här azd init kommandot i en tom mapp i den lokala terminalen eller kommandotolken:
```
azd init --template functions-quickstart-dotnet-azd -e httpendpoint-dotnet
```
Det här kommandot hämtar projektfilerna från malllagringsplatsen och initierar projektet i den aktuella mappen. Flaggan -e anger ett namn för den aktuella miljön. I azdanvänds miljön för att upprätthålla en unik distributionskontext för din app och du kan definiera mer än en. Den används också i namnet på den resursgrupp som du skapar i Azure.
Kör det här kommandot för att navigera till appmappen http :
```
cd http
```

Skapa en fil med namnet local.settings.json i http mappen som innehåller dessa JSON-data:

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

Den här filen krävs när den körs lokalt.

Kör det här azd init kommandot i en tom mapp i den lokala terminalen eller kommandotolken:
```
azd init --template azure-functions-java-flex-consumption-azd -e httpendpoint-java 
```
Det här kommandot hämtar projektfilerna från malllagringsplatsen och initierar projektet i den aktuella mappen. Flaggan -e anger ett namn för den aktuella miljön. I azdanvänds miljön för att upprätthålla en unik distributionskontext för din app och du kan definiera mer än en. Den används också i namnet på den resursgrupp som du skapar i Azure.
Kör det här kommandot för att navigera till appmappen http :
```
cd http
```

Skapa en fil med namnet local.settings.json i http mappen som innehåller dessa JSON-data:

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

Den här filen krävs när den körs lokalt.

Kör det här azd init kommandot i en tom mapp i den lokala terminalen eller kommandotolken:
```
azd init --template functions-quickstart-javascript-azd -e httpendpoint-js
```
Det här kommandot hämtar projektfilerna från malllagringsplatsen och initierar projektet i rotmappen. Flaggan -e anger ett namn för den aktuella miljön. I azdanvänds miljön för att upprätthålla en unik distributionskontext för din app och du kan definiera mer än en. Den används också i namnet på den resursgrupp som du skapar i Azure.

Skapa en fil med namnet local.settings.json i rotmappen som innehåller dessa JSON-data:

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

Den här filen krävs när den körs lokalt.

Kör det här azd init kommandot i en tom mapp i den lokala terminalen eller kommandotolken:
```
azd init --template functions-quickstart-powershell-azd -e httpendpoint-ps
```
Det här kommandot hämtar projektfilerna från malllagringsplatsen och initierar projektet i rotmappen. Flaggan -e anger ett namn för den aktuella miljön. I azdanvänds miljön för att upprätthålla en unik distributionskontext för din app och du kan definiera mer än en. Den används också i namnet på den resursgrupp som du skapar i Azure.
Kör det här kommandot för att navigera till appmappen src :
```
cd src
```

Skapa en fil med namnet local.settings.json i src mappen som innehåller dessa JSON-data:

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

Den här filen krävs när den körs lokalt.

Kör det här azd init kommandot i en tom mapp i den lokala terminalen eller kommandotolken:
```
azd init --template functions-quickstart-typescript-azd -e httpendpoint-ts
```
Det här kommandot hämtar projektfilerna från malllagringsplatsen och initierar projektet i rotmappen. Flaggan -e anger ett namn för den aktuella miljön. I azdanvänds miljön för att upprätthålla en unik distributionskontext för din app och du kan definiera mer än en. Den används också i namnet på den resursgrupp som du skapar i Azure.

Skapa en fil med namnet local.settings.json i rotmappen som innehåller dessa JSON-data:

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

Den här filen krävs när den körs lokalt.

Kör det här azd init kommandot i en tom mapp i den lokala terminalen eller kommandotolken:
```
azd init --template functions-quickstart-python-http-azd -e httpendpoint-py
```
Det här kommandot hämtar projektfilerna från malllagringsplatsen och initierar projektet i rotmappen. Flaggan -e anger ett namn för den aktuella miljön. I azdanvänds miljön för att upprätthålla en unik distributionskontext för din app och du kan definiera mer än en. Den används också i namnet på den resursgrupp som du skapar i Azure.

Skapa en fil med namnet local.settings.json i rotmappen som innehåller dessa JSON-data:

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

Den här filen krävs när den körs lokalt.

Skapa och aktivera en virtuell miljö

I rotmappen kör du dessa kommandon för att skapa och aktivera en virtuell miljö med namnet .venv:

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

Om Python inte installerade venv-paketet på Linux-distributionen kör du följande kommando:

sudo apt-get install python3-venv

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

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

Kör i din lokala miljö

Kör det här kommandot från appmappen i en terminal eller kommandotolk:
```
func start
```
```
mvn clean package
mvn azure-functions:run
```
```
npm install
func start  
```
```
npm install
npm start  
```
När Functions-värden startar i den lokala projektmappen skriver den URL-slutpunkterna för dina HTTP-utlösta funktioner till terminalutdata.
I webbläsaren navigerar du till httpget slutpunkten, som bör se ut så här:

http://localhost:7071/api/httpget
Från ett nytt terminal- eller kommandotolkfönster kör du det här curl kommandot för att skicka en POST-begäran med en JSON-nyttolast till httppost slutpunkten:
```
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"
```
Det här kommandot läser JSON-nyttolastdata från testdata.json projektfilen. Du hittar exempel på båda HTTP-begäranden i test.http projektfilen.
När du är klar trycker du på Ctrl+C i terminalfönstret för att stoppa func.exe värdprocessen.

Kör deactivate för att stänga av den virtuella miljön.

Granska koden (valfritt)

Du kan granska koden som definierar de två HTTP-utlösarfunktionsslutpunkterna:

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

Den här function.json filen definierar httpget funktionen:

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

Den här run.ps1 filen implementerar funktionskoden:

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

Den här function.json filen definierar httppost funktionen:

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

Den här run.ps1 filen implementerar funktionskoden:

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
        )

Du kan granska hela mallprojektet här.

Du kan granska hela mallprojektet här.

Du kan granska hela mallprojektet här.

Du kan granska hela mallprojektet här.

Du kan granska hela mallprojektet här.

Du kan granska hela mallprojektet här.

När du har verifierat dina funktioner lokalt är det dags att publicera dem till Azure.

Skapa Azure-resurser

Det här projektet är konfigurerat för att använda azd provision kommandot för att skapa en funktionsapp i en Flex Consumption-plan, tillsammans med andra nödvändiga Azure-resurser.

Note

Det här projektet innehåller en uppsättning Bicep-filer som azd använder för att skapa en säker distribution till en Flex-förbrukningsplan som följer bästa praxis.

azd up Kommandona och azd deploy stöds för närvarande inte för Java-appar.

I rotmappen för projektet kör du det här kommandot för att skapa nödvändiga Azure-resurser:
```
azd provision
```
Rotmappen innehåller den azure.yaml definitionsfil som krävs av azd.

Om du inte redan är inloggad uppmanas du att autentisera med ditt Azure-konto.

Ange följande nödvändiga distributionsparametrar när du uppmanas att göra det:

Parameter	Description
Azure-prenumeration	Prenumeration där dina resurser skapas.
Azure-plats	Azure-region där du kan skapa resursgruppen som innehåller de nya Azure-resurserna. Endast regioner som för närvarande stöder Flex Consumption-planen visas.

Kommandot azd provision använder ditt svar på dessa frågor med Bicep-konfigurationsfilerna för att skapa och konfigurera dessa nödvändiga Azure-resurser:

Flex Consumption-plan och funktionsapp
Azure Storage (krävs) och Application Insights (rekommenderas)
Åtkomstprinciper och roller för ditt konto
Tjänst-till-tjänst-anslutningar med hanterade identiteter (i stället för lagrade anslutningssträng)
Virtuellt nätverk för säker körning av både funktionsappen och andra Azure-resurser

När kommandot har slutförts kan du distribuera projektkoden till den nya funktionsappen i Azure.

Distribuera till Azure

Du kan använda Core Tools för att paketera din kod och distribuera den till Azure från utdatamappen target .

Navigera till motsvarande appmapp i utdatamappen target :
```
cd http/target/azure-functions/contoso-functions
```
Den här mappen ska ha en host.json fil, vilket anger att den är roten i din kompilerade Java-funktionsapp.
Kör dessa kommandon för att distribuera ditt kompilerade Java-kodprojekt till den nya funktionsappresursen i Azure med 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% 
```
Kommandot azd env get-value hämtar funktionsappens namn från den lokala miljön, vilket krävs för distribution med hjälp av func azure functionapp publish. När publiceringen är klar visas länkar till HTTP-utlösarslutpunkterna i Azure.

Distribuera till Azure

Det här projektet är konfigurerat för att använda azd up kommandot för att distribuera projektet till en ny funktionsapp i en Flex Consumption-plan i Azure.

Tip

Det här projektet innehåller en uppsättning Bicep-filer som azd använder för att skapa en säker distribution till en Flex-förbrukningsplan som följer bästa praxis.

Kör det här kommandot för att azd skapa nödvändiga Azure-resurser i Azure och distribuera kodprojektet till den nya funktionsappen:
```
azd up
```
Rotmappen innehåller den azure.yaml definitionsfil som krävs av azd.

Om du inte redan är inloggad uppmanas du att autentisera med ditt Azure-konto.

Ange följande nödvändiga distributionsparametrar när du uppmanas att göra det:

Parameter	Description
Azure-prenumeration	Prenumeration där dina resurser skapas.
Azure-plats	Azure-region där du kan skapa resursgruppen som innehåller de nya Azure-resurserna. Endast regioner som för närvarande stöder Flex Consumption-planen visas.

Kommandot azd up använder ditt svar på dessa frågor med Bicep-konfigurationsfilerna för att slutföra dessa distributionsuppgifter:

Skapa och konfigurera de här nödvändiga Azure-resurserna (motsvarande azd provision):
- Flex Consumption-plan och funktionsapp
- Azure Storage (krävs) och Application Insights (rekommenderas)
- Åtkomstprinciper och roller för ditt konto
- Tjänst-till-tjänst-anslutningar med hanterade identiteter (i stället för lagrade anslutningssträng)
- Virtuellt nätverk för säker körning av både funktionsappen och andra Azure-resurser
Paketera och distribuera koden till distributionscontainern (motsvarande azd deploy). Appen startas sedan och körs i det distribuerade paketet.

När kommandot har slutförts visas länkar till de resurser som du har skapat.

Anropa funktionen i Azure

Nu kan du anropa funktionsslutpunkterna i Azure genom att göra HTTP-begäranden till deras URL:er med hjälp av HTTP-testverktyget eller från webbläsaren (för GET-begäranden). När dina funktioner körs i Azure framtvingas åtkomstnyckelauktorisering och du måste ange en funktionsåtkomstnyckel med din begäran.

Du kan använda Core Tools för att hämta URL-slutpunkterna för dina funktioner som körs i Azure.

I den lokala terminalen eller kommandotolken kör du följande kommandon för att hämta URL-slutpunktsvärdena:

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

Kommandot azd env get-value hämtar funktionsappens namn från den lokala miljön. Om du använder alternativet --show-keys med func azure functionapp list-functions innebär det att det returnerade värdet Invoke URL: för varje slutpunkt innehåller en åtkomstnyckel på funktionsnivå.

Precis som tidigare använder du HTTP-testverktyget för att verifiera dessa URL:er i funktionsappen som körs i Azure.

Distribuera om koden

Du kan köra azd up kommandot så många gånger du behöver både etablera dina Azure-resurser och distribuera koduppdateringar till funktionsappen.

Note

Distribuerade kodfiler skrivs alltid över av det senaste distributionspaketet.

Dina första svar på azd frågor och eventuella miljövariabler som genereras av azd lagras lokalt i din namngivna miljö. azd env get-values Använd kommandot för att granska alla variabler i din miljö som användes när du skapade Azure-resurser.

Rensa resurser

När du är klar med funktionsappen och relaterade resurser kan du använda det här kommandot för att ta bort funktionsappen och dess relaterade resurser från Azure och undvika ytterligare kostnader:

azd down --no-prompt

Note

Alternativet --no-prompt instruerar azd dig att ta bort resursgruppen utan någon bekräftelse från dig.

Det här kommandot påverkar inte ditt lokala kodprojekt.

Feedback

Var den här sidan till hjälp?