ક્વાર્કસ અને AMQ ઓનલાઈનનો ઉપયોગ કરીને Red Hat OpenShift પ્લેટફોર્મ પર ક્લાઉડ-આધારિત મેસેજિંગ

કેમ છો બધા! તે અહીં છે - ક્વાર્કસ શ્રેણીમાં અમારી અંતિમ પોસ્ટ! (માર્ગ દ્વારા, અમારી વેબિનાર જુઓ "આ ક્વાર્કસ છે - કુબરનેટીસ મૂળ જાવા ફ્રેમવર્ક". અમે તમને બતાવીશું કે કેવી રીતે શરૂઆતથી શરૂઆત કરવી અથવા તૈયાર સોલ્યુશન ટ્રાન્સફર કેવી રીતે કરવું)

В અગાઉના આ પોસ્ટમાં, અમે જાવા એપ્લીકેશનના આધુનિકીકરણના પરિણામે મેળવેલા સુધારાઓને માપવા માટે ઉપયોગમાં લઈ શકાય તેવા સંબંધિત સાધનો પર ધ્યાન આપ્યું.

આવૃત્તિ 0.17.0 થી, ક્વાર્કસ એડવાન્સ્ડ મેસેજ ક્યુઇંગ પ્રોટોકોલ (AMQP), જે એપ્લીકેશન અથવા સંસ્થાઓ વચ્ચે વ્યવસાયિક સંદેશાઓને સ્થાનાંતરિત કરવા માટેનું એક ખુલ્લું ધોરણ છે.

Red Hat AMQ ઓનલાઇન ઓપન સોર્સ પ્રોજેક્ટના આધારે બનેલ સેવા છે એનમાસે અને પ્લેટફોર્મ-આધારિત મેસેજિંગ મિકેનિઝમનો અમલ કરવો રેડ Hat ઓપનશીફ્ટ. તે કેવી રીતે કાર્ય કરે છે તેના પર વધુ વિગતો માટે, જુઓ અહીં (EN). આજે અમે તમને બતાવીશું કે બે નવી મેસેજિંગ ટેક્નોલોજીનો ઉપયોગ કરીને આધુનિક OpenShift-આધારિત મેસેજિંગ સિસ્ટમ બનાવવા માટે AMQ Online અને Quarkus ને કેવી રીતે જોડવું.

એવું માનવામાં આવે છે કે તમે ઓપનશિફ્ટ પ્લેટફોર્મ પર AMQ ઓનલાઈન પહેલેથી જ જમાવ્યું છે (જો નહીં, તો પછી જુઓ સ્થાપન માર્ગદર્શિકા).

શરૂ કરવા માટે, અમે ક્વાર્કસ એપ્લિકેશન બનાવીશું જે પ્રતિક્રિયાશીલ મેસેજિંગનો ઉપયોગ કરીને એક સરળ ઓર્ડર પ્રોસેસિંગ સિસ્ટમ હશે. આ એપ્લિકેશનમાં ઓર્ડર જનરેટર શામેલ હશે જે એક નિશ્ચિત અંતરાલ પર સંદેશ કતારમાં ઓર્ડર મોકલે છે, તેમજ ઓર્ડર પ્રોસેસર કે જે કતારમાંથી સંદેશાઓ પર પ્રક્રિયા કરશે અને બ્રાઉઝરમાં જોઈ શકાય તેવા પુષ્ટિકરણો જનરેટ કરશે.

એકવાર અમે એપ્લિકેશન બનાવી લીધા પછી, અમે તમને બતાવીશું કે એપ્લિકેશનમાં મેસેજિંગ સિસ્ટમ ગોઠવણી કેવી રીતે એમ્બેડ કરવી અને સિસ્ટમ પર અમને જરૂરી સંસાધનોની જોગવાઈ કરવા માટે AMQ ઑનલાઇનનો ઉપયોગ કરવો.

ક્વાર્કસ એપ્લિકેશન

અમારી ક્વાર્કસ એપ્લિકેશન 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 ઓનલાઈન સાથે જોડાવા માટે, અમારી એપ્લિકેશનને કેટલાક રૂપરેખાંકન ડેટાની જરૂર પડશે, જેમ કે: ક્વાર્કસ કનેક્ટર ગોઠવણી, AMQP એન્ડપોઇન્ટ માહિતી અને ક્લાયંટ ઓળખપત્ર. અલબત્ત, તમામ રૂપરેખાંકન ડેટાને એક જ જગ્યાએ રાખવું વધુ સારું છે, પરંતુ ક્વાર્કસ એપ્લિકેશનને ગોઠવવા માટેના સંભવિત વિકલ્પો બતાવવા માટે અમે તેમને જાણીજોઈને અલગ કરીશું.

