Implementar aplicaciones Java sin servidor con Quarkus en Azure Functions

Artículo
03/18/2023

En este artículo desarrollará, compilará e implementará una aplicación Java sin servidor para Azure Functions mediante Quarkus. En este artículo se usa Quarkus Funqy y su compatibilidad integrada con el desencadenador HTTP de Azure Functions para Java. El uso de Quarkus con Azure Functions proporciona la potencia del modelo de programación de Quarkus con la escala y la flexibilidad de Azure Functions. Cuando termine, ejecutará aplicaciones de Quarkus sin servidor en Azure Functions y seguirá supervisando la aplicación en Azure.

Requisitos previos

La CLI de Azure instalada en su propio equipo.
Una cuenta de Azure. Si no tiene una suscripción a Azure, cree una cuenta gratuita de Azure antes de empezar.
Java JDK 17 con JAVA_HOME configurado correctamente. Este artículo se escribió teniendo en cuenta Java 17, pero Azure Functions y Quarkus también admiten versiones anteriores de Java.
Apache Maven 3.8.1+.

Crear el proyecto de la aplicación

Use el siguiente comando para clonar el proyecto de Java de ejemplo para este artículo. El ejemplo se encuentra en GitHub.

git clone https://github.com/Azure-Samples/quarkus-azure
cd quarkus-azure
git checkout 2023-01-10
cd functions-quarkus

Si ve un mensaje acerca de estar en estado HEAD desasociado, este mensaje es seguro de omitir. Dado que este artículo no requiere ninguna confirmación, el estado HEAD desasociado es adecuado.

Explore la función de ejemplo. Abra el archivo functions-quarkus/src/main/java/io/quarkus/GreetingFunction.java.

Ejecute el comando siguiente: La anotación @Funq convierte el método (en este caso, funqyHello) en una función sin servidor.

@Funq
public String funqyHello() {
    return "hello funqy";
}

En Azure Functions Java tiene su propio conjunto de anotaciones específicas de Azure, pero estas anotaciones no son necesarias cuando se usa Quarkus en Azure Functions en una capacidad sencilla, como estamos haciendo aquí. Para obtener más información sobre anotaciones de Java de Azure Functions, consulte la guía para desarrolladores de Java de Azure Functions.

A menos que especifique lo contrario, el nombre de la función es el mismo que el nombre del método. También puede usar el siguiente comando para definir el nombre de la función con un parámetro para la anotación:

@Funq("alternateName")
public String funqyHello() {
    return "hello funqy";
}

El nombre es importante. Se convierte en una parte del URI de REST para invocar la función, como se muestra más adelante en el artículo.

Prueba local de la función

Use mvn para ejecutar el modo de desarrollador de Quarkus en el terminal local. La ejecución de Quarkus de esta manera permite recargar en vivo con compilación en segundo plano. Al modificar los archivos de Java o los archivos de recursos y actualizar el explorador, estos cambios surtirán efecto automáticamente.

Una actualización del explorador desencadena un examen del área de trabajo. Si el examen detecta algún cambio, se vuelven a compilar los archivos Java y se vuelve a implementar la aplicación. La aplicación que se vuelve a implementar atiende la solicitud. Si hay algún problema con la compilación o la implementación, una página de error le informará.

En el procedimiento siguiente, reemplace yourResourceGroupName por un nombre de grupo de recursos. Los nombres de las aplicación de funciones deben ser únicos globalmente en todas las instancias de Azure. Los nombres de los grupos de recursos deben ser únicos globalmente dentro de una suscripción. En este artículo se logra la unicidad necesaria anteponiendo el nombre del grupo de recursos al nombre de la función. Considere la posibilidad de anteponer un identificador único a los nombres que cree que deban ser únicos. Una técnica útil es usar sus iniciales seguidas de la fecha de hoy en formato mmdd.

El grupo de recursos no es necesario para esta parte de las instrucciones, pero sí más adelante. Para simplificar, el proyecto de Maven requiere que defina la propiedad.

Invoque el modo de desarrollador de Quarkus:

cd functions-azure
mvn -DskipTests -DresourceGroup=<yourResourceGroupName> quarkus:dev

El resultado debe ser similar al siguiente:

...
--/ __ \/ / / / _ | / _ \/ //_/ / / / __/ 
-/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \   
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/   
INFO  [io.quarkus] (Quarkus Main Thread) quarkus-azure-function 1.0-SNAPSHOT on JVM (powered by Quarkus xx.xx.xx.) started in 1.290s. Listening on: http://localhost:8080

