Molnbaserad meddelandehantering på Red Hat OpenShift-plattformen med hjälp av Quarkus och AMQ Online

Hej alla! Här är det – vårt sista inlägg i serien om Quarkus! (Förresten, kolla in vårt webbinarie «Detta är Quarkus – en Kubernetes-nativ Java-ramverk». Vi visar hur man börjar «från grunden» eller flyttar befintliga lösningar)

I föregående i detta inlägg kommer vi att titta på relevanta verktyg som kan användas för att kvantitativt utvärdera förbättringar som gjorts genom modernisering av Java-applikationer.

Från och med version 0.17.0, Quarkus stöder användningen av Advanced Message Queuing Protocol (AMQP), vilket är en öppen standard för överföring av affärsmeddelanden mellan applikationer eller organisationer.

Red Hat AMQ Online är en tjänst byggd på den öppna projektet EnMasse och implementerar en meddelandeutbytesmekanism baserad på plattformen Red Hat OpenShift. För mer information om hur den är uppbyggd, se. här (EN). Idag visar vi hur man kombinerar AMQ Online och Quarkus för att bygga ett modernt meddelandeutbyten-system på OpenShift med hjälp av två nya teknologier relaterade till meddelandehantering.

Det förutsätts att du redan har implementerat AMQ Online på OpenShift-plattformen (om inte, se. installationsguiden).

Först kommer vi att skapa en Quarkus-applikation som kommer att vara ett enkelt system för orderhantering med reaktiv meddelandeutbyte. Denna applikation kommer att inkludera en ordergenerator som skickar beställningar till meddelandekön med fast intervall, samt en orderhanterare som kommer att behandla meddelanden från kön och skapa bekräftelser som är tillgängliga för visning i webbläsaren.

Efter att applikationen har skapats kommer vi att visa hur man implementerar meddelandeutbyteskonfigurationen och använder AMQ Online för att initiera de resurser vi behöver på detta system.

Quarkus-applikationen

Vår Quarkus-applikation körs på OpenShift och är en modifierad version av programmet amqp-quickstart. Ett komplett exempel på klientsidan kan hittas här.

Ordergeneratorn

Generatorn skickar varor med växande order-ID var femte sekund till adressen 'orders'.

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

Orderhanteraren

Orderhanteraren är ännu enklare; den returnerar bara bekräftelse-ID:t till adressen 'confirmations'.

@ApplicationScoped
public class OrderProcessor {
    @Incoming("orders")
    @Outgoing("confirmations")
    public Integer process(Integer order) {
        // Bekräftelse-ID är dubbelt så stort som order-ID <img draggable="false" class="emoji" alt=":-)" src="https://s.w.org/images/core/emoji/11.2.0/svg/1f642.svg">
        return order * 2;
    }
}

Bekräftelseresurser

Bekräftelsepunkten är en HTTP-slutpunkt för att lista de bekräftelser som genereras av vår applikation.

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

Inställning

För att ansluta till AMQ Online behöver vår applikation viss konfigurationsdata, nämligen: konfiguration av Quarkus-anslutning, information om AMQP-slutpunkten och klientcredentialer. Det är bäst att hålla all konfigurationsdata på ett ställe, men vi kommer avsiktligt att dela upp dem för att visa möjliga alternativ för att konfigurera Quarkus-applikationen.

Anslutningar

Konfigurationen av anslutningen kan ges vid kompileringstiden med hjälp av en applikationsegenskaper fil:

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

För att underlätta kommer vi att använda en meddelandekö endast för adressen "orders". Adressen "confirmations" i vår applikation kommer att använda en minneskö.

AMQP Slutpunkt

Vid kompilering är värdnamnet och portnumret för AMQP-slutpunkten okända, så de måste injiceras. Slutpunkten kan definieras i en configmap som skapas av AMQ Online, så vi kommer att definiera dem genom miljövariabler i applikationens manifest:

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

Credentialer

En tjänstkonto-token kan användas för att autentisera vår applikation i OpenShift. För detta måste vi först skapa en anpassad ConfigSource som läser autentiseringstoken från podden filsystem:

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

Byggande och distribution av applikationen

Eftersom applikationen måste kompileras till en körbar fil, behövs en virtuell maskin av GraalVM. För mer information om hur du konfigurerar miljön för detta, se relevanta instruktioner i Quarkus Guide.

Följ sedan instruktionerna där för att ladda ner källkoden, bygga och distribuera vår applikation:

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

Efter dessa kommandon kommer applikationen att vara distribuerad, men den kommer inte att starta förrän vi har konfigurerat de nödvändiga resurserna för meddelandehantering i AMQ Online.

Konfiguration av meddelandesystem

Nu återstår det att specificera de resurser som vårt applikation behöver i meddelandesystemet. För detta måste du skapa: 1) ett adressutrymme för att initiera en slutpunkt för meddelandesystemet; 2) en adress för att konfigurera adresserna vi använder i applikationen; 3) en användare för meddelandesystemet för att ange klientens autentiseringsuppgifter.

Adressutrymme

Objektet AddressSpace i AMQ Online är en grupp adresser som gemensamt använder slutpunkterna för anslutning samt autentiserings- och auktoriseringspolicyer. När du skapar ett adressutrymme kan du specificera hur slutpunkterna för meddelandesystemet kommer att tillhandahållas:

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

Adresser

Adresser används för att skicka och ta emot meddelanden. Varje adress har en typ som definierar dess betydelse samt en plan som anger mängden reserverade resurser. En adress kan definieras så här:

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

Användare i meddelandesystemet

För att endast betrodda applikationer ska kunna skicka och ta emot meddelanden på dina adresser, måste en användare skapas i meddelandesystemet. För applikationer som körs på klustret kan kunder autentiseras med hjälp av ett OpenShift-tjänstekonto. Användaren "serviceaccount" kan definieras så här:

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

Behörigheter för att konfigurera applikationen

För att AMQ Online ska kunna skapa en configmap, som vi använde för att införa uppgifter om AMQP-endpunkten, måste en roll och en rollbindning (Role och RoleBinding) definieras:

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

Hur man tillämpar konfigurationer

Konfigurationen av meddelandesystemet kan tillämpas så här:

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

Verifiering av applikationen

För att säkerställa att applikationen har startat, låt oss först kontrollera om respektive adresser har skapats och är aktiva:

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

Därefter kontrollerar vi URL:en för applikationens rutt (vi öppnar helt enkelt denna adress i webbläsaren):

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

I webbläsaren ska man kunna se att biljetterna uppdateras regelbundet i takt med att meddelanden skickas och tas emot av AMQ Online.

Sammanfattning

Så, vi har skrivit en Quarkus-applikation som använder AMQP för meddelandeutbyte, ställt in denna applikation för att fungera på Red Hat OpenShift-plattformen, samt implementerat dess konfiguration baserat på AMQ Online-konfigurationen. Vi har sedan skapat de manifest som behövs för att initiera meddelandesystemet för vår applikation.

Med detta avslutar vi serien om Quarkus, men det ligger mycket nytt och intressant framför oss, stanna kvar med oss!

Källa: habr.com