Inicio rápido: Creación de una función en Azure desde la línea de comandos

En este artículo, usará herramientas de línea de comandos locales para crear una función que responda a las solicitudes HTTP. Después de comprobar el código localmente, se implementa en un plan de hospedaje de consumo flexible sin servidor en Azure Functions.

Completar este inicio rápido acarrea un coste pequeño, de unos pocos centavos de dólar o menos, en su cuenta de Azure.

Asegúrese de seleccionar el lenguaje de desarrollo preferido en la parte superior del artículo.

Prerequisites

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

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

Ir a
Óxido

Go, se recomienda la última versión. Use el comando go version para comprobar la versión.

Azure CLI
El jq procesador JSON de la línea de comandos, que se usa para analizar la salida JSON, y también está disponible en Azure Cloud Shell.

Instalación de Azure Functions Core Tools

La manera recomendada de instalar Core Tools depende del sistema operativo del equipo de desarrollo local.

En los pasos siguientes se utiliza Windows Installer (MSI) para instalar Core Tools v4.x. Para más información sobre otros instaladores basados en paquetes, consulte el archivo Léame de Core Tools.

Descargue y ejecute el instalador de Core Tools según su versión de Windows:

v4.x: Windows de 64 bits (recomendado. La depuración de Visual Studio Code requiere 64 bits.)
v4.x: Windows de 32 bits

Si ha usado previamente Windows Installer (MSI) para instalar Core Tools en Windows, debe desinstalar la versión anterior desde Agregar/Quitar programas antes de instalar la versión más reciente.

Los pasos siguientes utilizan Homebrew para instalar Core Tools en macOS.

Instale Homebrew, si aún no está instalado.

Instale el paquete de Core Tools:

brew tap azure/functions
brew install azure-functions-core-tools@4
# if upgrading on a machine that has 2.x or 3.x installed:
brew link --overwrite azure-functions-core-tools@4

Los siguientes pasos usan APT para instalar Core Tools en la distribución de Ubuntu/Debian Linux. Para otras distribuciones de Linux, consulte el Archivo Léame de Core Tools.

Instale la clave GPG del repositorio de paquetes de Microsoft para validar la integridad del paquete:

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg

Configure la lista de origen de APT antes de actualizar APT.

Ubuntu

sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-$(lsb_release -cs 2>/dev/null)-prod $(lsb_release -cs 2>/dev/null) main" > /etc/apt/sources.list.d/dotnetdev.list'

Debian

sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/debian/$(lsb_release -rs 2>/dev/null | cut -d'.' -f 1)/prod $(lsb_release -cs 2>/dev/null) main" > /etc/apt/sources.list.d/dotnetdev.list'

Compruebe el archivo /etc/apt/sources.list.d/dotnetdev.list en busca de una de las cadenas de la versión Linux adecuada en la siguiente tabla:

Distribución de Linux	Version
Debian 12	`bookworm`
Debian 11	`bullseye`
Debian 10	`buster`
Debian 9	`stretch`
Ubuntu 24.04	`noble`
Ubuntu 22.04	`jammy`
Ubuntu 20.04	`focal`
Ubuntu 19.04	`disco`
Ubuntu 18.10	`cosmic`
Ubuntu 18.04	`bionic`
Ubuntu 17.04	`zesty`
Ubuntu 16.04/Linux Mint 18	`xenial`

Inicie la actualización del origen de APT:
```
sudo apt-get update
```

Instale el paquete de Core Tools:

sudo apt-get install azure-functions-core-tools-4

Creación y activación de un entorno virtual

En una carpeta adecuada, ejecute los comandos siguientes para crear y activar un entorno virtual denominado .venv. Asegúrese de usar una de las versiones de Python compatibles con Azure Functions.

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

.venv\scripts\activate

py -m venv .venv

.venv\scripts\activate

Ejecute todos los comandos siguientes en este entorno virtual activado.

Creación de un proyecto de código local y una función