કનેક્ટર્સ

એપ્લિકેશન પ્રોપર્ટીઝ ફાઇલનો ઉપયોગ કરીને કમ્પાઇલ સમયે કનેક્ટર રૂપરેખાંકન પ્રદાન કરી શકાય છે:

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

વસ્તુઓ સરળ રાખવા માટે, અમે ફક્ત "ઓર્ડર" સરનામા માટે સંદેશ કતારનો ઉપયોગ કરીશું. અને અમારી એપ્લિકેશનમાં "પુષ્ટિ" સરનામું મેમરીમાં કતારનો ઉપયોગ કરશે.

AMQP એન્ડપોઇન્ટ

કમ્પાઇલ સમયે, AMQP એન્ડપોઇન્ટ માટે હોસ્ટનામ અને પોર્ટ નંબર અજ્ઞાત છે, તેથી તેમને ઇન્જેક્ટ કરવું આવશ્યક છે. AMQ ઓનલાઈન દ્વારા બનાવેલ રૂપરેખા મેપમાં એન્ડપોઈન્ટ સેટ કરી શકાય છે, તેથી અમે તેમને એપ્લીકેશન મેનિફેસ્ટમાં પર્યાવરણ ચલો દ્વારા વ્યાખ્યાયિત કરીશું:

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 પર પ્રમાણિત કરવા માટે થઈ શકે છે. આ કરવા માટે, તમારે પહેલા કસ્ટમ કન્ફિગસોર્સ બનાવવું પડશે જે પોડની ફાઈલ સિસ્ટમમાંથી ઓથેન્ટિકેશન ટોકન વાંચશે:

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 ઓનલાઈન માં જરૂરી મેસેજિંગ સંસાધનોને ગોઠવીશું નહીં ત્યાં સુધી તે શરૂ થશે નહીં.

મેસેજિંગ સિસ્ટમ સેટ કરી રહ્યું છે

હવે જે બાકી છે તે સંસાધનોને સેટ કરવાનું છે જેની અમારી એપ્લિકેશનને મેસેજિંગ સિસ્ટમમાં જરૂર છે. આ કરવા માટે, તમારે બનાવવાની જરૂર છે: 1) મેસેજિંગ સિસ્ટમ એન્ડપોઇન્ટ શરૂ કરવા માટે એક સરનામાંની જગ્યા; 2) અમે એપ્લિકેશનમાં જે સરનામાંનો ઉપયોગ કરીએ છીએ તેને ગોઠવવા માટેનું સરનામું; 3) ક્લાયંટ ઓળખપત્રો સેટ કરવા માટે મેસેજિંગ વપરાશકર્તા.

સરનામાંની જગ્યા

AMQ ઓનલાઇનમાં 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"]

એપ્લિકેશનને ગોઠવવાની પરવાનગીઓ

અમે AMQP એન્ડપોઇન્ટ માહિતીને એમ્બેડ કરવા માટે ઉપયોગમાં લીધેલા રૂપરેખા મેપ બનાવવા માટે AMQ Online માટે, ભૂમિકા અને રોલબાઇન્ડિંગ સેટ કરવું આવશ્યક છે:

---
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 ઓનલાઈન દ્વારા સંદેશાઓ મોકલવામાં અને પ્રાપ્ત થાય છે.

એકત્ર કરવું

તેથી અમે ક્વાર્કસ એપ્લિકેશન લખી છે જે મેસેજિંગ માટે AMQP નો ઉપયોગ કરે છે, એપ્લિકેશનને Red Hat OpenShift પ્લેટફોર્મ પર ચલાવવા માટે રૂપરેખાંકિત કરી છે, અને AMQ ઓનલાઈન રૂપરેખાંકન પર આધારિત તેનું રૂપરેખાંકન અમલમાં મૂક્યું છે. અમે પછી અમારી એપ્લિકેશન માટે મેસેજિંગ સિસ્ટમ શરૂ કરવા માટે જરૂરી મેનિફેસ્ટ બનાવ્યાં.

આ ક્વાર્કસ વિશેની શ્રેણીને સમાપ્ત કરે છે, પરંતુ આગળ ઘણી નવી અને રસપ્રદ વસ્તુઓ છે, ટ્યુન રહો!

સોર્સ: www.habr.com