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

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 slutförandet av den här snabbstarten medför en liten kostnad på några USDcent eller mindre på ditt Azure-konto.

Prerequisites

• Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.

• Azure Developer CLI

• Azure Functions Core Tools

• .NET 8.0 SDK

• Azurite Storage-emulator

• 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

• PowerShell 7.2

• .NET 6.0 SDK

• Python 3.11

• Azurite Storage-emulator

• 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

azd init Använd kommandot för att skapa ett lokalt Azure Functions-kodprojekt från en mall.

1. 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 azdbehåller miljön 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.

2. Kör det här kommandot för att navigera till appmappen http :

   cd http
   

3. 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.

1. 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 azdbehåller miljön 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.

2. Kör det här kommandot för att navigera till appmappen http :

   cd http
   

3. 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.

1. 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 azdbehåller miljön 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.

2. 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.

1. 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 azdbehåller miljön 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.

2. Kör det här kommandot för att navigera till appmappen src :

   cd src
   

3. 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.

1. 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 azdbehåller miljön en unik distributionskontext för din app och du kan definiera mer än en. Miljönamnet används också i namnet på den resursgrupp som du skapar i Azure.

2. 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.

1. 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 azdbehåller miljön en unik distributionskontext för din app och du kan definiera mer än en. Miljönamnet används också i namnet på den resursgrupp som du skapar i Azure.

2. 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:

Linux/macOS

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

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

sudo apt-get install python3-venv

Windows (bash)

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

Windows (cmd)

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

Kör i din lokala miljö

1. 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.

   Note

   Eftersom åtkomstnyckelauktorisering inte framtvingas när den körs lokalt innehåller inte funktions-URL:en som returneras åtkomstnyckelvärdet och du behöver det inte för att anropa funktionen.

2. I webbläsaren går du till httpget slutpunkten, som bör se ut så här:

   http://localhost:7071/api/httpget

3. 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.

4. När du är klar trycker du på Ctrl+C i terminalfönstret för att stoppa func.exe värdprocessen.

5. 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

       [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}!")

httppost

[Function("httppost")]
public IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req,
    [FromBody] Person person)
{
    _logger.LogInformation($"C# HTTP POST trigger function processed a request for url {req.Body}");

    if (string.IsNullOrEmpty(person.Name) | string.IsNullOrEmpty(person.Age.ToString()) | person.Age == 0)
    {
        _logger.LogInformation("C# HTTP POST trigger function processed a request with no name/age provided.");
        return new BadRequestObjectResult("Please provide both name and age in the request body.");
    }

    var returnValue = $"Hello, {person.Name}! You are {person.Age} years old.";
    
    _logger.LogInformation($"C# HTTP POST trigger function processed a request for {person.Name} who is {person.Age} years old.");
    return new OkObjectResult(returnValue);
}

@FunctionName("httppost")
public HttpResponseMessage runPost(
        @HttpTrigger(
            name = "req",
            methods = {HttpMethod.POST},
            authLevel = AuthorizationLevel.FUNCTION)
            HttpRequestMessage<Optional<String>> request,
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a POST request.");

    // Parse request body
    String name;
    Integer age;
    try {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode jsonNode = mapper.readTree(request.getBody().orElse("{}"));
        name = Optional.ofNullable(jsonNode.get("name")).map(JsonNode::asText).orElse(null);
        age = Optional.ofNullable(jsonNode.get("age")).map(JsonNode::asInt).orElse(null);
        if (name == null || age == null) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                    .body("Please provide both name and age in the request body.").build();
        }
    } catch (Exception e) {
        context.getLogger().severe("Error parsing request body: " + e.getMessage());
        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                .body("Error parsing request body").build();
    }

const { app } = require('@azure/functions');

app.http('httppost', {
    methods: ['POST'],
    authLevel: 'function',
    handler: async (request, context) => {
        context.log(`Http function processed request for url "${request.url}"`);

        try {
            const person = await request.json();
            const { name, age } = person;

            if (!name || !age) {
                return {
                    status: 400,
                    body: 'Please provide both name and age in the request body.'
                };
            }

            return {
                status: 200,
                body: `Hello, ${name}! You are ${age} years old.`
            };
        } catch (error) {
            return {
                status: 400,
                body: 'Invalid request body. Please provide a valid JSON object with name and age.'
            };
        }
    }
});

import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";

interface Person {
    name: string;
    age: number;
}

function isPerson(obj: any): obj is Person {
    return typeof obj === 'object' && obj !== null && 
           typeof obj.name === 'string' && 
           typeof obj.age === 'number';
}

export async function httpPostBodyFunction(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

        try {
            const data: any  = await request.json();
    
            if (!isPerson(data)) {
                return {
                    status: 400,
                    body: 'Please provide both name and age in the request body.'
                };
            }

            return {
                status: 200,
                body: `Hello, ${data.name}! You are ${data.age} years old.`
            };
        } catch (error) {
            return {
                status: 400,
                body: 'Invalid request body. Please provide a valid JSON object with name and age.'
            };
        }
};

app.http('httppost', {
    methods: ['POST'],
    authLevel: 'function',
    handler: httpPostBodyFunction
});

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.

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

Projektet innehåller en uppsättning Bicep-filer (i infra mappen) som azd använder för att skapa en säker distribution till en Flex-förbrukningsplan som följer bästa praxis.

1. 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.

2. 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.
   vnetEnabled	Välj Falskt. När den är inställd på Sant skapar distributionen din funktionsapp i ett nytt virtuellt nätverk.

   Kommandot azd up använder dina svar till 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)
     • (Alternativ) 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.

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

   bash

   SET APP_NAME=$(azd env get-value AZURE_FUNCTION_NAME)
   func azure functionapp list-functions $APP_NAME --show-keys
   

   Cmd

   for /f "tokens=*" %i in ('azd env get-value AZURE_FUNCTION_NAME') do set APP_NAME=%i
   func azure functionapp list-functions %APP_NAME% --show-keys 
   

   PowerShell

   $APP_NAME = azd env get-value AZURE_FUNCTION_NAME
   func azure functionapp list-functions $APP_NAME --show-keys
   

   Cmd

   for /f "tokens=*" %i in ('azd env get-value AZURE_FUNCTION_NAME') do set APP_NAME=%i
   func azure functionapp list-functions %APP_NAME% --show-keys 
   

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

2. 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

azd up Kör 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 du använde när du skapade Azure-resurser.

Rensa resurser

När du är klar med funktionsappen och relaterade resurser använder du 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.

Relaterat innehåll

• Azure Functions-scenarier
• Flex-förbrukningsplan
• Azure Developer CLI (azd)
• azd-referens
• Referens för Azure Functions Core Tools
• Koda och testa Azure Functions lokalt