Hei alle sammen! Her er det - vårt siste innlegg i Quarkus-serien! (Se forresten webinaret vårt . Vi viser deg hvordan du starter fra bunnen av eller overfører ferdige løsninger)
В I dette innlegget har vi sett på de relevante verktøyene som kan brukes til å kvantifisere forbedringene oppnådd som et resultat av modernisering av Java-applikasjoner.
Siden versjon 0.17.0, støtter bruk av Advanced Message Queuing Protocol (), som er en åpen standard for overføring av forretningsmeldinger mellom applikasjoner eller organisasjoner.
er en tjeneste bygget på grunnlag av et åpen kildekode-prosjekt og implementere en plattformbasert meldingsmekanisme . For mer informasjon om hvordan det fungerer, se . I dag viser vi deg hvordan du kombinerer AMQ Online og Quarkus for å bygge et moderne OpenShift-basert meldingssystem ved å bruke to nye meldingsteknologier.
Det antas at du allerede har distribuert AMQ Online på OpenShift-plattformen (hvis ikke, se ).
Til å begynne med vil vi lage en Quarkus-applikasjon som vil være et enkelt ordrebehandlingssystem som bruker reaktiv melding. Denne applikasjonen vil inkludere en ordregenerator som sender ordre til en meldingskø med et fast intervall, samt en ordreprosessor som vil behandle meldinger fra køen og generere bekreftelser som kan vises i nettleseren.
Når vi har opprettet applikasjonen, viser vi deg hvordan du bygger inn meldingssystemkonfigurasjonen i applikasjonen og bruker AMQ Online til å klargjøre ressursene vi trenger på systemet.
Quarkus app
Quarkus-applikasjonen vår kjører på OpenShift og er en modifisert versjon av programmet . Du finner et fullstendig eksempel på klientsiden .
Bestill generator
Generatoren sender ganske enkelt monotont voksende ordre-IDer til "ordre"-adressen hvert 5. sekund.
@ApplicationScoped
public class OrderGenerator {
private int orderId = 1;
@Outgoing("orders")
public Flowable<Integer> generate() {
return Flowable.interval(5, TimeUnit.SECONDS)
.map(tick -> orderId++);
}
}
Ordrebehandler
Ordrebehandleren er enda enklere, den returnerer bare en bekreftelses-ID til "bekreftelses"-adressen.
@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;
}
}
Bekreftelsesressurser
Bekreftelsesressursen er et HTTP-endepunkt for å liste opp bekreftelsene generert av applikasjonen vår.
@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;
}
}
justering
For å koble til AMQ Online, vil applikasjonen vår trenge noen konfigurasjonsdata, nemlig: Quarkus-koblingskonfigurasjon, AMQP-endepunktinformasjon og klientlegitimasjon. Det er selvfølgelig bedre å holde alle konfigurasjonsdataene på ett sted, men vi vil bevisst skille dem for å vise de mulige alternativene for å konfigurere Quarkus-applikasjonen.
Koblinger
Koblingskonfigurasjon kan gis ved kompilering ved å bruke en programegenskaper-fil:
mp.messaging.outgoing.orders.connector=smallrye-amqp
mp.messaging.incoming.orders.connector=smallrye-amqp
For å gjøre ting enkelt, bruker vi bare en meldingskø for "ordre"-adressen. Og "bekreftelses"-adressen i applikasjonen vår vil bruke en kø i minnet.
AMQP-endepunkt
På kompileringstidspunktet er vertsnavnet og portnummeret for AMQP-endepunktet ukjent, så de må injiseres. Endepunktet kan settes i konfigurasjonskartet som er opprettet av AMQ Online, så vi vil definere dem gjennom miljøvariabler i applikasjonsmanifestet:
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
Legitimasjon
Tjenestekontotokenet kan brukes til å autentisere applikasjonen vår til OpenShift. For å gjøre dette må du først opprette en egendefinert ConfigSource som vil lese autentiseringstokenet fra podens filsystem:
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);
}
}
Bygg og distribuer applikasjonen
Siden applikasjonen må kompileres til en kjørbar fil, kreves en virtuell GraalVM-maskin. For detaljer om hvordan du setter opp et miljø for dette, se de tilsvarende instruksjonene i .
Deretter, ved å følge instruksjonene gitt der, må du laste ned kilden, bygge og distribuere applikasjonen vår:
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
Etter disse kommandoene vil applikasjonen bli distribuert, men vil ikke starte før vi konfigurerer meldingsressursene vi trenger i AMQ Online.
Sette opp meldingssystemet
Nå gjenstår det bare å sette inn ressursene som applikasjonen vår trenger i meldingssystemet. For å gjøre dette må du opprette: 1) et adresseområde for å initialisere meldingssystemets endepunkt; 2) adresse for å konfigurere adressene vi bruker i applikasjonen; 3) Meldingsbruker for å angi klientlegitimasjon.
Adresseplass
Et AddressSpace-objekt i AMQ Online er en gruppe adresser som deler tilkoblingsendepunkter og autentiserings- og autorisasjonspolicyer. Når du oppretter et adresseområde, kan du spesifisere hvordan meldingsendepunkter skal eksponeres:
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
adresse
Adresser brukes til å sende og motta meldinger. Hver adresse har en type som bestemmer dens semantikk, samt en plan som spesifiserer antall ressurser som skal reserveres. Adressen kan for eksempel bestemmes slik:
apiVersion: enmasse.io/v1beta1
kind: Address
metadata:
name: quarkus-example.orders
spec:
address: orders
type: queue
plan: brokered-queue
Meldingsbruker
For å sikre at bare klarerte applikasjoner kan sende og motta meldinger til adressene dine, må du opprette en bruker i meldingssystemet. For applikasjoner som kjører på en klynge, kan klienter autentiseres ved hjelp av en OpenShift-tjenestekonto. Brukeren "tjenestekonto" kan for eksempel defineres slik:
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"]
Tillatelser til å konfigurere applikasjonen
For at AMQ Online skal lage konfigurasjonskartet som vi brukte til å bygge inn AMQP-endepunktinformasjonen, må rollen og rollebindingen settes:
---
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
Slik bruker du konfigurasjoner
Du kan bruke meldingssystemkonfigurasjonen slik:
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
Søknadsverifisering
For å være sikker på at applikasjonen har startet, la oss først og fremst sjekke om de tilsvarende adressene er opprettet og er aktive:
until [[ `oc get address quarkus-example.prices -o jsonpath='{.status.phase}'` == "Active" ]]; do echo "Not yet ready"; sleep 5; done
La oss så sjekke applikasjonens rute-URL (bare åpne denne adressen i nettleseren):
echo "http://$(oc get route quarkus-example-client -o jsonpath='{.spec.host}')/prices.html"
Nettleseren skal vise at billetter oppdateres med jevne mellomrom ettersom meldinger sendes og mottas av AMQ Online.
Oppsummering
Så vi skrev en Quarkus-applikasjon som bruker AMQP for meldinger, konfigurerte applikasjonen til å kjøre på Red Hat OpenShift-plattformen og implementerte konfigurasjonen basert på AMQ Online-konfigurasjonen. Vi opprettet deretter manifestene som trengs for å initialisere meldingssystemet for applikasjonen vår.
Dette avslutter serien om Quarkus, men det er mye nytt og interessant i vente, følg med!
Kilde: www.habr.com