Ամպային բնիկ հաղորդագրություններ Red Hat OpenShift հարթակում Quarkus-ի և AMQ Online-ի միջոցով

Բարեւ բոլորին! Ահա այն՝ Quarkus շարքի մեր վերջին գրառումը: (Ի դեպ, դիտեք մեր վեբինարը «Սա Quarkus – Kubernetes հայրենի Java շրջանակն է». Մենք ձեզ ցույց կտանք, թե ինչպես սկսել զրոյից կամ փոխանցել պատրաստի լուծումները)

В նախորդ Այս գրառման մեջ մենք դիտեցինք համապատասխան գործիքները, որոնք կարող են օգտագործվել Java հավելվածների արդիականացման արդյունքում ձեռք բերված բարելավումների քանակական գնահատման համար:

0.17.0 տարբերակից սկսած, Քվարկուս աջակցում է Ընդլայնված հաղորդագրությունների հերթագրման արձանագրության օգտագործումը (AMQP), որը բաց ստանդարտ է հավելվածների կամ կազմակերպությունների միջև բիզնես հաղորդագրությունների փոխանցման համար:

Red Hat AMQ Online բաց կոդով նախագծի հիման վրա ստեղծված ծառայություն է EnMasse և հարթակի վրա հիմնված հաղորդագրությունների մեխանիզմի ներդրում Red Hat OpenShift- ը. Լրացուցիչ մանրամասների համար, թե ինչպես է այն աշխատում, տես այստեղ (EN). Այսօր մենք ձեզ ցույց կտանք, թե ինչպես համատեղել AMQ Online-ը և Quarkus-ը՝ ստեղծելով OpenShift-ի վրա հիմնված հաղորդագրությունների փոխանակման ժամանակակից համակարգ՝ օգտագործելով երկու նոր հաղորդագրությունների տեխնոլոգիաներ:

Ենթադրվում է, որ դուք արդեն տեղակայել եք AMQ Online-ը OpenShift հարթակում (եթե ոչ, ապա տես. տեղադրման ուղեցույց).

Սկսելու համար մենք կստեղծենք Quarkus հավելված, որը կլինի պատվերների մշակման պարզ համակարգ՝ օգտագործելով ռեակտիվ հաղորդագրություններ: Այս հավելվածը կներառի պատվերների գեներատոր, որը պատվերներ է ուղարկում հաղորդագրությունների հերթին ֆիքսված ընդմիջումով, ինչպես նաև պատվերի մշակող, որը կմշակի հաղորդագրությունները հերթից և կստեղծի հաստատումներ, որոնք տեսանելի կլինեն դիտարկիչում:

Երբ մենք ստեղծենք հավելվածը, մենք ձեզ ցույց կտանք, թե ինչպես ներդնել հաղորդագրությունների համակարգի կազմաձևումը հավելվածում և օգտագործել AMQ Online՝ համակարգում մեզ անհրաժեշտ ռեսուրսները ապահովելու համար:

Quarkus հավելված

Մեր Quarkus հավելվածն աշխատում է OpenShift-ով և հանդիսանում է ծրագրի փոփոխված տարբերակը amqp-quickstart. Հաճախորդի կողմի ամբողջական օրինակ կարելի է գտնել այստեղ.

Պատվերի գեներատոր

Գեներատորը պարզապես միապաղաղ կերպով յուրաքանչյուր 5 վայրկյանը մեկ ուղարկում է աճող պատվերի ID-ներ «պատվերների» հասցեին:

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

Պատվերների մշակող

Պատվերների մշակիչը նույնիսկ ավելի պարզ է, այն պարզապես վերադարձնում է հաստատման ID-ն «հաստատումների» հասցեին:

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

Հաստատման ռեսուրսներ

Հաստատման ռեսուրսը HTTP վերջնակետ է՝ մեր հավելվածի կողմից ստեղծված հաստատումները ցուցակագրելու համար:

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

հարմարեցում

AMQ Online-ին միանալու համար մեր հավելվածին անհրաժեշտ կլինեն որոշ կոնֆիգուրացիայի տվյալներ, մասնավորապես՝ Quarkus միակցիչի կազմաձևումը, AMQP-ի վերջնական կետի տեղեկատվությունը և հաճախորդի հավատարմագրերը: Իհարկե, ավելի լավ է կոնֆիգուրացիայի բոլոր տվյալները պահել մեկ տեղում, բայց մենք միտումնավոր կառանձնացնենք դրանք՝ ցույց տալու Quarkus հավելվածի կազմաձևման հնարավոր տարբերակները։

Միակցիչներ

Միակցիչի կոնֆիգուրացիան կարող է տրամադրվել կոմպիլյացիայի ժամանակ՝ օգտագործելով հավելվածի հատկությունների ֆայլը.

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

Ամեն ինչ պարզ պահելու համար մենք կօգտագործենք միայն «պատվերների» հասցեի հաղորդագրությունների հերթ: Իսկ մեր հավելվածի «հաստատումների» հասցեն հիշողության մեջ կօգտագործի հերթ:

AMQP վերջնակետ

