Guida introduttiva: Creare un'API Web scalabile con Funzioni di Azure

In questa guida introduttiva si usano gli strumenti da riga di comando per sviluppatori di Azure per creare un'API Web scalabile con endpoint di funzione che rispondono alle richieste HTTP. Dopo aver testato il codice in locale, è possibile distribuirlo in una nuova app per le funzioni serverless creata in un piano a consumo Consumo Flessibile in Funzioni di Azure.

L'origine del progetto usa Azure Developer CLI (azd) per semplificare la distribuzione del codice in Azure. Questa distribuzione segue le procedure consigliate correnti per le distribuzioni di Funzioni di Azure sicure e scalabili.

Per impostazione predefinita, il piano Flex Consumption segue un modello di fatturazione con pagamento in base al consumo, il che significa che il completamento di questa guida introduttiva comporta un costo ridotto di pochi centesimi di USD o inferiore nell'account Azure.

Prerequisites

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
CLI per sviluppatori di Azure
Strumenti di base di Funzioni di Azure

.NET 8.0 SDK
Emulatore di archiviazione Azurite

Java 17 Developer Kit
- Se si usa un'altra versione supportata di Java, è necessario aggiornare il file pom.xml del progetto.
- La JAVA_HOME variabile di ambiente deve essere impostata sul percorso di installazione della versione corretta di Java Development Kit (JDK).
Apache Maven 3.8.x

Node.js 20

Uno strumento di test HTTP sicuro per l'invio di richieste con payload JSON agli endpoint di funzione. Questo articolo usa curl.

Inizializzare il progetto

Usare il azd init comando per creare un progetto di codice di Funzioni di Azure locale da un modello.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template functions-quickstart-dotnet-azd -e httpendpoint-dotnet
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella corrente. Il flag -e imposta un nome per l'ambiente corrente. In azdl'ambiente mantiene un contesto di distribuzione univoco per l'app ed è possibile definire più di uno. Viene usato anche nel nome del gruppo di risorse creato in Azure.
Eseguire questo comando per andare alla cartella dell'app http:
```
cd http
```

Creare un file denominato local.settings.json nella cartella http che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template azure-functions-java-flex-consumption-azd -e httpendpoint-java 
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella corrente. Il flag -e imposta un nome per l'ambiente corrente. In azdl'ambiente mantiene un contesto di distribuzione univoco per l'app ed è possibile definire più di uno. Viene usato anche nel nome del gruppo di risorse creato in Azure.
Eseguire questo comando per andare alla cartella dell'app http:
```
cd http
```

Creare un file denominato local.settings.json nella cartella http che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template functions-quickstart-javascript-azd -e httpendpoint-js
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella radice. Il flag -e imposta un nome per l'ambiente corrente. In azdl'ambiente mantiene un contesto di distribuzione univoco per l'app ed è possibile definire più di uno. Viene usato anche nel nome del gruppo di risorse creato in Azure.

Creare un file denominato local.settings.json nella cartella radice che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template functions-quickstart-powershell-azd -e httpendpoint-ps
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella radice. Il flag -e imposta un nome per l'ambiente corrente. In azdl'ambiente mantiene un contesto di distribuzione univoco per l'app ed è possibile definire più di uno. Viene usato anche nel nome del gruppo di risorse creato in Azure.
Eseguire questo comando per andare alla cartella dell'app src:
```
cd src
```

Creare un file denominato local.settings.json nella cartella src che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template functions-quickstart-typescript-azd -e httpendpoint-ts
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella radice. Il flag -e imposta un nome per l'ambiente corrente. In azdl'ambiente mantiene un contesto di distribuzione univoco per l'app ed è possibile definire più di uno. Il nome dell'ambiente viene usato anche nel nome del gruppo di risorse creato in Azure.

Creare un file denominato local.settings.json nella cartella radice che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template functions-quickstart-python-http-azd -e httpendpoint-py
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella radice. Il flag -e imposta un nome per l'ambiente corrente. In azdl'ambiente mantiene un contesto di distribuzione univoco per l'app ed è possibile definire più di uno. Il nome dell'ambiente viene usato anche nel nome del gruppo di risorse creato in Azure.

Creare un file denominato local.settings.json nella cartella radice che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Creare e attivare un ambiente virtuale

Nella cartella principale, eseguire questi comandi per creare e attivare un ambiente virtuale denominato .venv:

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

Se Python non installa il pacchetto venv nella distribuzione Linux, eseguire il comando seguente:

sudo apt-get install python3-venv

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

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

Eseguire l'ambiente locale

Eseguire questo comando dalla cartella dell'app in un terminale o nel prompt dei comandi:
```
func start
```
```
mvn clean package
mvn azure-functions:run
```
```
npm install
func start  
```
```
npm install
npm start  
```
Quando l'host Funzioni viene avviato nella cartella del progetto locale, scrive gli endpoint URL delle funzioni attivate da HTTP nell'output del terminale.

Note

Poiché l'autorizzazione della chiave di accesso non viene applicata durante l'esecuzione in locale, l'URL della funzione restituito non include il valore della chiave di accesso e non è necessario per chiamare la funzione.
Nel browser, andare all'endpoint httpget, che dovrebbe essere simile a questo URL:

