ಕ್ವಾರ್ಕಸ್ ಮತ್ತು AMQ ಆನ್‌ಲೈನ್ ಬಳಸಿಕೊಂಡು Red Hat OpenShift ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ಕ್ಲೌಡ್-ಸ್ಥಳೀಯ ಸಂದೇಶ ಕಳುಹಿಸುವಿಕೆ

ಎಲ್ಲರಿಗು ನಮಸ್ಖರ! ಇದು ಇಲ್ಲಿದೆ - ಕ್ವಾರ್ಕಸ್ ಸರಣಿಯಲ್ಲಿ ನಮ್ಮ ಅಂತಿಮ ಪೋಸ್ಟ್! (ಅಂದಹಾಗೆ, ನಮ್ಮ ವೆಬ್ನಾರ್ ಅನ್ನು ವೀಕ್ಷಿಸಿ "ಇದು ಕ್ವಾರ್ಕಸ್ - ಕುಬರ್ನೆಟ್ಸ್ ಸ್ಥಳೀಯ ಜಾವಾ ಚೌಕಟ್ಟು". ಮೊದಲಿನಿಂದ ಹೇಗೆ ಪ್ರಾರಂಭಿಸುವುದು ಅಥವಾ ಸಿದ್ಧ ಪರಿಹಾರಗಳನ್ನು ವರ್ಗಾಯಿಸುವುದು ಹೇಗೆ ಎಂದು ನಾವು ನಿಮಗೆ ತೋರಿಸುತ್ತೇವೆ)

В ಹಿಂದಿನ ಈ ಪೋಸ್ಟ್‌ನಲ್ಲಿ, ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಆಧುನೀಕರಿಸುವ ಪರಿಣಾಮವಾಗಿ ಪಡೆದ ಸುಧಾರಣೆಗಳನ್ನು ಪ್ರಮಾಣೀಕರಿಸಲು ಬಳಸಬಹುದಾದ ಸಂಬಂಧಿತ ಸಾಧನಗಳನ್ನು ನಾವು ನೋಡಿದ್ದೇವೆ.

ಆವೃತ್ತಿ 0.17.0 ರಿಂದ, ಕ್ವಾರ್ಕಸ್ ಸುಧಾರಿತ ಸಂದೇಶ ಕ್ಯೂಯಿಂಗ್ ಪ್ರೋಟೋಕಾಲ್ ಬಳಕೆಯನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ (AMQP), ಇದು ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಅಥವಾ ಸಂಸ್ಥೆಗಳ ನಡುವೆ ವ್ಯಾಪಾರ ಸಂದೇಶಗಳನ್ನು ವರ್ಗಾಯಿಸಲು ಮುಕ್ತ ಮಾನದಂಡವಾಗಿದೆ.

Red Hat AMQ ಆನ್‌ಲೈನ್ ತೆರೆದ ಮೂಲ ಯೋಜನೆಯ ಆಧಾರದ ಮೇಲೆ ನಿರ್ಮಿಸಲಾದ ಸೇವೆಯಾಗಿದೆ ಸಾಮೂಹಿಕವಾಗಿ ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್-ಆಧಾರಿತ ಸಂದೇಶ ಕಳುಹಿಸುವಿಕೆಯ ಕಾರ್ಯವಿಧಾನವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು Red Hat ಓಪನ್‌ಶಿಫ್ಟ್. ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ಹೆಚ್ಚಿನ ವಿವರಗಳಿಗಾಗಿ, ನೋಡಿ ಇಲ್ಲಿ (EN). ಎರಡು ಹೊಸ ಮೆಸೇಜಿಂಗ್ ತಂತ್ರಜ್ಞಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಆಧುನಿಕ ಓಪನ್‌ಶಿಫ್ಟ್-ಆಧಾರಿತ ಸಂದೇಶ ಕಳುಹಿಸುವ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸಲು AMQ ಆನ್‌ಲೈನ್ ಮತ್ತು ಕ್ವಾರ್ಕಸ್ ಅನ್ನು ಹೇಗೆ ಸಂಯೋಜಿಸುವುದು ಎಂಬುದನ್ನು ಇಂದು ನಾವು ನಿಮಗೆ ತೋರಿಸುತ್ತೇವೆ.

ನೀವು ಈಗಾಗಲೇ OpenShift ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ AMQ ಆನ್‌ಲೈನ್ ಅನ್ನು ನಿಯೋಜಿಸಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸಲಾಗಿದೆ (ಇಲ್ಲದಿದ್ದರೆ, ನಂತರ ನೋಡಿ ಅನುಸ್ಥಾಪನ ಮಾರ್ಗದರ್ಶಿ).