Կազմման ժամանակ AMQP վերջնակետի հոսթի անունը և պորտի համարը անհայտ են, ուստի դրանք պետք է ներարկվեն: Վերջնական կետը կարող է սահմանվել AMQ Online-ի կողմից ստեղծված կազմաձևման քարտեզում, ուստի մենք դրանք կսահմանենք հավելվածի մանիֆեստում շրջակա միջավայրի փոփոխականների միջոցով.

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

Հավատարմագրեր

Ծառայության հաշվի նշանը կարող է օգտագործվել մեր դիմումը OpenShift-ում նույնականացնելու համար: Դա անելու համար նախ պետք է ստեղծեք հատուկ ConfigSource, որը կկարդա նույնականացման նշանը 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);
    }
}

Կառուցեք և տեղակայեք հավելվածը

Քանի որ հավելվածը պետք է կազմվի գործարկվող ֆայլի մեջ, անհրաժեշտ է GraalVM վիրտուալ մեքենա: Մանրամասների համար, թե ինչպես ստեղծել դրա համար միջավայր, տե՛ս համապատասխան հրահանգները Quarkus ուղեցույց.

Այնուհետև, հետևելով այնտեղ տրված հրահանգներին, դուք պետք է ներբեռնեք աղբյուրը, կառուցեք և տեղակայեք մեր հավելվածը.

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

Այս հրամաններից հետո հավելվածը կտեղակայվի, բայց չի գործարկվի, քանի դեռ չենք կարգավորել մեզ անհրաժեշտ հաղորդագրությունների ռեսուրսները AMQ Online-ում:

Հաղորդագրությունների համակարգի կարգավորում

Այժմ մնում է միայն տեղադրել այն ռեսուրսները, որոնք անհրաժեշտ են մեր հավելվածին հաղորդագրությունների համակարգում: Դա անելու համար անհրաժեշտ է ստեղծել. 1) հասցե՝ հավելվածում օգտագործվող հասցեները կարգավորելու համար. 2) Օգտատիրոջ հաղորդագրություններ՝ հաճախորդի հավատարմագրերը սահմանելու համար:

Հասցեների տարածություն

AMQ Online-ում AddressSpace օբյեկտը հասցեների խումբ է, որոնք կիսում են կապի վերջնակետերը և նույնականացման ու թույլտվության քաղաքականությունը: Հասցեների տարածք ստեղծելիս կարող եք նշել, թե ինչպես են բացահայտվելու հաղորդագրությունների վերջնակետերը.

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

Հասցեներ

Հասցեները օգտագործվում են հաղորդագրություններ ուղարկելու և ստանալու համար: Յուրաքանչյուր հասցե ունի իր տեսակը, որը որոշում է դրա իմաստաբանությունը, ինչպես նաև պլան, որը նշում է ռեսուրսների քանակը, որոնք պետք է պահպանվեն: Հասցեն կարելի է որոշել, օրինակ, այսպես.

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

Հաղորդագրությունների օգտատեր

Ապահովելու համար, որ միայն վստահելի հավելվածները կարող են ուղարկել և ստանալ հաղորդագրություններ ձեր հասցեներով, դուք պետք է օգտատեր ստեղծեք հաղորդագրությունների համակարգում: Կլաստերի վրա աշխատող հավելվածների համար հաճախորդները կարող են նույնականացվել՝ օգտագործելով OpenShift ծառայության հաշիվը: Օգտագործողի «ծառայության հաշիվը» կարող է սահմանվել, օրինակ, այսպես.

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

Հավելվածը կարգավորելու թույլտվություններ

Որպեսզի AMQ Online-ը ստեղծի այն կազմաձևը, որը մենք օգտագործել ենք AMQP վերջնակետի տեղեկատվությունը ներկառուցելու համար, Role-ը և 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

Ինչպես կիրառել կոնֆիգուրացիաներ

Դուք կարող եք կիրառել հաղորդագրությունների համակարգի կազմաձևումը հետևյալ կերպ.

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

Դիմումի ստուգում

Համոզվելու համար, որ հավելվածը մեկնարկել է, նախ ստուգենք, արդյոք համապատասխան հասցեները ստեղծվել են և ակտիվ են.

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

Այնուհետև եկեք ստուգենք հավելվածի երթուղու URL-ը (պարզապես բացեք այս հասցեն բրաուզերում).

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

Բրաուզերը պետք է ցույց տա, որ տոմսերը պարբերաբար թարմացվում են, երբ հաղորդագրություններն ուղարկվում և ստացվում են AMQ Online-ի կողմից:

Ամփոփելով

Այսպիսով, մենք գրեցինք Quarkus հավելված, որն օգտագործում է AMQP հաղորդագրությունների փոխանակման համար, կազմաձևեցինք հավելվածը, որպեսզի այն աշխատի Red Hat OpenShift հարթակում և իրականացրեցինք դրա կազմաձևը՝ հիմնված AMQ Online կոնֆիգուրացիայի վրա: Այնուհետև մենք ստեղծեցինք մանիֆեստներ, որոնք անհրաժեշտ էին մեր հավելվածի համար հաղորդագրությունների համակարգը սկզբնավորելու համար:

Սրանով ավարտվում է Quarkus-ի մասին շարքը, բայց առջևում շատ նոր և հետաքրքիր բաներ կան, հետևեք:

Source: www.habr.com