En Azure Functions, el proyecto de código es una aplicación que contiene una o varias funciones individuales que cada una responde a un desencadenador específico. Todas las funciones de un proyecto comparten las mismas configuraciones y se implementan como una unidad en Azure. En esta sección, creará un proyecto de código que contiene una sola función.

En un terminal o consola, ejecute este func init comando para crear un proyecto de aplicación de funciones en la carpeta actual.
```
func init --worker-runtime dotnet-isolated 
```

En un terminal o consola, ejecute este func init comando para crear un proyecto de aplicación de funciones en la carpeta actual.
```
func init --worker-runtime node --language javascript 
```

En un terminal o consola, ejecute este func init comando para crear un proyecto de aplicación de funciones en la carpeta actual.
```
func init --worker-runtime powershell 
```

En un terminal o consola, ejecute este func init comando para crear un proyecto de aplicación de funciones en la carpeta actual.
```
func init --worker-runtime python 
```

En un terminal o consola, ejecute este func init comando para crear un proyecto de aplicación de funciones en la carpeta actual.
```
func init --worker-runtime node --language typescript 
```

En un terminal o consola, ejecute este func init comando para crear un proyecto de aplicación de funciones en la carpeta actual.
```
func init --worker-runtime custom 
```

En una carpeta vacía, ejecute este mvn comando para generar el proyecto de código a partir de un arquetipo de Maven de Azure Functions:
- Bash
- PowerShell
- Cmd
```
mvn archetype:generate -DarchetypeGroupId=com.microsoft.azure -DarchetypeArtifactId=azure-functions-archetype -DjavaVersion=17
```
```
mvn archetype:generate "-DarchetypeGroupId=com.microsoft.azure" "-DarchetypeArtifactId=azure-functions-archetype" "-DjavaVersion=17" 
```
```
mvn archetype:generate "-DarchetypeGroupId=com.microsoft.azure" "-DarchetypeArtifactId=azure-functions-archetype" "-DjavaVersion=17"
```
Important
- Use -DjavaVersion=11 si quiere que las funciones se ejecuten en Java 11. Para más información, consulte Versiones de Java.
- Establezca la JAVA_HOME variable de entorno en la ubicación de instalación de la versión correcta del JDK para completar este artículo.

Maven le pide los valores necesarios para finalizar la generación del proyecto en la implementación.
Indique los siguientes valores cuando se le solicite:

Prompt	Value	Description
groupId	`com.fabrikam`	Un valor que identifica de forma única su proyecto entre todos los demás y que sigue las reglas de nomenclatura de paquetes de Java.
artifactId	`fabrikam-functions`	Un valor que es el nombre del archivo jar, sin un número de versión.
version	`1.0-SNAPSHOT`	Elija el valor predeterminado.
package	`com.fabrikam`	Un valor que es el paquete de Java para el código de función generado. Use el valor predeterminado.

Escriba Y o presione Entrar para confirmar.

Maven crea los archivos del proyecto en una carpeta nueva llamada artifactId que, en este ejemplo, es fabrikam-functions.
Vaya a la carpeta del proyecto:
```
cd fabrikam-functions
```
Puede revisar el código generado por la plantilla para la nueva función de desencadenador HTTP en Function.java en el directorio del proyecto \src\main\java\com\fabrikam.

Use este func new comando para agregar una función al proyecto:
```
func new --name HttpExample --template "HTTP trigger" --authlevel "function"
```
Se agrega un nuevo archivo de código al proyecto. En este caso, el --name argumento es el nombre único de la función (HttpExample) y el --template argumento especifica un desencadenador HTTP.

La carpeta raíz del proyecto contiene varios archivos para el proyecto, incluidos los archivos de configuración denominados local.settings.json y host.json. Como local.settings.json puede contener secretos descargados de Azure, el archivo se excluye del control de código fuente de forma predeterminada en el archivo .gitignore.

Creación y compilación de la función

