Bonjour à tous ! Voici notre dernier article de la série sur Quarkus ! (Au fait, regardez notre webinaire . Nous allons montrer comment commencer «de zéro» ou migrer des solutions existantes)
Dans dans cet article, nous avons examiné les outils pertinents qui permettent d'évaluer quantitativement les améliorations obtenues suite à la modernisation des applications Java.
À partir de la version 0.17.0, supporte l'utilisation du Advanced Message Queuing Protocol (), qui est une norme ouverte pour le transfert de messages d'entreprise entre applications ou organisations.
est un service basé sur un projet ouvert et met en œuvre un mécanisme de messagerie sur la plateforme . Pour en savoir plus sur son fonctionnement, consultez . Aujourd'hui, nous allons montrer comment combiner AMQ Online et Quarkus pour construire un système moderne de messagerie basé sur OpenShift en utilisant deux nouvelles technologies liées au traitement des messages.
Il est supposé que vous avez déjà déployé AMQ Online sur la plateforme OpenShift (si ce n'est pas le cas, consultez ).
Pour commencer, nous allons créer une application Quarkus qui représentera un système simple de gestion des commandes utilisant un échange de messages réactif. Cette application inclura un générateur de commandes envoyant des commandes dans une file de messages à intervalles réguliers, ainsi qu'un traitement des commandes qui traitera les messages de la file et générera des confirmations disponibles à visualiser dans le navigateur.
Après avoir créé l'application, nous montrerons comment intégrer la configuration du système de messagerie et utiliserons AMQ Online pour initialiser les ressources nécessaires sur ce système.
Application Quarkus
Notre application Quarkus s'exécute sur OpenShift et est une version modifiée du programme . Un exemple complet de la partie cliente peut être trouvé .
Générateur de commandes
Le générateur envoie simplement des identifiants de commande croissants à l'adresse « orders » toutes les 5 secondes.
@ApplicationScoped
public class OrderGenerator {
private int orderId = 1;
@Outgoing("orders")
public Flowable generate() {
return Flowable.interval(5, TimeUnit.SECONDS)
.map(tick -> orderId++);
}
}
Gestionnaire des commandes
Le gestionnaire des commandes est encore plus simple, il renvoie simplement l'identifiant de confirmation à l'adresse « confirmations ».
@ApplicationScoped
public class OrderProcessor {
@Incoming("orders")
@Outgoing("confirmations")
public Integer process(Integer order) {
// L'identifiant de confirmation est égal au double de l'identifiant de la commande <img draggable="false" class="emoji" alt=":-)" src="https://s.w.org/images/core/emoji/11.2.0/svg/1f642.svg">
return order * 2;
}
}
Ressources de confirmation
La ressource de confirmation est un point de terminaison HTTP pour la liste des confirmations générées par notre application.
@Path("/confirmations")
public class ConfirmationResource {
@Inject
@Stream("confirmations") Publisher orders;
@GET
@Produces(MediaType.TEXT_PLAIN)
public String hello() {
return "hello";
}
@GET
@Path("/stream")
@Produces(MediaType.SERVER_SENT_EVENTS)
public Publisher stream() {
return orders;
}
}
Configuration
Pour se connecter à AMQ Online, notre application a besoin de certaines données de configuration, à savoir : la configuration du connecteur Quarkus, les informations sur le point de terminaison AMQP et les identifiants du client. Il est préférable de garder toutes les données de configuration en un seul endroit, mais nous les diviserons intentionnellement pour montrer les différentes options de configuration de l'application Quarkus.
Connecteurs
La configuration du connecteur peut être fournie au moment de la compilation à l'aide d'un fichier de propriétés de l'application :
mp.messaging.outgoing.orders.connector=smallrye-amqp
mp.messaging.incoming.orders.connector=smallrye-amqp
Pour simplifier, nous utiliserons la file de messages uniquement pour l'adresse « orders ». L'adresse « confirmations » dans notre application utilisera une file en mémoire.
Point de terminaison AMQP
Au moment de la compilation, le nom d'hôte et le numéro de port pour le point de terminaison AMQP ne sont pas connus, il faut donc les injecter. Le point de terminaison peut être défini dans le configmap, qui est créé par AMQ Online, nous allons donc les définir via des variables d'environnement dans le manifeste de l'application :
spec:
template:
spec:
containers:
- env:
- name: AMQP_HOST
valueFrom:
configMapKeyRef:
name: quarkus-config
key: service.host
- name: AMQP_PORT
valueFrom:
configMapKeyRef:
name: quarkus-config
key: service.port.amqp
Identifiants
Le jeton du compte de service peut être utilisé pour authentifier notre application dans OpenShift. Pour cela, il faut d'abord créer une ConfigSource personnalisée qui lira le jeton d'authentification depuis le système de fichiers du pod :
public class MessagingCredentialsConfigSource implements ConfigSource {
private static final Set propertyNames;
static {
propertyNames = new HashSet();
propertyNames.add("amqp-username");
propertyNames.add("amqp-password");
}
@Override
public Set getPropertyNames() {
return propertyNames;
}
@Override
public Map getProperties() {
try {
Map properties = new HashMap();
properties.put("amqp-username", "@@serviceaccount@@");
properties.put("amqp-password", readTokenFromFile());
return properties;
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
@Override
public String getValue(String key) {
if ("amqp-username".equals(key)) {
return "@@serviceaccount@@";
}
if ("amqp-password".equals(key)) {
try {
return readTokenFromFile();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
return null;
}
@Override
public String getName() {
return "messaging-credentials-config";
}
private static String readTokenFromFile() throws IOException {
return new String(Files.readAllBytes(Paths.get("/var/run/secrets/kubernetes.io/serviceaccount/token")), StandardCharsets.UTF_8);
}
}
Compilation et déploiement de l'application
Puisque l'application doit être compilée en un exécutable, une machine virtuelle GraalVM sera nécessaire. Pour plus de détails sur la façon de configurer cet environnement, consultez les instructions correspondantes dans .
Ensuite, en suivant les instructions fournies là-bas, vous devez télécharger le code source, effectuer la compilation et déployer notre application :
git clone https://github.com/EnMasseProject/enmasse-example-clients
cd enmasse-example-clients/quarkus-example-client
oc new-project myapp
mvn -Pnative -Dfabric8.mode=openshift -Dfabric8.build.strategy=docker package fabric8:build fabric8:resource fabric8:apply
Après ces commandes, l'application sera déployée, mais elle ne démarrera pas tant que nous n'aurons pas configuré les ressources de messagerie nécessaires dans AMQ Online.
Configuration du système de messagerie
Nous devons maintenant spécifier dans le système de messagerie les ressources dont notre application a besoin. Pour cela, il faut créer : 1) un espace d'adresses pour initialiser le point de terminaison du système de messagerie ; 2) une adresse pour configurer les adresses que nous utilisons dans l'application ; 3) un utilisateur du système de messagerie pour définir les informations d'identification du client.
Espace d'adresses
L'objet AddressSpace dans AMQ Online est un groupe d'adresses qui partagent les points de terminaison de connexion, ainsi que les politiques d'authentification et d'autorisation. Lors de la création de l'espace d'adresses, il est possible de définir comment les points de terminaison du système de messagerie seront fournis :
apiVersion: enmasse.io/v1beta1
kind: AddressSpace
metadata:
name: quarkus-example
spec:
type: brokered
plan: brokered-single-broker
endpoints:
- name: messaging
service: messaging
exports:
- name: quarkus-config
kind: configmap
Adresses
Les adresses sont utilisées pour envoyer et recevoir des messages. Chaque adresse a un type qui définit sa sémantique, ainsi qu'un plan qui détermine le nombre de ressources réservées. Une adresse peut être définie comme suit :
apiVersion: enmasse.io/v1beta1
kind: Address
metadata:
name: quarkus-example.orders
spec:
address: orders
type: queue
plan: brokered-queue
Utilisateur du système de messagerie
Pour que seules les applications de confiance puissent envoyer et recevoir des messages sur vos adresses, un utilisateur doit être créé dans le système de messagerie. Pour les applications fonctionnant dans le cluster, les clients peuvent être authentifiés à l'aide d'un compte de service OpenShift. L'utilisateur « serviceaccount » peut être défini comme suit :
apiVersion: user.enmasse.io/v1beta1
kind: MessagingUser
metadata:
name: quarkus-example.app
spec:
username: system:serviceaccount:myapp:default
authentication:
type: serviceaccount
authorization:
- operations: ["send", "recv"]
addresses: ["orders"]
Permissions pour la configuration de l'application
Pour qu'AMQ Online puisse créer le configmap que nous avons utilisé pour injecter les informations sur le point de terminaison AMQP, il est nécessaire de définir un rôle et une liaison de rôle (Role et RoleBinding) :
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: quarkus-config
spec:
rules:
- apiGroups: [ "" ]
resources: [ "configmaps" ]
verbs: [ "create" ]
- apiGroups: [ "" ]
resources: [ "configmaps" ]
resourceNames: [ "quarkus-config" ]
verbs: [ "get", "update", "patch" ]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: quarkus-config
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: Role
name: quarkus-config
subjects:
- kind: ServiceAccount
name: address-space-controller
namespace: amq-online-infra
Comment appliquer les configurations
Les configurations du système de messagerie peuvent être appliquées comme suit :
cd enmasse-example-clients/quarkus-example-client
oc project myapp
oc apply -f src/main/resources/k8s/addressspace
oc apply -f src/main/resources/k8s/address
Vérification de l'application
Pour vous assurer que l'application a démarré, vérifions d'abord si les adresses correspondantes ont été créées et sont actives :
until [[ `oc get address quarkus-example.prices -o jsonpath='{.status.phase}'` == "Active" ]]; do echo "Pas encore prêt"; sleep 5; done
Ensuite, nous vérifierons l'URL de la route de l'application (il suffit d'ouvrir cette adresse dans le navigateur) :
echo "http://$(oc get route quarkus-example-client -o jsonpath='{.spec.host}')/prices.html"
Le navigateur devrait afficher que les tickets se mettent à jour périodiquement au fur et à mesure que les messages sont envoyés et reçus par AMQ Online.
Bilan
Ainsi, nous avons écrit une application Quarkus utilisant AMQP pour l'échange de messages, configuré cette application pour fonctionner sur la plateforme Red Hat OpenShift, et déployé sa configuration basée sur celle d'AMQ Online. Ensuite, nous avons créé les manifestes nécessaires pour initier le système d'échange de messages pour notre application.
Ainsi, nous concluons notre série sur Quarkus, mais beaucoup de nouvelles choses intéressantes nous attendent, restez avec nous !
Source : habr.com
