Inicio rápido: Creación de una API web escalable mediante Azure Functions

En este inicio rápido, usará las herramientas de línea de comandos de Azure Developer para crear una API web escalable con puntos de conexión de función que respondan a solicitudes HTTP. Después de probar el código localmente, se implementa en una nueva aplicación de funciones sin servidor que se crea en ejecución en un plan de consumo flexible en Azure Functions.

El origen del proyecto usa la Azure Developer CLI (azd) para simplificar la implementación del código en Azure. Esta implementación sigue los procedimientos recomendados actuales para implementaciones seguras y escalables de Azure Functions.

De forma predeterminada, el plan Flex Consumption sigue un modelo de facturación de pago por uso, lo que implica que completar esta iniciación rápida conllevará un pequeño costo de unos pocos centavos de dólar estadounidense o menos en su cuenta de Azure.

Prerequisites

• Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.

• CLI de desarrollo de Azure

• Azure Functions Core Tools

• SDK de .NET 8.0

• Emulador Storage Azurite

• Kit para desarrolladores de Java 17
  • Si usa otra versión compatible de Java, debe actualizar el archivo pom.xml del proyecto.
  • La JAVA_HOME variable de entorno debe establecerse en la ubicación de instalación de la versión correcta del Kit de desarrollo de Java (JDK).
• Apache Maven 3.8.x

• Node.js 20

• PowerShell 7.2

• SDK de .NET 6.0

• Python 3.11

• Emulador Storage Azurite

• Una herramienta de prueba HTTP segura para enviar solicitudes con cargas JSON a los puntos de conexión de función. En este artículo se usa curl.

Inicialización del proyecto

Use el azd init comando para crear un proyecto de código local de Azure Functions a partir de una plantilla.

1. En el terminal local o el símbolo del sistema, ejecute este comando azd init en una carpeta vacía:

   azd init --template functions-quickstart-dotnet-azd -e httpendpoint-dotnet
   

   Este comando extrae los archivos de proyecto del repositorio de plantillas e inicializa el proyecto en la carpeta actual. La marca -e establece un nombre para el entorno actual. En azd, el entorno mantiene un contexto de implementación único para la aplicación y puede definir más de uno. También se usa en el nombre del grupo de recursos que crea en Azure.

2. Ejecute este comando para ir a la carpeta de la http aplicación:

   cd http
   

3. Cree un archivo denominado local.settings.json en la http carpeta que contiene estos datos JSON:

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

   Este archivo es necesario cuando se ejecuta localmente.

1. En el terminal local o el símbolo del sistema, ejecute este comando azd init en una carpeta vacía:

   azd init --template azure-functions-java-flex-consumption-azd -e httpendpoint-java 
   

   Este comando extrae los archivos de proyecto del repositorio de plantillas e inicializa el proyecto en la carpeta actual. La marca -e establece un nombre para el entorno actual. En azd, el entorno mantiene un contexto de implementación único para la aplicación y puede definir más de uno. También se usa en el nombre del grupo de recursos que crea en Azure.

2. Ejecute este comando para ir a la carpeta de la http aplicación:

   cd http
   

3. Cree un archivo denominado local.settings.json en la http carpeta que contiene estos datos JSON:

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

   Este archivo es necesario cuando se ejecuta localmente.

1. En el terminal local o el símbolo del sistema, ejecute este comando azd init en una carpeta vacía:

   azd init --template functions-quickstart-javascript-azd -e httpendpoint-js
   

   Este comando extrae los archivos de proyecto del repositorio de plantillas e inicializa el proyecto en la carpeta raíz. La marca -e establece un nombre para el entorno actual. En azd, el entorno mantiene un contexto de implementación único para la aplicación y puede definir más de uno. También se usa en el nombre del grupo de recursos que crea en Azure.

2. Cree un archivo denominado local.settings.json en la carpeta raíz que contiene estos datos JSON:

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

   Este archivo es necesario cuando se ejecuta localmente.

1. En el terminal local o el símbolo del sistema, ejecute este comando azd init en una carpeta vacía:

   azd init --template functions-quickstart-powershell-azd -e httpendpoint-ps
   

   Este comando extrae los archivos de proyecto del repositorio de plantillas e inicializa el proyecto en la carpeta raíz. La marca -e establece un nombre para el entorno actual. En azd, el entorno mantiene un contexto de implementación único para la aplicación y puede definir más de uno. También se usa en el nombre del grupo de recursos que crea en Azure.