INFO  [io.quarkus] (Quarkus Main Thread) Profile dev activated. Live Coding activated.
INFO  [io.quarkus] (Quarkus Main Thread) Installed features: [cdi, funqy-http, smallrye-context-propagation, vertx]

--
Tests paused
Press [r] to resume testing, [o] Toggle test output, [:] for the terminal, [h] for more options>

Acceda a la función mediante el comando CURL en el terminal local:
```
curl localhost:8080/api/funqyHello
```
El resultado debe ser similar al siguiente:
```
"hello funqy"
```

Agregar la inserción de dependencias a la función

La tecnología estándar abierta Contexts and Dependency Injection (Inyección de contextos y dependencias, CDI) de Jakarta EE proporciona inserción de dependencias en Quarkus. Para obtener información general sobre la inyección en general y CDI específicamente, consulte el tutorial de Jakarta EE.

Agregue una nueva función que use la inyección de dependencias.

Cree un archivo GreetingService.java en el directorio functions-quarkus/src/main/java/io/quarkus. Use el código siguiente como código fuente del archivo:
```
package io.quarkus;

import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class GreetingService {

    public String greeting(String name) {
        return "Welcome to build Serverless Java with Quarkus on Azure Functions, " + name;
    }

}
```
Guarde el archivo.

GreetingService es un bean inyectable que implementa un método greeting(). El método devuelve un mensaje de cadena Welcome... con un parámetro name.

Abra el archivo existente functions-quarkus/src/main/java/io/quarkus/GreetingFunction.java. Reemplace la clase por el código siguiente para agregar un nuevo campo gService y el método greeting:

package io.quarkus;

import javax.inject.Inject;
import io.quarkus.funqy.Funq;

public class GreetingFunction {

    @Inject
    GreetingService gService;

    @Funq
    public String greeting(String name) {
        return gService.greeting(name);
    }

    @Funq
    public String funqyHello() {
        return "hello funqy";
    }

}

Guarde el archivo.

Acceda a la nueva función greeting mediante el comando curl en el terminal local:
```
curl -d '"Dan"' -X POST localhost:8080/api/greeting
```
El resultado debe ser similar al siguiente:
```
"Welcome to build Serverless Java with Quarkus on Azure Functions, Dan"
```
Importante

Live Coding (también denominado modo de desarrollador) permite ejecutar la aplicación y realizar cambios sobre la marcha. Quarkus volverá a compilar y recargará automáticamente la aplicación cuando se realicen cambios. Se trata de un estilo potente y eficaz de desarrollo que usará en este artículo.

Antes de avanzar al paso siguiente, detenga el modo de desarrollador de Quarkus pulsando Ctrl+C.

Implementar la aplicación en Azure

Si no lo ha hecho todavía, inicie sesión en la suscripción de Azure con el comando az login y siga las instrucciones de la pantalla:
```
az login
```
Nota:

Si hay varios inquilinos de Azure asociados a sus credenciales de Azure, debe especificar en qué inquilino desea iniciar sesión. Puede hacerlo mediante la opción --tenant. Por ejemplo: az login --tenant contoso.onmicrosoft.com.

Continúe el proceso en el explorador web. Si no hay ningún explorador web disponible o no se puede abrir el explorador web, use el flujo de código del dispositivo con az login --use-device-code.

Después de iniciar sesión correctamente, la salida en el terminal local debería parecerse a la siguiente:
```
xxxxxxx-xxxxx-xxxx-xxxxx-xxxxxxxxx 'Microsoft'
[
    {
        "cloudName": "AzureCloud",
        "homeTenantId": "xxxxxx-xxxx-xxxx-xxxx-xxxxxxx",
        "id": "xxxxxx-xxxx-xxxx-xxxx-xxxxxxxx",
        "isDefault": true,
        "managedByTenants": [],
        "name": "Contoso account services",
        "state": "Enabled",
        "tenantId": "xxxxxxx-xxxx-xxxx-xxxxx-xxxxxxxxxx",
        "user": {
        "name": "user@contoso.com",
        "type": "user"
        }
    }
]
```
Compile e implemente las funciones en Azure.