El archivo function.json de la carpeta HttpExample declara una función de desencadenador HTTP. Para completar la función, agregue un controlador y compílela en un archivo ejecutable.

Ir a
Óxido

Pulse Ctrl + N (Cmd + N en macOS) para crear un archivo nuevo. Guárdelo como handler.go en la carpeta raíz de la aplicación de funciones (en la misma carpeta que host.json).

En el archivo handler.go, agregue el código siguiente y guárdelo. Este es el controlador personalizado de Go.

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    message := "This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.\n"
    name := r.URL.Query().Get("name")
    if name != "" {
        message = fmt.Sprintf("Hello, %s. This HTTP triggered function executed successfully.\n", name)
    }
    fmt.Fprint(w, message)
}

func main() {
    listenAddr := ":8080"
    if val, ok := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT"); ok {
        listenAddr = ":" + val
    }
    http.HandleFunc("/api/HttpExample", helloHandler)
    log.Printf("About to listen on %s. Go to https://127.0.0.1%s/", listenAddr, listenAddr)
    log.Fatal(http.ListenAndServe(listenAddr, nil))
}

Pulse Ctrl + Mayús + ` o seleccione Nuevo terminal en el menú Terminal para abrir un nuevo terminal integrado en VS Code.
Compile el controlador personalizado con el siguiente comando. Se genera un archivo ejecutable llamado handler (handler.exe en Windows) en la carpeta raíz de la aplicación de funciones.
```
go build handler.go
```

Pulse Ctrl + Mayús + ` o seleccione Nuevo terminal en el menú Terminal para abrir un nuevo terminal integrado en VS Code.
En la carpeta raíz de la aplicación de funciones (en la misma carpeta que host.json), inicialice un proyecto de Rust llamado handler.
```
cargo init --name handler
```
En el archivo Cargo.toml, agregue las siguientes dependencias necesarias para completar esta guía de inicio rápido. En el ejemplo se usa el marco de servidor web warp.
```
[dependencies]
warp = "0.3"
tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
```

En el archivo src/main.rs, agregue el código siguiente y guárdelo. Este es el controlador personalizado de Rust.

use std::collections::HashMap;
use std::env;
use std::net::Ipv4Addr;
use warp::{http::Response, Filter};

#[tokio::main]
async fn main() {
    let example1 = warp::get()
        .and(warp::path("api"))
        .and(warp::path("HttpExample"))
        .and(warp::query::<HashMap<String, String>>())
        .map(|p: HashMap<String, String>| match p.get("name") {
            Some(name) => Response::builder().body(format!("Hello, {}. This HTTP triggered function executed successfully.", name)),
            None => Response::builder().body(String::from("This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.")),
        });

    let port_key = "FUNCTIONS_CUSTOMHANDLER_PORT";
    let port: u16 = match env::var(port_key) {
        Ok(val) => val.parse().expect("Custom Handler port is not a number!"),
        Err(_) => 3000,
    };

    warp::serve(example1).run((Ipv4Addr::LOCALHOST, port)).await
}

Compile un archivo binario para el controlador personalizado. Se genera un archivo ejecutable llamado handler (handler.exe en Windows) en la carpeta raíz de la aplicación de funciones.
```
cargo build --release
cp target/release/handler .
```

Configuración de la aplicación de funciones

El host de la función se debe configurar para ejecutar el archivo binario del controlador personalizado al iniciarse.

Abra el archivo host.json.
En la sección customHandler.description, establezca el valor de defaultExecutablePath en handler (en Windows, establézcalo en handler.exe).
En la sección customHandler, agregue una propiedad llamada enableForwardingHttpRequest y establezca su valor en true. En el caso de las funciones que solo se componen de un desencadenador HTTP, esta configuración simplifica la programación, ya que permite trabajar con una solicitud HTTP típica en lugar de la carga de la solicitud del controlador personalizado.

Confirme que la sección customHandler es similar a la de este ejemplo. Guarde el archivo.

