Salut tout le monde! Le voici - notre dernier article de la série Quarkus ! (Au fait, regardez notre webinaire . Nous vous montrerons comment repartir de zéro ou transférer des solutions toutes faites)
В Dans cet article, nous avons examiné les outils pertinents qui peuvent être utilisés pour quantifier les améliorations obtenues grâce à la modernisation des applications Java.
Depuis la version 0.17.0, prend en charge l'utilisation du protocole Advanced Message Queuing (), qui est un standard ouvert pour le transfert de messages professionnels entre applications ou organisations.
est un service construit sur la base d'un projet open source et mettre en œuvre un mécanisme de messagerie basé sur une plateforme . Pour plus de détails sur son fonctionnement, voir . Aujourd'hui, nous allons vous montrer comment combiner AMQ Online et Quarkus pour créer un système de messagerie moderne basé sur OpenShift en utilisant deux nouvelles technologies de messagerie.
Il est supposé que vous avez déjà déployé AMQ Online sur la plateforme OpenShift (sinon, consultez ).
Pour commencer, nous allons créer une application Quarkus qui sera un simple système de traitement des commandes utilisant une messagerie réactive. Cette application comprendra un générateur de commandes qui enverra les commandes à une file d'attente de messages à intervalle fixe, ainsi qu'un processeur de commandes qui traitera les messages de la file d'attente et générera des confirmations visibles dans le navigateur.
Une fois l'application créée, nous vous montrerons comment intégrer la configuration du système de messagerie dans l'application et utiliser AMQ Online pour provisionner les ressources dont nous avons besoin sur le système.
Application Quarkus
Notre application Quarkus fonctionne sur OpenShift et est une version modifiée du programme . Un exemple complet du côté client peut être trouvé .
Générateur de commandes
Le générateur envoie simplement de manière monotone des identifiants de commande croissants à l'adresse « commandes » toutes les 5 secondes.
@ApplicationScoped
public class OrderGenerator {
private int orderId = 1;
@Outgoing("orders")
public Flowable<Integer> generate() {
return Flowable.interval(5, TimeUnit.SECONDS)
.map(tick -> orderId++);
}
}
Processeur de commandes
Le gestionnaire de commandes est encore plus simple, il renvoie simplement un identifiant de confirmation à l'adresse "confirmations".
@ApplicationScoped
public class OrderProcessor {
@Incoming("orders")
@Outgoing("confirmations")
public Integer process(Integer order) {
// Идентификатор подтверждения равен удвоенному идентификатору заказа <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 permettant de répertorier les confirmations générées par notre application.
@Path("/confirmations")
public class ConfirmationResource {
@Inject
@Stream("confirmations") Publisher<Integer> orders;
@GET
@Produces(MediaType.TEXT_PLAIN)
public String hello() {
return "hello";
}
@GET
@Path("/stream")
@Produces(MediaType.SERVER_SENT_EVENTS)
public Publisher<Integer> stream() {
return orders;
}
}
réglage
Pour se connecter à AMQ Online, notre application aura besoin de certaines données de configuration, à savoir : la configuration du connecteur Quarkus, les informations sur le point de terminaison AMQP et les informations d'identification du client. Il est bien sûr préférable de conserver toutes les données de configuration au même endroit, mais nous les séparerons délibérément pour montrer les options possibles pour configurer 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 d'application :
mp.messaging.outgoing.orders.connector=smallrye-amqp
mp.messaging.incoming.orders.connector=smallrye-amqp
Pour simplifier les choses, nous utiliserons uniquement une file d'attente de messages pour l'adresse "commandes". Et l'adresse « confirmations » dans notre application utilisera une file d'attente en mémoire.
Point de terminaison AMQP
Au moment de la compilation, le nom d'hôte et le numéro de port du point de terminaison AMQP sont inconnus, ils doivent donc être injectés. Le point de terminaison peut être défini dans la carte de configuration créée par AMQ Online, nous les définirons donc 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
Crédits
Le jeton du compte de service peut être utilisé pour authentifier notre application auprès d'OpenShift. Pour ce faire, vous devez d'abord créer un ConfigSource personnalisé qui lira le jeton d'authentification à partir du système de fichiers du pod :
public class MessagingCredentialsConfigSource implements ConfigSource {
private static final Set<String> propertyNames;
static {
propertyNames = new HashSet<>();
propertyNames.add("amqp-username");
propertyNames.add("amqp-password");
}
@Override
public Set<String> getPropertyNames() {
return propertyNames;
}
@Override
public Map<String, String> getProperties() {
try {
Map<String, String> 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);
}
}
Créer et déployer l'application
Puisque l'application doit être compilée dans un fichier exécutable, une machine virtuelle GraalVM est requise. Pour plus de détails sur la façon de configurer un environnement pour cela, consultez les instructions correspondantes dans .
Ensuite, en suivant les instructions qui y sont données, vous devez télécharger le source, créer 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 ne démarrera pas tant que nous n'aurons pas configuré les ressources de messagerie dont nous avons besoin dans AMQ Online.
Mise en place de la messagerie
Il ne reste plus qu'à définir les ressources dont notre application a besoin dans la messagerie. Pour ce faire, vous devez créer : 1) un espace d'adressage pour initialiser le point de terminaison du système de messagerie ; 2) adresse pour configurer les adresses que nous utilisons dans l'application ; 3) Utilisateur de messagerie pour définir les informations d'identification du client.
Espace d'adressage
Un objet AddressSpace dans AMQ Online est un groupe d'adresses qui partagent des points de terminaison de connexion et des stratégies d'authentification et d'autorisation. Lorsque vous créez un espace d'adressage, vous pouvez spécifier comment les points de terminaison de messagerie seront exposés :
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
Адреса
Les adresses sont utilisées pour envoyer et recevoir des messages. Chaque adresse possède un type, qui détermine sa sémantique, ainsi qu'un plan, qui précise le nombre de ressources à réserver. L'adresse peut être déterminée, par exemple, comme ceci :
apiVersion: enmasse.io/v1beta1
kind: Address
metadata:
name: quarkus-example.orders
spec:
address: orders
type: queue
plan: brokered-queue
Utilisateur de messagerie
Pour garantir que seules les applications approuvées peuvent envoyer et recevoir des messages à vos adresses, vous devez créer un utilisateur dans le système de messagerie. Pour les applications exécutées sur un cluster, les clients peuvent être authentifiés à l'aide d'un compte de service OpenShift. L'utilisateur "serviceaccount" peut être défini, par exemple, comme ceci :
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"]
Autorisations pour configurer l'application
Pour qu'AMQ Online crée la carte de configuration que nous avons utilisée pour intégrer les informations du point de terminaison AMQP, le rôle et le rôle de liaison doivent être définis :
---
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
Vous pouvez appliquer la configuration du système de messagerie comme ceci :
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 la demande
Pour nous assurer que l’application a démarré, vérifions tout 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 "Not yet ready"; sleep 5; done
Vérifions ensuite 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 doit indiquer que les tickets sont mis à jour périodiquement au fur et à mesure que les messages sont envoyés et reçus par AMQ Online.
Résumant
Nous avons donc écrit une application Quarkus qui utilise AMQP pour la messagerie, configuré l'application pour qu'elle s'exécute sur la plate-forme Red Hat OpenShift et implémenté sa configuration basée sur la configuration AMQ Online. Nous avons ensuite créé les manifestes nécessaires à l'initialisation du système de messagerie de notre application.
Ceci conclut la série sur Quarkus, mais il y a beaucoup de choses nouvelles et intéressantes à venir, restez à l'écoute !
Source: habr.com