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
