Déployer des applications Java serverless avec Quarkus sur Azure Functions

Article
08/22/2024

Dans cet article, vous allez développer, générer et déployer une application Java serverless pour Azure Functions à l’aide de Quarkus. Cet article utilise Quarkus Funqy et sa prise en charge intégrée du déclencheur HTTP Azure Functions pour Java. L’utilisation de Quarkus avec Azure Functions vous donne la puissance du modèle de programmation Quarkus avec l’échelle et la flexibilité de Azure Functions. Lorsque vous avez terminé, vous exécuterez des applications Quarkus serverless sur Azure Functions et continuerez à surveiller votre application sur Azure.

Prérequis

Azure CLI, installé sur votre propre ordinateur.
Un compte Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit Azure avant de commencer.
Java JDK 17 avec JAVA_HOME configuré de manière appropriée. Cet article a été écrit avec Java 17 à l’esprit, mais Azure Functions et Quarkus prennent également en charge les versions antérieures de Java.
Apache Maven 3.8.1.

Création du projet d’application

Utilisez la commande suivante pour cloner l’exemple de projet Java pour cet article. L’exemple se trouve sur GitHub.

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

Si un message vous signale que vous allez passer à l’état detached HEAD, vous pouvez ignorer ce message sans risque. Étant donné que cet article ne nécessite aucune validation, l’état détaché HEAD est approprié.

Explorer l’exemple de fonction. Ouvrez le fichier functions-quarkus/src/main/java/io/quarkus/GreetingFunction.java .

Exécutez la commande suivante : L’annotation @Funq fait de votre méthode (dans ce cas, funqyHello) une fonction serverless.

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

Azure Functions Java a son propre ensemble d’annotations spécifiques à Azure, mais ces annotations ne sont pas nécessaires lorsque vous utilisez Quarkus sur Azure Functions dans une capacité simple, comme nous le faisons ici. Pour plus d’informations sur Azure Functions annotations Java, consultez le Guide du développeur Java Azure Functions.

Sauf indication contraire, le nom de la fonction est le même que le nom de la méthode. Vous pouvez également utiliser la commande suivante pour définir le nom de la fonction avec un paramètre pour l’annotation :

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

Le nom est important. Il devient une partie de l’URI REST pour appeler la fonction, comme indiqué plus loin dans l’article.

Tester la fonction en local

Utilisez mvn pour exécuter le mode de développement Quarkus sur votre terminal local. L’exécution de Quarkus de cette façon permet un rechargement en direct avec la compilation en arrière-plan. Lorsque vous modifiez vos fichiers Java et/ou vos fichiers de ressources et actualisez votre navigateur, ces modifications prennent automatiquement effet.

Une actualisation du navigateur déclenche une analyse de l’espace de travail. Si l’analyse détecte des modifications, les fichiers Java sont recompilés et l’application est redéployée. Votre application redéployée prend en compte la requête. En cas de problèmes de compilation ou de déploiement, une page d’erreur vous en informera.

Dans la procédure suivante, remplacezyourResourceGroupName par un nom de groupe de ressources. Les noms des applications de fonction doivent être globalement uniques dans l’ensemble d’Azure. Les noms de groupes de ressources doivent être globalement uniques au sein d’un abonnement. Cet article permet d'obtenir l'unicité nécessaire en ajoutant le nom du groupe de ressources au nom de la fonction. Envisagez de prévoir un identificateur unique pour tous les noms que vous créez qui doivent être uniques. Une technique utile consiste à utiliser vos initiales suivies de la date du jour au formatmmdd.

Le groupe de ressources n’est pas nécessaire pour cette partie des instructions, mais il est nécessaire ultérieurement. Par souci de simplicité, le projet Maven vous oblige à définir la propriété .

Appeler le mode de développement Quarkus :

mvn -DskipTests -DresourceGroup=<yourResourceGroupName> quarkus:dev

La sortie doit ressembler à ceci :

...
--/ __ \/ / / / _ | / _ \/ //_/ / / / __/ 
-/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \   
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/   
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>

Accédez à la fonction à l’aide de la commandeCURL sur votre terminal local :
```
curl localhost:8080/api/funqyHello
```
La sortie doit ressembler à ceci :
```
"hello funqy"
```

Ajouter l’injection de dépendances à la fonction

La technologie open-standard Jakarta EE Contexts and Dependency Injection (CDI) fournit l’injection de dépendances dans Quarkus. Pour obtenir une vue d’ensemble générale de l’injection en général, et du CDI en particulier, consultez le tutoriel Jakarta EE.

Ajoutez une nouvelle fonction qui utilise l’injection de dépendances.

Créez un fichier GreetingService.java dans le répertoire functions-quarkus/src/main/java/io/quarkus . Utilisez le code suivant comme code source du fichier :
```
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;
    }

}
```
Enregistrez le fichier .

GreetingService est un haricot injectable qui implémente une méthodegreeting(). La méthode retourne un Welcome... message de chaîne avec un name paramètre .

Ouvrez le fichier functions-quarkus/src/main/java/io/quarkus/GreetingFunction.java . Remplacez la classe par le code suivant pour ajouter un nouveau gService champ et la greeting méthode :

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

}

Enregistrez le fichier .

Accédez à la nouvelle greeting fonction à l’aide de la curl commande sur votre terminal local :
```
curl -d '"Dan"' -X POST localhost:8080/api/greeting
```
La sortie doit ressembler à ceci :
```
"Welcome to build Serverless Java with Quarkus on Azure Functions, Dan"
```
Important

Live Coding (également appelé mode dev) vous permet d’exécuter l’application et d’apporter des modifications à la volée. Quarkus recompile et recharge automatiquement l’application lorsque des modifications sont apportées. Il s’agit d’un style de développement puissant et efficace que vous utiliserez tout au long de cet article.

