Inicio rápido: Creación e implementación de funciones en Azure Functions mediante la Azure Developer CLI

Artículo
09/11/2024

En este inicio rápido, usará las herramientas de línea de comandos de Azure Developer para crear funciones 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.

Importante

El Plan de Consumo Flex está actualmente en versión preliminar.

De forma predeterminada, el plan de consumo flexible sigue un modelo de facturación de pago por uso, lo que significa que completar este inicio rápido conlleva un pequeño costo de unos pocos centavos de USD o menos en su cuenta de Azure.

Requisitos previos

Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
Azure Developer CLI.
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 variable de entorno JAVA_HOME se debe establecer en la ubicación de instalación de la versión correcta del JDK.
Apache Maven 3.8.x

Node.js 20

Python 3.11.

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

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

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 flexquickstart-dotnet
```
Este comando extrae los archivos del 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 se usa para mantener 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.
Ejecute este comando para ir a la carpeta de la http aplicación:
```
cd http
```

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.

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 flexquickstart-java 
```
Este comando extrae los archivos del 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 se usa para mantener 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.
Ejecute este comando para ir a la carpeta de la http aplicación:
```
cd http
```

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.

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 flexquickstart-js
```
Este comando extrae los archivos del 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 se usa para mantener 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.

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.

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 flexquickstart-ps
```
Este comando extrae los archivos del 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 se usa para mantener 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.
Ejecute este comando para ir a la carpeta de la src aplicación:
```
cd src
```

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.

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 flexquickstart-ts
```
Este comando extrae los archivos del 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 se usa para mantener 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.

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.

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 flexquickstart-py
```
Este comando extrae los archivos del 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 se usa para mantener 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.

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:

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

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

sudo apt-get install python3-venv

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

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

Ejecución en el entorno local

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 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.
En el explorador, vaya al punto de conexión de httpget, que debería tener este aspecto:

http://localhost:7071/api/httpget
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
```
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.
Cuando haya terminado, presione Ctrl+C en la ventana del terminal para detener el proceso de host de func.exe.

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

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

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

Creación de recursos de Azure

Este proyecto está configurado para usar el comando azd provision para crear una aplicación de funciones en un plan de consumo flexible, junto con otros recursos de Azure necesarios.

Nota:

Este proyecto incluye un conjunto de archivos de Bicep que azd usa para crear una implementación segura en un plan de consumo Flex que sigue los procedimientos recomendados.

Los comandos azd up y azd deploy no se admiten actualmente para las aplicaciones Java.

En la carpeta raíz del proyecto, ejecute este comando para crear los recursos de Azure necesarios:
```
azd provision
```
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.

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

Parámetro	Descripción
Suscripción de 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.

El comando azd provision usa la respuesta a estos mensajes con los archivos de configuración de Bicep para crear y configurar estos recursos de Azure necesarios:

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)
Red virtual para ejecutar de forma segura tanto la aplicación de funciones como los demás recursos de Azure

Una vez que el comando se complete correctamente, puede implementar el código del proyecto en esta nueva aplicación de funciones en Azure.

Implementación en Azure

Puede usar Core Tools para empaquetar el código e implementarlo en Azure desde la carpeta de salida target.

Vaya a la carpeta de la aplicación equivalente en la carpeta de salida target:
```
cd http/target/azure-functions/contoso-functions
```
Esta carpeta debe tener un archivo host.json, que indica que es la raíz de la aplicación de funciones de Java compilada.
Ejecute estos comandos para implementar el proyecto de código Java compilado en el nuevo recurso de aplicación de funciones en Azure mediante 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% 
```
El comando azd env get-value obtiene el nombre de la aplicación de funciones del entorno local, que es necesario para la implementación mediante func azure functionapp publish. Después de que la publicación se complete correctamente, verá vínculos a los puntos de conexión del desencadenador HTTP 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.

Sugerencia

Este proyecto incluye un conjunto de archivos de Bicep que azd usa para crear una implementación segura en un plan de consumo Flex que sigue los procedimientos recomendados.

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.

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

Parámetro	Descripción
Suscripción de 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.

El comando azd up usa la respuesta 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)
- 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.

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

El comando azd env get-value obtiene el nombre de la aplicación de funciones del entorno local. El uso de la opción --show-keys con func azure functionapp list-functions significa que la dirección URL de invocación de devuelta: valor para cada punto de conexión incluye una clave de acceso de nivel de función.

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

Puede ejecutar 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.

Nota:

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 comando azd env get-values para revisar todas las variables del entorno que se usaron al crear recursos de Azure.

Limpieza de recursos

Cuando haya terminado de trabajar con la aplicación de funciones y los recursos relacionados, puede usar 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

Nota:

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.