2. Ejecute este comando para ir a la carpeta de la src aplicación:

   cd src
   

3. Cree un archivo denominado local.settings.json en la src carpeta que contiene estos datos JSON:

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

   Este archivo es necesario cuando se ejecuta localmente.

1. En el terminal local o el símbolo del sistema, ejecute este comando azd init en una carpeta vacía:

   azd init --template functions-quickstart-typescript-azd -e httpendpoint-ts
   

   Este comando extrae los archivos de proyecto del repositorio de plantillas e inicializa el proyecto en la carpeta raíz. La marca -e establece un nombre para el entorno actual. En azd, el entorno mantiene un contexto de implementación único para la aplicación y puede definir más de uno. El nombre del entorno también se usa en el nombre del grupo de recursos que crea en Azure.

2. Cree un archivo denominado local.settings.json en la carpeta raíz que contiene estos datos JSON:

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

   Este archivo es necesario cuando se ejecuta localmente.

1. En el terminal local o el símbolo del sistema, ejecute este comando azd init en una carpeta vacía:

   azd init --template functions-quickstart-python-http-azd -e httpendpoint-py
   

   Este comando extrae los archivos de proyecto del repositorio de plantillas e inicializa el proyecto en la carpeta raíz. La marca -e establece un nombre para el entorno actual. En azd, el entorno mantiene un contexto de implementación único para la aplicación y puede definir más de uno. El nombre del entorno también se usa en el nombre del grupo de recursos que crea en Azure.

2. Cree un archivo denominado local.settings.json en la carpeta raíz que contiene estos datos JSON:

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

   Este archivo es necesario cuando se ejecuta localmente.

Creación y activación de un entorno virtual

En la carpeta raíz, ejecute estos comandos para crear y activar un entorno virtual denominado .venv:

Linux/macOS

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

Si Python no instala el paquete venv en la distribución de Linux, ejecute el siguiente comando:

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

Ejecución en el entorno local

1. Ejecute este comando desde la carpeta de la aplicación en un terminal o símbolo del sistema:

   func start
   

   mvn clean package
   mvn azure-functions:run
   

   npm install
   func start  
   

   npm install
   npm start  
   

   Cuando el host de Functions se inicia en la carpeta del proyecto local, escribe los puntos de conexión de dirección URL de las funciones desencadenadas por HTTP en la salida del terminal.

   Note

   Dado que la autorización de clave de acceso no se aplica cuando se ejecuta localmente, la dirección URL de la función devuelta no incluye el valor de la clave de acceso y no es necesario llamar a la función.

2. En su navegador, vaya al httpget endpoint, y debería verse como esta URL:

   http://localhost:7071/api/httpget

3. Desde una nueva ventana del terminal o del símbolo del sistema, ejecute este curlcomando para enviar una solicitud POST con una carga JSON al punto de conexión 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"
   

   Este comando lee los datos de carga JSON del archivo de proyecto de testdata.json. Puede encontrar ejemplos de ambas solicitudes HTTP en el archivo de proyecto test.http.

4. Cuando haya terminado, presione Ctrl+C en la ventana del terminal para detener el proceso de host de func.exe.

5. Ejecute deactivate para apagar el entorno virtual.

Revisión del código (opcional)

Puede revisar el código que define los dos puntos de conexión de función del desencadenador HTTP:

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

Este archivo function.json define la función httpget:

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

Este archivo run.ps1 implementa el código de función:

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

Este archivo function.json define la función httppost:

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

Este archivo run.ps1 implementa el código de función:

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
        )

Puede revisar el proyecto de plantilla completo aquí.

Puede revisar el proyecto de plantilla completo aquí.

Puede revisar el proyecto de plantilla completo aquí.

Puede revisar el proyecto de plantilla completo aquí.

Puede revisar el proyecto de plantilla completo aquí.

Puede revisar el proyecto de plantilla completo aquí.

Después de comprobar las funciones localmente, es el momento de publicarlas en Azure.

Implementación en Azure