Avant de passer à l’étape suivante, arrêtez le mode de développement Quarkus en sélectionnant Ctrl+C.

Déploiement de l’application dans Azure

Si ce n’est pas déjà fait, connectez-vous à votre abonnement Azure à l’aide de la commande az login suivante et suivez les instructions à l’écran :
```
az login
```
Notes

Si plusieurs locataires Azure sont associés à vos informations d’identification Azure, vous devez spécifier le locataire auquel vous souhaitez vous connecter. Vous pouvez le faire à l’aide de l’option --tenant. Par exemple : az login --tenant contoso.onmicrosoft.com.

Poursuivez le processus dans le navigateur web. Si aucun navigateur web n’est disponible ou si l’ouverture du navigateur web échoue, utilisez le flux de code de l’appareil avec az login --use-device-code.

Une fois que vous vous êtes connecté, la sortie sur votre terminal local doit ressembler à ce qui suit :
```
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"
        }
    }
]
```
Générez et déployez les fonctions sur Azure.

Le fichierpom.xml que vous avez généré à l’étape précédente utilise azure-functions-maven-plugin. L’exécution mvn install génère des fichiers de configuration et un répertoire intermédiaire qui azure-functions-maven-plugin nécessite. Pour yourResourceGroupName, utilisez la valeur que vous avez utilisée précédemment.
```
mvn clean install -DskipTests -DtenantId=<your tenantId from shown previously> -DresourceGroup=<yourResourceGroupName> azure-functions:deploy
```
Pendant le déploiement, connectez-vous à Azure. Le azure-functions-maven-plugin plug-in est configuré pour demander la connexion Azure chaque fois que le projet est déployé. Pendant la génération, une sortie similaire à ce qui suit s’affiche :
```
[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.
```
Effectuez comme indiqué dans la sortie et authentifiez-vous auprès d’Azure à l’aide du navigateur et du code d’appareil fourni. De nombreuses autres options d’authentification et de configuration sont disponibles. La documentation de référence complète pour azure-functions-maven-plugin est disponible dans Azure Functions : Détails de la configuration.
Après l’authentification, la build doit continuer et se terminer. Assurez-vous que la sortie inclut BUILD SUCCESS vers la fin.
```
Successfully deployed the artifact to https://quarkus-demo-123451234.azurewebsites.net
```
Vous pouvez également trouver l’URL pour déclencher votre fonction sur Azure dans le journal de sortie :
```
[INFO] HTTP Trigger Urls:
[INFO] 	 quarkus : https://quarkus-azure-functions-http-archetype-20220629204040017.azurewebsites.net/api/{*path}
```
La fin du déploiement prendra un certain temps. En attendant, nous allons explorer Azure Functions dans le Portail Azure.

Accéder à la fonction serverless sur Azure et la surveiller

Connectez-vous au portail et vérifiez que vous avez sélectionné le même locataire et l’abonnement que vous avez utilisés dans Azure CLI.

Tapez l’application de fonction dans la barre de recherche en haut du Portail Azure et sélectionnez la touche Entrée. Votre application de fonction doit être déployée et s’afficher avec le nom <yourResourceGroupName>-function-quarkus.
Sélectionnez l’application de fonction pour afficher des informations détaillées, telles que l’emplacement, l’abonnement, l’URL, les métriques et App Service plan. Ensuite, sélectionnez la valeur d’URL .
Vérifiez que la page d’accueil indique que votre application de fonction est « opérationnelle ».
Appelez la fonction greetingà l’aide de la commande suivante curl sur votre terminal local.

Important

Remplacez par YOUR_HTTP_TRIGGER_URL votre propre URL de fonction que vous trouvez dans le Portail Azure ou la sortie.
```
curl -d '"Dan on Azure"' -X POST https://YOUR_HTTP_TRIGGER_URL/api/greeting
```
Le résultat doit être semblable à ce qui suit :
```
"Welcome to build Serverless Java with Quarkus on Azure Functions, Dan on Azure"
```
Vous pouvez également accéder à l’autre fonction (funqyHello) à l’aide de la commande suivante curl :
```
curl https://YOUR_HTTP_TRIGGER_URL/api/funqyHello
```
La sortie doit être identique à ce que vous avez observé précédemment :
```
"hello funqy"
```
Si vous souhaitez exercer la fonctionnalité de métriques de base dans le Portail Azure, essayez d’appeler la fonction dans une boucle d’interpréteur de commandes for :
```
for i in {1..100}; do curl -d '"Dan on Azure"' -X POST https://YOUR_HTTP_TRIGGER_URL/api/greeting; done
```
Après un certain temps, vous verrez certaines données de métriques dans le portail.

Maintenant que vous avez ouvert votre fonction Azure dans le portail, voici d’autres fonctionnalités auxquelles vous pouvez accéder à partir du portail :

Surveillez les performances de votre fonction Azure. Pour plus d’informations, consultez Surveille les fonctions Azure.
Explorer la télémétrie. Pour en savoir plus, consultez Analyser la télémétrie d’Azure Functions dans Application Insights.
Configurez la journalisation. Pour plus d’informations, consultez Activer les journaux d’exécution de streaming dans Azure Functions.

Nettoyer les ressources

Si vous n’avez pas besoin de ces ressources, vous pouvez les supprimer en exécutant la commande ci-dessous :

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

Étapes suivantes

Dans cet article, vous avez appris à effectuer les opérations suivantes :

Exécutez le mode de développement Quarkus.
Déployez une application Funqy sur des fonctions Azure à l’aide de azure-functions-maven-plugin.
Examinez les performances de la fonction dans le portail.

Pour en savoir plus sur Azure Functions et Quarkus, consultez les articles et références suivants :

Partager via