ღრუბლოვანი შეტყობინებები Red Hat OpenShift პლატფორმაზე Quarkus-ისა და AMQ Online-ის გამოყენებით

Სალამი ყველას! აი ეს არის ჩვენი ბოლო პოსტი Quarkus-ის სერიაში! (სხვათა შორის, უყურეთ ჩვენს ვებინარს "ეს არის Quarkus - Kubernetes მშობლიური Java Framework". ჩვენ გაჩვენებთ, თუ როგორ უნდა დაიწყოთ ნულიდან ან გადაიტანოთ მზა გადაწყვეტილებები)

В წინა ამ პოსტში ჩვენ გადავხედეთ შესაბამის ინსტრუმენტებს, რომლებიც შეიძლება გამოყენებულ იქნას ჯავის აპლიკაციების მოდერნიზაციის შედეგად მიღებული გაუმჯობესებების რაოდენობრივად დასადგენად.

0.17.0 ვერსიიდან, კვარკუსი მხარს უჭერს Advanced Message Queuing Protocol-ის გამოყენებას (AMQP), რომელიც არის ღია სტანდარტი აპლიკაციებსა თუ ორგანიზაციებს შორის ბიზნეს შეტყობინებების გადასატანად.

Red Hat AMQ ონლაინ არის სერვისი, რომელიც აგებულია ღია კოდის პროექტის საფუძველზე EnMasse და პლატფორმაზე დაფუძნებული შეტყობინებების მექანიზმის დანერგვა Red Hat OpenShift. დამატებითი ინფორმაციისთვის, თუ როგორ მუშაობს, იხილეთ აქ (EN). დღეს ჩვენ გაჩვენებთ, თუ როგორ დააკავშიროთ AMQ Online და Quarkus, რათა ავაშენოთ თანამედროვე OpenShift-ზე დაფუძნებული შეტყობინებების სისტემა ორი ახალი შეტყობინებების ტექნოლოგიის გამოყენებით.

ვარაუდობენ, რომ თქვენ უკვე განათავსეთ AMQ Online OpenShift პლატფორმაზე (თუ არა, მაშინ იხ. ინსტალაციის სახელმძღვანელო).

დასაწყისისთვის, ჩვენ შევქმნით Quarkus-ის აპლიკაციას, რომელიც იქნება შეკვეთის დამუშავების მარტივი სისტემა რეაქტიული შეტყობინებების გამოყენებით. ეს აპლიკაცია მოიცავს შეკვეთის გენერატორს, რომელიც აგზავნის შეკვეთებს შეტყობინებების რიგში ფიქსირებული ინტერვალით, ასევე შეკვეთის პროცესორს, რომელიც დაამუშავებს შეტყობინებებს რიგიდან და გამოიმუშავებს დადასტურებებს, რომლებიც ხილვადია ბრაუზერში.

მას შემდეგ რაც შევქმნით აპლიკაციას, ჩვენ გაჩვენებთ, თუ როგორ უნდა ჩართოთ შეტყობინებების სისტემის კონფიგურაცია აპლიკაციაში და გამოიყენოთ AMQ Online სისტემაში საჭირო რესურსების უზრუნველსაყოფად.

Quarkus აპლიკაცია

ჩვენი Quarkus აპლიკაცია მუშაობს OpenShift-ზე და არის პროგრამის შეცვლილი ვერსია amqp-სწრაფი დაწყება. შეგიძლიათ იპოვოთ კლიენტის მხარის სრული მაგალითი აქ.

შეკვეთის გენერატორი

გენერატორი უბრალოდ მონოტონურად აგზავნის მზარდი შეკვეთის ID-ებს „შეკვეთების“ მისამართზე ყოველ 5 წამში.

@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 ვირტუალური მანქანა. დეტალებისთვის, თუ როგორ უნდა შეიქმნას გარემო ამისათვის, იხილეთ შესაბამისი ინსტრუქციები კვარკუსის გზამკვლევი.

შემდეგ, იქ მოცემული ინსტრუქციების შემდეგ, თქვენ უნდა ჩამოტვირთოთ წყარო, ააწყოთ და განათავსოთ ჩვენი აპლიკაცია:

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) მისამართი იმ მისამართების კონფიგურაციისთვის, რომელსაც ჩვენ ვიყენებთ აპლიკაციაში; 3) მომხმარებლის შეტყობინებების გაგზავნა კლიენტის რწმუნებათა სიგელების დასაყენებლად.

მისამართების სივრცე

AddressSpace ობიექტი AMQ Online-ში არის მისამართების ჯგუფი, რომლებიც იზიარებენ კავშირის ბოლო წერტილებს და ავთენტიფიკაციისა და ავტორიზაციის პოლიტიკას. როდესაც თქვენ შექმნით მისამართთა სივრცეს, შეგიძლიათ მიუთითოთ, თუ როგორ გამოჩნდება შეტყობინებების საბოლოო წერტილები:

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 საბოლოო წერტილის ინფორმაციის ჩასართავად, როლი და როლი Binding უნდა იყოს მითითებული:

---
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-ის შესახებ, მაგრამ წინ ბევრი ახალი და საინტერესო რამ გველის, თვალი ადევნეთ!

წყარო: www.habr.com