http://localhost:7071/api/httpget
Da una nuova finestra del terminale o del prompt dei comandi eseguire questo comando curl per inviare una richiesta POST con un payload JSON all'endpoint httppost:
```
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"
```
Questo comando legge i dati del payload JSON dal file di progetto testdata.json. È possibile trovare esempi di entrambe le richieste HTTP nel file di progetto test.http.
Al termine, premere CTRL+C nella finestra del terminale per arrestare il processo host func.exe.

Eseguire deactivate per arrestare l'ambiente virtuale.

Esaminare il codice (facoltativo)

È possibile esaminare il codice che definisce i due endpoint della funzione di trigger HTTP:

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

Questo file function.json definisce la funzione httpget:

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

Questo file run.ps1 implementa il codice della funzione:

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

Questo file function.json definisce la funzione httppost:

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

Questo file run.ps1 implementa il codice della funzione:

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
        )

È possibile esaminare il progetto di modello completo qui.

È possibile esaminare il progetto di modello completo qui.

È possibile esaminare il progetto di modello completo qui.

È possibile esaminare il progetto di modello completo qui.

È possibile esaminare il progetto di modello completo qui.

È possibile esaminare il progetto di modello completo qui.

Dopo aver verificato le funzioni in locale, è possibile pubblicarle in Azure.

Distribuisci in Azure

Questo progetto è configurato per l'uso del comando azd up al fine di distribuire questo progetto in una nuova app per le funzioni in un piano a consumo Flex in Azure.

Tip

Il progetto include un set di file Bicep (nella infra cartella) che azd utilizza per creare una distribuzione sicura in un piano di consumo Flex che segue le procedure consigliate.

Eseguire questo comando affinché azd possa creare le risorse di Azure necessarie in Azure e distribuire il progetto di codice nella nuova app per le funzioni:
```
azd up
```
La cartella radice contiene il file di definizione azure.yaml richiesto da azd.

Se non è già stato eseguito l'accesso, viene chiesto di eseguire l'autenticazione con l'account Azure.

Quando richiesto, specificare questi parametri di distribuzione obbligatori:

Parameter	Description
Sottoscrizione di Azure	Sottoscrizione in cui vengono create le risorse.
Località di Azure	Area di Azure in cui creare il gruppo di risorse che contiene le nuove risorse di Azure. Vengono visualizzate solo le aree che attualmente supportano il piano Consumo Flessibile.
vnetEnabled	Scegliere False. Se impostato su True, la distribuzione crea l'applicazione di funzione in una nuova rete virtuale.

Il comando azd up usa le risposte a questi prompt con i file di configurazione Bicep per completare queste attività di distribuzione:

Creare e configurare queste risorse di Azure necessarie (equivalenti a azd provision):
- Piano Consumo Flessibile e app per le funzioni
- Archiviazione di Azure (richiesta) e Application Insights (consigliata)
- Criteri di accesso e ruoli per l'account
- Connessioni da servizio a servizio che usano identità gestite (anziché stringhe di connessione archiviate)
- (Opzione) Rete virtuale per eseguire in modo sicuro sia l'app per le funzioni che le altre risorse di Azure
Creare un pacchetto e distribuire il codice nel contenitore di distribuzione (equivalente a azd deploy). L'app viene quindi avviata ed eseguita nel pacchetto distribuito.

Al termine del comando, vengono visualizzati i collegamenti alle risorse create.

Richiamare la funzione in Azure

È ora possibile richiamare gli endpoint di funzione in Azure effettuando richieste HTTP agli URL usando lo strumento di test HTTP o dal browser (per le richieste GET). Quando le funzioni vengono eseguite in Azure, viene applicata l'autorizzazione della chiave di accesso ed è necessario fornire una chiave di accesso alla funzione con la richiesta.

È possibile usare Core Tools per ottenere gli endpoint URL delle funzioni in esecuzione in Azure.

Nel terminale locale o nel prompt dei comandi, eseguire questi comandi per ottenere i valori dell'endpoint URL:

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

Il comando azd env get-value ottiene il nome dell'app per le funzioni dall'ambiente locale. Quando si usa l'opzione --show-keys con func azure functionapp list-functions, il valore Invoke URL: restituito per ogni endpoint include una chiave di accesso a livello di funzione.

Come in precedenza, usare lo strumento di test HTTP per convalidare questi URL nell'app per le funzioni in esecuzione in Azure.

Ridistribuire il codice

Eseguire il comando azd up quante volte è necessario per effettuare il provisioning delle risorse di Azure e distribuire gli aggiornamenti del codice nell'app per le funzioni.

Note

I file di codice distribuiti vengono sempre sovrascritti dal pacchetto di distribuzione più recente.

Le risposte iniziali alle azd richieste e a qualsiasi variabile di ambiente generata da azd, vengono archiviate localmente nell'ambiente denominato. Usare il azd env get-values comando per esaminare tutte le variabili nell'ambiente usato durante la creazione di risorse di Azure.

Pulire le risorse

Al termine dell'uso dell'app per le funzioni e delle risorse correlate, usare questo comando per eliminare l'app per le funzioni e le relative risorse da Azure ed evitare di sostenere ulteriori costi:

azd down --no-prompt

Note

L'opzione --no-prompt indica a azd di eliminare il gruppo di risorse senza conferma.

Questo comando non influisce sul progetto di codice locale.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-12-05