Quarkus ਅਤੇ AMQ ਔਨਲਾਈਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Red Hat OpenShift ਪਲੇਟਫਾਰਮ 'ਤੇ ਕਲਾਉਡ-ਨੇਟਿਵ ਮੈਸੇਜਿੰਗ

ਸਾਰਿਆਂ ਨੂੰ ਸਤਿ ਸ਼੍ਰੀ ਅਕਾਲ! ਇਹ ਇੱਥੇ ਹੈ - ਕੁਆਰਕਸ ਲੜੀ ਵਿੱਚ ਸਾਡੀ ਅੰਤਿਮ ਪੋਸਟ! (ਤਰੀਕੇ ਨਾਲ, ਸਾਡਾ ਵੈਬਿਨਾਰ ਦੇਖੋ "ਇਹ ਕੁਆਰਕਸ ਹੈ - ਕੁਬਰਨੇਟਸ ਨੇਟਿਵ ਜਾਵਾ ਫਰੇਮਵਰਕ". ਅਸੀਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂਗੇ ਕਿ ਕਿਵੇਂ ਸ਼ੁਰੂ ਤੋਂ ਸ਼ੁਰੂ ਕਰਨਾ ਹੈ ਜਾਂ ਤਿਆਰ ਕੀਤੇ ਹੱਲਾਂ ਨੂੰ ਟ੍ਰਾਂਸਫਰ ਕਰਨਾ ਹੈ)

В ਪਿਛਲਾ ਇਸ ਪੋਸਟ ਵਿੱਚ, ਅਸੀਂ ਉਹਨਾਂ ਢੁਕਵੇਂ ਸਾਧਨਾਂ ਨੂੰ ਦੇਖਿਆ ਹੈ ਜੋ ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਆਧੁਨਿਕ ਬਣਾਉਣ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਪ੍ਰਾਪਤ ਕੀਤੇ ਸੁਧਾਰਾਂ ਨੂੰ ਮਾਪਣ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ।

ਸੰਸਕਰਣ 0.17.0 ਤੋਂ, ਕਵਾਕਰਸ ਐਡਵਾਂਸਡ ਮੈਸੇਜ ਕਿਊਇੰਗ ਪ੍ਰੋਟੋਕੋਲ ਦੀ ਵਰਤੋਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ (AMQP), ਜੋ ਕਿ ਐਪਲੀਕੇਸ਼ਨਾਂ ਜਾਂ ਸੰਸਥਾਵਾਂ ਵਿਚਕਾਰ ਵਪਾਰਕ ਸੁਨੇਹਿਆਂ ਨੂੰ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ ਇੱਕ ਖੁੱਲਾ ਮਿਆਰ ਹੈ।

Red Hat AMQ ਔਨਲਾਈਨ ਇੱਕ ਓਪਨ ਸੋਰਸ ਪ੍ਰੋਜੈਕਟ ਦੇ ਅਧਾਰ 'ਤੇ ਬਣਾਈ ਗਈ ਸੇਵਾ ਹੈ EnMasse ਅਤੇ ਪਲੇਟਫਾਰਮ-ਆਧਾਰਿਤ ਮੈਸੇਜਿੰਗ ਵਿਧੀ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਰੈੱਡ ਹੈੱਟ ਓਪਨ ਸ਼ੀਫਟ. ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਇਸ ਬਾਰੇ ਹੋਰ ਵੇਰਵਿਆਂ ਲਈ, ਵੇਖੋ ਇੱਥੇ (EN). ਅੱਜ ਅਸੀਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂਗੇ ਕਿ ਦੋ ਨਵੀਆਂ ਮੈਸੇਜਿੰਗ ਤਕਨੀਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਆਧੁਨਿਕ ਓਪਨਸ਼ਿਫਟ-ਅਧਾਰਿਤ ਮੈਸੇਜਿੰਗ ਸਿਸਟਮ ਬਣਾਉਣ ਲਈ AMQ ਔਨਲਾਈਨ ਅਤੇ ਕੁਆਰਕਸ ਨੂੰ ਕਿਵੇਂ ਜੋੜਿਆ ਜਾਵੇ।

ਇਹ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਓਪਨਸ਼ਿਫਟ ਪਲੇਟਫਾਰਮ 'ਤੇ ਪਹਿਲਾਂ ਹੀ AMQ ਔਨਲਾਈਨ ਤੈਨਾਤ ਕਰ ਚੁੱਕੇ ਹੋ (ਜੇ ਨਹੀਂ, ਤਾਂ ਵੇਖੋ ਇੰਸਟਾਲੇਸ਼ਨ ਗਾਈਡ).

ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਅਸੀਂ ਇੱਕ ਕੁਆਰਕਸ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਵਾਂਗੇ ਜੋ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਮੈਸੇਜਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਧਾਰਨ ਆਰਡਰ ਪ੍ਰੋਸੈਸਿੰਗ ਸਿਸਟਮ ਹੋਵੇਗਾ। ਇਸ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਇੱਕ ਆਰਡਰ ਜਨਰੇਟਰ ਸ਼ਾਮਲ ਹੋਵੇਗਾ ਜੋ ਇੱਕ ਨਿਸ਼ਚਿਤ ਅੰਤਰਾਲ 'ਤੇ ਇੱਕ ਸੁਨੇਹਾ ਕਤਾਰ ਨੂੰ ਆਰਡਰ ਭੇਜਦਾ ਹੈ, ਨਾਲ ਹੀ ਇੱਕ ਆਰਡਰ ਪ੍ਰੋਸੈਸਰ ਜੋ ਕਤਾਰ ਤੋਂ ਸੁਨੇਹਿਆਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰੇਗਾ ਅਤੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਦੇਖਣਯੋਗ ਪੁਸ਼ਟੀਕਰਨ ਤਿਆਰ ਕਰੇਗਾ।

ਇੱਕ ਵਾਰ ਜਦੋਂ ਅਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾ ਲੈਂਦੇ ਹਾਂ, ਅਸੀਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂਗੇ ਕਿ ਕਿਵੇਂ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਮੈਸੇਜਿੰਗ ਸਿਸਟਮ ਕੌਂਫਿਗਰੇਸ਼ਨ ਨੂੰ ਏਮਬੇਡ ਕਰਨਾ ਹੈ ਅਤੇ ਸਿਸਟਮ 'ਤੇ ਲੋੜੀਂਦੇ ਸਰੋਤਾਂ ਦਾ ਪ੍ਰਬੰਧ ਕਰਨ ਲਈ AMQ ਔਨਲਾਈਨ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਹੈ।

ਕੁਆਰਕਸ ਐਪ

ਸਾਡੀ Quarkus ਐਪਲੀਕੇਸ਼ਨ 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 ਲਈ ਸਾਡੀ ਅਰਜ਼ੀ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਇੱਕ ਕਸਟਮ ConfigSource ਬਣਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਪੋਡ ਦੇ ਫਾਈਲ ਸਿਸਟਮ ਤੋਂ ਪ੍ਰਮਾਣਿਕਤਾ ਟੋਕਨ ਨੂੰ ਪੜ੍ਹੇਗਾ:

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

ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਲਈ ਅਨੁਮਤੀਆਂ

AMQ ਔਨਲਾਈਨ ਨੂੰ ਸੰਰਚਨਾ ਬਣਾਉਣ ਲਈ ਕ੍ਰਮ ਵਿੱਚ ਜੋ ਅਸੀਂ AMQP ਅੰਤਮ ਬਿੰਦੂ ਜਾਣਕਾਰੀ ਨੂੰ ਏਮਬੈਡ ਕਰਨ ਲਈ ਵਰਤਿਆ ਸੀ, ਰੋਲ ਅਤੇ ਰੋਲਬਾਈਡਿੰਗ ਨੂੰ ਸੈੱਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ:

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