"customHandler": {
  "description": {
    "defaultExecutablePath": "handler",
    "workingDirectory": "",
    "arguments": []
  },
  "enableForwardingHttpRequest": true
}

La aplicación de funciones está configurada para iniciar el archivo ejecutable del controlador personalizado.

Ejecución local de la función

Compruebe la nueva función ejecutando el proyecto localmente y llamando al punto de conexión de la función.

Use este comando para iniciar el host en tiempo de ejecución de Azure Functions local en la raíz de la carpeta del proyecto:

func start

npm install
npm start

mvn clean package  
mvn azure-functions:run

Hacia el final de la salida, aparecen las siguientes líneas:

 ...

 Now listening on: http://0.0.0.0:7071
 Application started. Press Ctrl+C to shut down.

 Http Functions:

         HttpExample: [GET,POST] http://localhost:7071/api/HttpExample
 ...

Copie la dirección URL de su HttpExample función desde esta salida y péguela en un navegador para navegar a la URL de la función. Debe recibir una respuesta exitosa con un mensaje "hola mundo".

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.
Cuando termine, presione Ctrl+C y seleccione y para detener el host de Functions.

Creación de recursos auxiliares de Azure para la función

Para poder implementar el código de función en Azure, debe crear estos recursos:

Un grupo de recursos, que es un contenedor lógico de recursos relacionados.
Una cuenta de almacenamiento predeterminada, que usa el host de Functions para mantener el estado y otra información sobre las funciones.
Una identidad administrada asignada por el usuario, que el host de Functions usa para conectarse a la cuenta de almacenamiento predeterminada.
Una aplicación de funciones, que proporciona el entorno para ejecutar el código de función. Una aplicación de funciones se asigna al proyecto de funciones y le permite agrupar funciones como una unidad lógica para facilitar la administración, la implementación y el uso compartido de recursos.

Use los comandos de la CLI de Azure en estos pasos para crear los recursos necesarios.

Si todavía no lo ha hecho, inicie sesión en Azure:
```
az login
```
El comando az login inicia sesión en la cuenta de Azure. Omita este paso cuando se ejecute en Azure Cloud Shell.
Si aún no lo ha hecho, use este az extension add comando para instalar la extensión de Application Insights:
```
az extension add --name application-insights
```
Use este comando az group create para crear un grupo de recursos denominado AzureFunctionsQuickstart-rg en la región elegida:
```
az group create --name "AzureFunctionsQuickstart-rg" --location "<REGION>"
```
En este ejemplo, reemplace <REGION> por una región cercana que admita el plan de consumo flexible. Use el comando az functionapp list-flexconsumption-locations para ver la lista de regiones admitidas actualmente.
Use este comando az storage account create para crear una cuenta de almacenamiento de uso general en el grupo de recursos y la región:
```
az storage account create --name <STORAGE_NAME> --location "<REGION>" --resource-group "AzureFunctionsQuickstart-rg" \
--sku "Standard_LRS" --allow-blob-public-access false --allow-shared-key-access false
```
En este ejemplo, reemplace por <STORAGE_NAME> un nombre adecuado para usted y único en Azure Storage. Los nombres deben contener entre 3 y 24 caracteres y solo letras minúsculas. Standard_LRS especifica una cuenta de uso general, que es compatible con Functions. El acceso a esta nueva cuenta solo es posible mediante identidades autenticadas por Microsoft Entra a las que se les han otorgado permisos para recursos específicos.
Use este script para crear una identidad administrada asignada por el usuario, analizar las propiedades JSON devueltas del objeto mediante jqy conceder Storage Blob Data Owner permisos en la cuenta de almacenamiento predeterminada:
```
output=$(az identity create --name "func-host-storage-user" --resource-group "AzureFunctionsQuickstart-rg" --location <REGION> \
--query "{userId:id, principalId: principalId, clientId: clientId}" -o json)

userId=$(echo $output | jq -r '.userId')
principalId=$(echo $output | jq -r '.principalId')
clientId=$(echo $output | jq -r '.clientId')

storageId=$(az storage account show --resource-group "AzureFunctionsQuickstart-rg" --name <STORAGE_NAME> --query 'id' -o tsv)
az role assignment create --assignee-object-id $principalId --assignee-principal-type ServicePrincipal \
--role "Storage Blob Data Owner" --scope $storageId
```
Si no tiene la jq utilidad en la shell de Bash local, está disponible en Azure Cloud Shell. En este ejemplo, reemplace <STORAGE_NAME> y <REGION> por el nombre y la región de la cuenta de almacenamiento predeterminados, respectivamente.