El archivo pom.xml que generó en el paso anterior usa azure-functions-maven-plugin. La ejecución de mvn install genera archivos de configuración y un directorio de almacenamiento provisional que requiere azure-functions-maven-plugin. Para yourResourceGroupName, use el valor que usó anteriormente.
```
mvn clean install -DskipTests -DtenantId=<your tenantId from shown previously> -DresourceGroup=<yourResourceGroupName> azure-functions:deploy
```
Durante la implementación, inicie sesión en Azure. El complemento azure-functions-maven-plugin está configurado para solicitar el inicio de sesión de Azure cada vez que se implementa el proyecto. Durante la compilación, aparece un resultado similar al siguiente:
```
[INFO] Auth type: DEVICE_CODE
To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code AXCWTLGMP to authenticate.
```
Haga lo que indica el resultado y autentíquese en Azure mediante el explorador y el código de dispositivo proporcionado. Hay muchas otras opciones de autenticación y configuración disponibles. La documentación de referencia completa de azure-functions-maven-plugin está disponible en Azure Functions: detalles de configuración.
Después de la autenticación, la compilación se debe continuar y finalizar. Asegúrese de que la salida incluye BUILD SUCCESS cerca del final.
```
Successfully deployed the artifact to https://quarkus-demo-123451234.azurewebsites.net
```
También puede encontrar la dirección URL para desencadenar la función en Azure en el registro de salida:
```
[INFO] HTTP Trigger Urls:
[INFO] 	 quarkus : https://quarkus-azure-functions-http-archetype-20220629204040017.azurewebsites.net/api/{*path}
```
La implementación tardará un tiempo en finalizar. Mientras tanto, vamos a explorar Azure Functions en el Azure Portal.

Acceder y supervisar la función sin servidor en Azure

Inicie sesión en el portal y asegúrese de que ha seleccionado el mismo inquilino y suscripción que usó en la CLI de Azure.

Escriba aplicación de funciones en la barra de búsqueda de la parte superior del Azure Portal y pulse la tecla Entrar. La aplicación de funciones debe implementarse y mostrarse con el nombre <yourResourceGroupName>-function-quarkus.
Seleccione la aplicación de funciones para mostrar información detallada, como ubicación, Suscripción, URL, Métricas y Plan de App Service. A continuación, seleccione el valor URL.
Confirme que la página principal indica que la aplicación de funciones está en funcionamiento.
Invoque la función greeting mediante el siguiente comando curl en el terminal local.

Importante

Reemplace YOUR_HTTP_TRIGGER_URL por su propia dirección URL de función que encuentre en el Azure Portal o la salida.
```
curl -d '"Dan on Azure"' -X POST https://YOUR_HTTP_TRIGGER_URL/api/greeting
```
La salida debe tener una apariencia similar a la siguiente:
```
"Welcome to build Serverless Java with Quarkus on Azure Functions, Dan on Azure"
```
También puede acceder a la otra función (funqyHello) mediante el siguiente comandocurl:
```
curl https://YOUR_HTTP_TRIGGER_URL/api/funqyHello
```
La salida debe ser la misma que la que observó anteriormente:
```
"hello funqy"
```
Si desea ejercer la funcionalidad de métricas básicas en el Azure Portal, intente invocar la función dentro de un bucle de shell for:
```
for i in {1..100}; do curl -d '"Dan on Azure"' -X POST https://YOUR_HTTP_TRIGGER_URL/api/greeting; done
```
Después de un tiempo, verá algunos datos de métricas en el portal.

Ahora que ha abierto la función de Azure en el portal, estas son otras características a las que puede acceder desde el portal:

Supervise el rendimiento de la función de Azure. Para más información, consulte Supervisión de Azure Functions.
Explore los datos de telemetría. Para obtener más información, consulte Analizar la telemetría de Azure Functions en Application Insights.
Configurar los registros. Para más información, consulte Habilitar los registros de ejecución de streaming en Azure Functions.

Limpieza de recursos

Si no necesita estos recursos puede eliminarlos ejecutando el siguiente comando en Azure Cloud Shell o en el terminal local:

az group delete --name <yourResourceGroupName> --yes

Pasos siguientes

En este artículo, ha aprendido cómo:

Ejecute el modo de desarrollador de Quarkus.
Implemente una aplicación de Funqy en las funciones de Azure mediante azure-functions-maven-plugin.
Examine el rendimiento de la función en el portal.

Para obtener más información sobre Azure Functions y Quarkus, consulte los siguientes artículos y referencias: