Wolkgebaseerde boodskappe op die Red Hat OpenShift-platform met Quarkus en AMQ Online

Hi almal! Hier is dit - ons laaste plasing in die Quarkus-reeks! (Terloops, kyk na ons webinar "Dit is Quarkus - Kubernetes inheemse Java-raamwerk". Ons sal jou wys hoe om van voor af te begin of klaargemaakte oplossings oor te dra)

Wolkgebaseerde boodskappe op die Red Hat OpenShift-platform met Quarkus en AMQ Online

В vorige In hierdie pos het ons gekyk na die relevante gereedskap wat gebruik kan word om die verbeterings wat verkry is as gevolg van die modernisering van Java-toepassings te kwantifiseer.

Sedert weergawe 0.17.0, Kwark ondersteun die gebruik van Advanced Message Queuing Protocol (AMQP), wat 'n oop standaard is vir die oordrag van besigheidsboodskappe tussen toepassings of organisasies.

Red Hat AMQ Aanlyn is 'n diens gebou op die basis van 'n oopbronprojek In hul massas en die implementering van 'n platform-gebaseerde boodskapmeganisme RedHat OpenShift. Vir meer besonderhede oor hoe dit werk, sien hier (EN). Vandag sal ons jou wys hoe om AMQ Online en Quarkus te kombineer om 'n moderne OpenShift-gebaseerde boodskapstelsel te bou deur twee nuwe boodskaptegnologieë te gebruik.

Daar word aanvaar dat jy reeds AMQ Online op die OpenShift-platform ontplooi het (indien nie, sien dan installasie gids).

Om te begin, sal ons 'n Quarkus-toepassing skep wat 'n eenvoudige bestelverwerkingstelsel sal wees wat reaktiewe boodskappe gebruik. Hierdie toepassing sal 'n bestellinggenerator insluit wat bestellings na 'n boodskapwaglys op 'n vaste interval stuur, sowel as 'n bestellingverwerker wat boodskappe vanaf die tou sal verwerk en bevestigings genereer wat in die blaaier besigtig kan word.

Sodra ons die toepassing geskep het, sal ons jou wys hoe om die boodskapstelselkonfigurasie in die toepassing in te sluit en AMQ Online te gebruik om die hulpbronne wat ons benodig op die stelsel te voorsien.

Quarkus app

Ons Quarkus-toepassing loop op OpenShift en is 'n gewysigde weergawe van die program amqp-vinnige begin. 'n Volledige voorbeeld van die kliëntkant kan gevind word hier.

Bestel kragopwekker

Die kragopwekker stuur eenvoudig eentonig groeiende bestelling ID's na die "bestellings" adres elke 5 sekondes.

@ApplicationScoped
public class OrderGenerator {
 
    private int orderId = 1;
 
    @Outgoing("orders")
    public Flowable<Integer> generate() {
        return Flowable.interval(5, TimeUnit.SECONDS)
        .map(tick -> orderId++);
    }
}

Bestel verwerker

Die bestelling hanteerder is selfs eenvoudiger, dit stuur net 'n bevestiging ID terug na die "bevestigings" adres.

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

Bevestigingshulpbronne

Die bevestigingshulpbron is 'n HTTP-eindpunt vir die lys van die bevestigings wat deur ons toepassing gegenereer word.

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

aanpassing

Om aan AMQ Online te koppel, sal ons toepassing 'n paar konfigurasiedata benodig, naamlik: Quarkus-koppelkonfigurasie, AMQP-eindpuntinligting en kliëntbewyse. Dit is natuurlik beter om al die konfigurasiedata op een plek te hou, maar ons sal hulle doelbewus skei om die moontlike opsies vir die konfigurasie van die Quarkus-toepassing te wys.

Verbindings

Koppelaarkonfigurasie kan tydens samestelling verskaf word deur 'n toepassingseienskappelêer te gebruik:

mp.messaging.outgoing.orders.connector=smallrye-amqp
mp.messaging.incoming.orders.connector=smallrye-amqp

Om dinge eenvoudig te hou, sal ons slegs 'n boodskapwaglys vir die "bestellings"-adres gebruik. En die "bevestigings"-adres in ons aansoek sal 'n tou in die geheue gebruik.

AMQP eindpunt

Tydens samestelling is die gasheernaam en poortnommer vir die AMQP-eindpunt onbekend, dus moet hulle ingespuit word. Die eindpunt kan ingestel word in die configmap wat deur AMQ Online geskep word, so ons sal dit definieer deur omgewingsveranderlikes in die toepassingsmanifes:

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

Geloofsbriewe

Die diensrekeningtoken kan gebruik word om ons toepassing na OpenShift te verifieer. Om dit te doen, moet jy eers 'n pasgemaakte ConfigSource skep wat die verifikasietoken vanaf die pod se lêerstelsel sal lees:

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

Bou en ontplooi die toepassing

Aangesien die toepassing in 'n uitvoerbare lêer saamgestel moet word, word 'n GraalVM virtuele masjien vereis. Vir besonderhede oor hoe om 'n omgewing hiervoor op te stel, sien die ooreenstemmende instruksies in Quarkus Gids.

Dan, volgens die instruksies wat daar gegee word, moet u die bron aflaai, ons toepassing bou en ontplooi:

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

Na hierdie opdragte sal die toepassing ontplooi word, maar sal nie begin voordat ons die boodskaphulpbronne wat ons benodig in AMQ Online opgestel het nie.

Die opstel van die boodskapstelsel

Al wat nou oorbly, is om die hulpbronne wat ons toepassing benodig in die boodskapstelsel in te stel. Om dit te doen, moet jy skep: 1) 'n adresspasie om die boodskapstelsel eindpunt te inisialiseer; 2) adres om die adresse op te stel wat ons in die toepassing gebruik; 3) Boodskappe gebruiker om kliënt geloofsbriewe in te stel.

Adresspasie

'n AddressSpace-objek in AMQ Online is 'n groep adresse wat verbindingseindpunte en verifikasie- en magtigingsbeleide deel. Wanneer jy 'n adresspasie skep, kan jy spesifiseer hoe boodskapeindpunte blootgestel sal word:

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 word gebruik om boodskappe te stuur en te ontvang. Elke adres het 'n tipe wat die semantiek daarvan bepaal, sowel as 'n plan wat die aantal hulpbronne spesifiseer wat gereserveer moet word. Die adres kan byvoorbeeld soos volg bepaal word:

apiVersion: enmasse.io/v1beta1
kind: Address
metadata:
  name: quarkus-example.orders
spec:
  address: orders
  type: queue
  plan: brokered-queue

Boodskap gebruiker

Om te verseker dat slegs vertroude toepassings boodskappe na jou adresse kan stuur en ontvang, moet jy 'n gebruiker in die boodskapstelsel skep. Vir toepassings wat op 'n groepering loop, kan kliënte geverifieer word met 'n OpenShift-diensrekening. Die gebruiker "diensrekening" kan byvoorbeeld soos volg gedefinieer word:

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"]

Toestemmings om die toepassing op te stel

Om AMQ Online die konfigurasiekaart te skep wat ons gebruik het om die AMQP-eindpuntinligting in te sluit, moet die Rol en Rolbinding gestel word:

---
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

Hoe om konfigurasies toe te pas

U kan die boodskapstelselkonfigurasie soos volg toepas:

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

Aansoek verifikasie

Om seker te maak dat die toepassing begin het, kom ons kyk eers of die ooreenstemmende adresse geskep is en aktief is:

until [[ `oc get address quarkus-example.prices -o jsonpath='{.status.phase}'` == "Active" ]]; do echo "Not yet ready"; sleep 5; done

Kom ons kyk dan na die toepassingsroete-URL (maak net hierdie adres in die blaaier oop):

echo "http://$(oc get route quarkus-example-client -o jsonpath='{.spec.host}')/prices.html"

Die blaaier moet wys dat kaartjies periodiek opgedateer word soos boodskappe deur AMQ Online gestuur en ontvang word.

Opsomming

Ons het dus 'n Quarkus-toepassing geskryf wat AMQP vir boodskappe gebruik, die toepassing gekonfigureer om op die Red Hat OpenShift-platform te loop, en sy konfigurasie geïmplementeer gebaseer op die AMQ Online-konfigurasie. Ons het toe die manifeste geskep wat nodig is om die boodskapstelsel vir ons toepassing te inisialiseer.

Dit sluit die reeks oor Quarkus af, maar daar lê baie nuwe en interessante dinge voor, bly ingeskakel!

Bron: will.com

Voeg 'n opmerking