El comando az identity create crea una identidad denominada func-host-storage-user. El principalId devuelto se utiliza para asignar permisos a esta nueva identidad en la cuenta de almacenamiento predeterminada mediante el comando az role assignment create. El az storage account show comando se usa para obtener el identificador de la cuenta de almacenamiento.

Use este comando az functionapp create para crear la aplicación de funciones en Azure:

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime dotnet-isolated --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime java --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime node --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime python --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime python --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime other --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

En este ejemplo, reemplace estos marcadores de posición por los valores adecuados:

<APP_NAME>: un nombre único global adecuado para usted. <APP_NAME> también es el dominio DNS predeterminado de la aplicación de función.
<STORAGE_NAME>: el nombre de la cuenta que usó en el paso anterior.
<REGION>: la región actual.
<LANGUAGE_VERSION>: utilice la misma versión de stack de idiomas compatible que ha comprobado localmente, si es aplicable.

Este comando crea una función de aplicación que se ejecuta en el tiempo de ejecución del lenguaje especificado en Linux, bajo el Plan de Consumo Flexible, el cual es gratuito para el nivel de uso que se incurre aquí. El comando también crea una instancia de Azure Application Insights asociada en el mismo grupo de recursos, con el que puede usar para supervisar las ejecuciones de la aplicación de funciones y ver los registros. Para más información, consulte Supervisión de Azure Functions. La instancia no incurrirá en ningún costo hasta que se active.

Use este script para agregar la identidad administrada asignada por el usuario al rol Publicador de métricas de supervisión en la instancia de Application Insights:
```
appInsights=$(az monitor app-insights component show --resource-group "AzureFunctionsQuickstart-rg" \
    --app <APP_NAME> --query "id" --output tsv)
principalId=$(az identity show --name "func-host-storage-user" --resource-group "AzureFunctionsQuickstart-rg" \
    --query principalId -o tsv)
az role assignment create --role "Monitoring Metrics Publisher" --assignee $principalId --scope $appInsights
```
En este ejemplo, reemplace <APP_NAME> por el nombre de la aplicación de funciones. El comando az role assignment create agrega el usuario al rol. El identificador de recurso de la instancia de Application Insights y el ID principal de su usuario se obtienen mediante los comandos az monitor app-insights component show y az identity show, respectivamente.

Actualización de la configuración de la aplicación

Para permitir que el host de Functions se conecte a la cuenta de almacenamiento predeterminada usando secretos compartidos, reemplace la AzureWebJobsStorage configuración de cadena de conexión por varias configuraciones con el prefijo AzureWebJobsStorage__. Esta configuración define una configuración compleja que la aplicación usa para conectarse al almacenamiento y Application Insights con una identidad administrada asignada por el usuario.

Use este script para obtener el identificador de cliente de la identidad administrada asignada por el usuario y usarlo para definir conexiones de identidad administrada tanto al almacenamiento como a Application Insights:

clientId=$(az identity show --name func-host-storage-user \
    --resource-group AzureFunctionsQuickstart-rg --query 'clientId' -o tsv)
az functionapp config appsettings set --name <APP_NAME> --resource-group "AzureFunctionsQuickstart-rg" \
    --settings AzureWebJobsStorage__accountName=<STORAGE_NAME> \
    AzureWebJobsStorage__credential=managedidentity AzureWebJobsStorage__clientId=$clientId \
    APPLICATIONINSIGHTS_AUTHENTICATION_STRING="ClientId=$clientId;Authorization=AAD"