Este proyecto está configurado para usar el comando azd up para implementar este proyecto en una nueva aplicación de funciones en un Plan de consumo flexible en Azure.

Tip

El proyecto incluye un conjunto de archivos de Bicep (en la infra carpeta) que azd utiliza para crear una implementación segura en un plan de consumo Flex que sigue las mejores prácticas.

1. Ejecute este comando para que azd cree los recursos de Azure necesarios en Azure e implemente el proyecto de código en la nueva aplicación de funciones:

   azd up
   

   La carpeta raíz contiene el azure.yamlarchivo de definición de requerido por azd.

   Si aún no ha iniciado sesión, se le pedirá que se autentique con su cuenta de Azure.

2. Cuando se le solicite, proporcione estos parámetros de implementación necesarios:

   Parameter	Description
   Suscripción a Azure	Suscripción en la que se crean los recursos.
   Ubicación de Azure	Región de Azure en la que se va a crear el grupo de recursos que contiene los nuevos recursos de Azure. Solo se muestran las regiones que admiten actualmente el plan de consumo flexible.
   vnetEnabled	Elija False. Cuando se establece en True , la implementación crea la aplicación de funciones en una nueva red virtual.

   El azd up comando usa las respuestas a estos mensajes con los archivos de configuración de Bicep para completar estas tareas de implementación:

   • Cree y configure estos recursos de Azure necesarios (equivalente a azd provision):

     • Plan de consumo flexible y aplicación de funciones
     • Azure Storage (obligatorio) y Application Insights (recomendado)
     • Directivas y roles de acceso para la cuenta
     • Conexiones de servicio a servicio mediante identidades administradas (en lugar de cadenas de conexión almacenadas)
     • (Opción) Red virtual para ejecutar de forma segura tanto la aplicación de funciones como los demás recursos de Azure

   • Empaquete e implemente el código en el contenedor de implementación (equivalente a azd deploy). A continuación, la aplicación se inicia y se ejecuta en el paquete implementado.

   Una vez que el comando se complete correctamente, verá vínculos a los recursos que creó.

Invocación de la función en Azure

Ahora puede invocar los puntos de conexión de función en Azure realizando solicitudes HTTP a sus direcciones URL mediante la herramienta de prueba HTTP o desde el explorador (para solicitudes GET). Cuando las funciones se ejecutan en Azure, se aplica la autorización de clave de acceso y debe proporcionar una clave de acceso de función con la solicitud.

Puede usar Core Tools para obtener los puntos de conexión de dirección URL de las funciones que se ejecutan en Azure.

1. En el terminal local o el símbolo del sistema, ejecute estos comandos para obtener los valores del punto de conexión de dirección URL:

   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 
   

   El comando azd env get-value obtiene el nombre de la aplicación de funciones del entorno local. Cuando se usa la --show-keys opción con func azure functionapp list-functions, el valor de Invoke URL: devuelto para cada punto de conexión incluye una clave de acceso de nivel de función.

2. Como antes, use la herramienta de prueba HTTP para validar estas direcciones URL en la aplicación de funciones que se ejecuta en Azure.

Reimplementación del código

Ejecute el azd up comando tantas veces como sea necesario aprovisionar los recursos de Azure e implementar actualizaciones de código en la aplicación de funciones.

Note

El paquete de implementación más reciente siempre sobrescribe los archivos de código implementados.

Las respuestas iniciales a azd mensajes y las variables de entorno generadas por azd se almacenan localmente en el entorno con nombre. Use el azd env get-values comando para revisar todas las variables del entorno que usó al crear recursos de Azure.

Limpieza de recursos

Cuando haya terminado de trabajar con la aplicación de funciones y los recursos relacionados, use este comando para eliminar la aplicación de funciones y sus recursos relacionados de Azure y evitar incurrir en costos adicionales:

azd down --no-prompt

Note

La --no-prompt opción indica azd que elimine el grupo de recursos sin una confirmación de usted.

Este comando no afecta al proyecto de código local.

Contenido relacionado

• Escenarios de Azure Functions
• Plan de consumo flexible
• CLI para desarrolladores de Azure (azd)
• azd reference
• Referencia de Azure Functions Core Tools
• Codificación y comprobación de Azure Functions en un entorno local