ಪ್ರಾರಂಭಿಸಲು, ನಾವು ಕ್ವಾರ್ಕಸ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಅದು ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಸಂದೇಶ ಕಳುಹಿಸುವಿಕೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸರಳ ಆರ್ಡರ್ ಪ್ರಕ್ರಿಯೆ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ. ಈ ಅಪ್ಲಿಕೇಶನ್ ಆರ್ಡರ್ ಜನರೇಟರ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಅದು ಸ್ಥಿರ ಮಧ್ಯಂತರದಲ್ಲಿ ಸಂದೇಶ ಸರತಿಗೆ ಆದೇಶಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ, ಹಾಗೆಯೇ ಸರದಿಯಿಂದ ಸಂದೇಶಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಮತ್ತು ಬ್ರೌಸರ್‌ನಲ್ಲಿ ವೀಕ್ಷಿಸಬಹುದಾದ ದೃಢೀಕರಣಗಳನ್ನು ರಚಿಸುವ ಆರ್ಡರ್ ಪ್ರೊಸೆಸರ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

ಒಮ್ಮೆ ನಾವು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಿದ ನಂತರ, ಮೆಸೇಜಿಂಗ್ ಸಿಸ್ಟಮ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಹೇಗೆ ಎಂಬೆಡ್ ಮಾಡುವುದು ಮತ್ತು ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ನಮಗೆ ಅಗತ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಒದಗಿಸಲು AMQ ಆನ್‌ಲೈನ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ನಾವು ನಿಮಗೆ ತೋರಿಸುತ್ತೇವೆ.

ಕ್ವಾರ್ಕಸ್ ಅಪ್ಲಿಕೇಶನ್

ನಮ್ಮ ಕ್ವಾರ್ಕಸ್ ಅಪ್ಲಿಕೇಶನ್ OpenShift ನಲ್ಲಿ ರನ್ ಆಗುತ್ತದೆ ಮತ್ತು ಇದು ಪ್ರೋಗ್ರಾಂನ ಮಾರ್ಪಡಿಸಿದ ಆವೃತ್ತಿಯಾಗಿದೆ amqp-ಕ್ವಿಕ್‌ಸ್ಟಾರ್ಟ್. ಕ್ಲೈಂಟ್ ಸೈಡ್ನ ಸಂಪೂರ್ಣ ಉದಾಹರಣೆಯನ್ನು ಕಾಣಬಹುದು ಇಲ್ಲಿ.

ಆರ್ಡರ್ ಜನರೇಟರ್

ಜನರೇಟರ್ ಸರಳವಾಗಿ ಏಕತಾನತೆಯಿಂದ ಬೆಳೆಯುತ್ತಿರುವ ಆರ್ಡರ್ ಐಡಿಗಳನ್ನು "ಆರ್ಡರ್‌ಗಳು" ವಿಳಾಸಕ್ಕೆ ಪ್ರತಿ 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 ಆನ್‌ಲೈನ್‌ನಲ್ಲಿನ ಅಡ್ರೆಸ್‌ಸ್ಪೇಸ್ ಆಬ್ಜೆಕ್ಟ್ ಸಂಪರ್ಕದ ಅಂತಿಮ ಬಿಂದುಗಳು ಮತ್ತು ದೃಢೀಕರಣ ಮತ್ತು ದೃಢೀಕರಣ ನೀತಿಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳುವ ವಿಳಾಸಗಳ ಗುಂಪಾಗಿದೆ. ನೀವು ವಿಳಾಸ ಸ್ಥಳವನ್ನು ರಚಿಸಿದಾಗ, ಸಂದೇಶ ಕಳುಹಿಸುವಿಕೆಯ ಅಂತಿಮ ಬಿಂದುಗಳನ್ನು ಹೇಗೆ ಬಹಿರಂಗಪಡಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು:

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

ಸಂದೇಶ ಕಳುಹಿಸುವ ಬಳಕೆದಾರರು

ವಿಶ್ವಾಸಾರ್ಹ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮಾತ್ರ ನಿಮ್ಮ ವಿಳಾಸಗಳಿಗೆ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಬಹುದು ಮತ್ತು ಸ್ವೀಕರಿಸಬಹುದು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, ನೀವು ಸಂದೇಶ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಬಳಕೆದಾರರನ್ನು ರಚಿಸಬೇಕು. ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ, ಓಪನ್‌ಶಿಫ್ಟ್ ಸೇವಾ ಖಾತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ಲೈಂಟ್‌ಗಳನ್ನು ದೃಢೀಕರಿಸಬಹುದು. ಬಳಕೆದಾರ "ಸೇವಾ ಖಾತೆ" ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, ಈ ರೀತಿ:

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 ಆನ್‌ಲೈನ್ ರಚಿಸಲು, ಪಾತ್ರ ಮತ್ತು ರೋಲ್‌ಬೈಂಡಿಂಗ್ ಅನ್ನು ಹೊಂದಿಸಬೇಕು:

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