En este script, reemplace <APP_NAME> y <STORAGE_NAME> por los nombres de la aplicación de funciones y la cuenta de almacenamiento, respectivamente.

Ejecute el comando az functionapp config appsettings delete para quitar la configuración de cadena de conexión existente AzureWebJobsStorage , que contiene una clave secreta compartida:
```
az functionapp config appsettings delete --name <APP_NAME> --resource-group "AzureFunctionsQuickstart-rg" --setting-names AzureWebJobsStorage
```
En este ejemplo, reemplace por <APP_NAME> los nombres de la aplicación de funciones.

En este momento, el host de Functions puede conectarse a la cuenta de almacenamiento de forma segura mediante identidades administradas en lugar de secretos compartidos. Ahora puede implementar el código del proyecto en los recursos de Azure.

Implementación del proyecto de función en Azure

Después de haber creado correctamente su aplicación de funciones en Azure, estará listo para implementar el proyecto de funciones local mediante el comando func azure functionapp publish.

En la carpeta del proyecto raíz, ejecute este comando func azure functionapp publish:

func azure functionapp publish <APP_NAME>

En este ejemplo, reemplace <APP_NAME> por el nombre de la aplicación. Una implementación correcta muestra resultados similares a la salida siguiente (truncada por motivos de simplicidad):

 ...

 Getting site publishing info...
 Creating archive for current directory...
 Performing remote build for functions project.

 ...

 Deployment successful.
 Remote build succeeded!
 Syncing triggers...
 Functions in msdocs-azurefunctions-qs:
     HttpExample - [httpTrigger]
         Invoke url: https://msdocs-azurefunctions-qs.azurewebsites.net/api/httpexample

En el terminal local, ejecute este comando para obtener el valor del punto de conexión URL, incluida la clave de acceso.
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
En este ejemplo, reemplace <APP_NAME> de nuevo por el nombre de la aplicación.
Copie la dirección URL y la clave del punto de conexión devueltos, que se usan para invocar el punto de conexión de la función.

Actualización del archivo pom.xml

Después de crear correctamente la aplicación de funciones en Azure, actualice el archivo pom.xml para que Maven pueda implementar en la nueva aplicación. De lo contrario, Maven crea un nuevo conjunto de recursos de Azure durante la implementación.

En Azure Cloud Shell, use este az functionapp show comando para obtener la dirección URL del contenedor de implementación y el identificador de la nueva identidad administrada asignada por el usuario:

az functionapp show --name <APP_NAME> --resource-group AzureFunctionsQuickstart-rg  \
    --query "{userAssignedIdentityResourceId: properties.functionAppConfig.deployment.storage.authentication.userAssignedIdentityResourceId, \
    containerUrl: properties.functionAppConfig.deployment.storage.value}"

En este ejemplo, reemplace por <APP_NAME> los nombres de la aplicación de funciones.

En el directorio raíz del proyecto, abra el archivo pom.xml en un editor de texto, busque el properties elemento y actualice estos valores de propiedad específicos:

Nombre de propiedad	Value
`java.version`	Use la misma versión de pila de idioma compatible que ha comprobado localmente, como `17`.
`azure.functions.maven.plugin.version`	`1.37.1`
`azure.functions.java.library.version`	`3.1.0`
`functionAppName`	Nombre de la aplicación de funciones en Azure.

Busque la configuration sección de azure-functions-maven-plugin y reemplácela por este fragmento XML:

<configuration>
    <appName>${functionAppName}</appName>
    <resourceGroup>AzureFunctionsQuickstart-rg</resourceGroup>
    <pricingTier>Flex Consumption</pricingTier>
    <region>....</region>
    <runtime>
        <os>linux</os>
        <javaVersion>${java.version}</javaVersion>
    </runtime>
    <deploymentStorageAccount>...</deploymentStorageAccount>
    <deploymentStorageResourceGroup>AzureFunctionsQuickstart-rg</deploymentStorageResourceGroup>
    <deploymentStorageContainer>...</deploymentStorageContainer>
    <storageAuthenticationMethod>UserAssignedIdentity</storageAuthenticationMethod>
    <userAssignedIdentityResourceId>...</userAssignedIdentityResourceId>
    <appSettings>
        <property>
            <name>FUNCTIONS_EXTENSION_VERSION</name>
            <value>~4</value>
        </property>
    </appSettings>
</configuration>

En el nuevo elemento configuration, realice estos reemplazos específicos de los puntos suspensivos (...):

Configuration	Value
`region`	Código de región de la aplicación de funciones existente, como `eastus`.
`deploymentStorageAccount`	El nombre de la cuenta de almacenamiento.
`deploymentStorageContainer`	Nombre del recurso compartido de implementación, que viene después de `\` en el valor `containerUrl` que obtuvo.
`userAssignedIdentityResourceId`	Identificador de recurso completo de la identidad administrada que obtuvo.

Guarde los cambios en el archivo pom.xml.

Ahora puede usar Maven para implementar el proyecto de código en la aplicación existente.

Implementación del proyecto de función en Azure

En el símbolo del sistema, ejecute este comando:
```
mvn clean package azure-functions:deploy
```
Una vez que la implementación se haya realizado correctamente, ejecute este comando de Core Tools para obtener el valor del punto de conexión de dirección URL, incluida la clave de acceso:
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
En este ejemplo, reemplace <APP_NAME> de nuevo por el nombre de la aplicación.
Copie la dirección URL y la clave del punto de conexión devueltos, que se usan para invocar el punto de conexión de la función.

Invocación de la función en Azure

Dado que la función usa un desencadenador HTTP y admite solicitudes GET, se invoca mediante la realización de una solicitud HTTP a su dirección URL mediante la clave de acceso de nivel de función. Es más fácil ejecutar una solicitud GET en un explorador.

Pegue la dirección URL y la clave de acceso que copió en una barra de direcciones del explorador.

La dirección URL del punto de conexión debe tener un aspecto similar al de este ejemplo:

https://contoso-app.azurewebsites.net/api/httpexample?code=aabbccdd...

En este caso, también debe proporcionar una clave de acceso en la cadena de consulta al realizar una solicitud GET a la dirección URL del punto de conexión. Se recomienda usar una clave de acceso para limitar el acceso desde clientes aleatorios. Al realizar una solicitud POST mediante un cliente HTTP, debe proporcionar la clave de acceso en el x-functions-key encabezado.

Cuando vaya a esta dirección URL, el explorador debe mostrar una salida similar a cuando ejecutó la función localmente.

Limpieza de recursos

Si continúa con el paso siguiente y agrega un enlace de salida de la cola de Azure Storage, conserve todos los recursos intactos, ya que va a crear a partir de lo que ya ha hecho.

De lo contrario, use el siguiente comando para eliminar el grupo de recursos y todos los recursos que contiene para evitar incurrir en costos adicionales.

Azure CLI
Azure PowerShell

az group delete --name AzureFunctionsQuickstart-rg

Remove-AzResourceGroup -Name AzureFunctionsQuickstart-rg

Pasos siguientes

Conexión a Azure Queue Storage

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-12-04

Compartir a través de

Inicio rápido: Creación de una función en Azure desde la línea de comandos

Prerequisites

Instalación de Azure Functions Core Tools

Creación y activación de un entorno virtual

Creación de un proyecto de código local y una función

Creación y compilación de la función

Configuración de la aplicación de funciones

Ejecución local de la función

Creación de recursos auxiliares de Azure para la función

Actualización de la configuración de la aplicación

Implementación del proyecto de función en Azure

Actualización del archivo pom.xml

Implementación del proyecto de función en Azure

Invocación de la función en Azure

Limpieza de recursos

Pasos siguientes

Comentarios

Recursos adicionales