העברת הודעות מקוריות בענן בפלטפורמת Red Hat OpenShift באמצעות Quarkus ו-AMQ Online

שלום לכולם! הנה זה - הפוסט האחרון שלנו בסדרת Quarkus! (אגב, צפו בסמינר המקוון שלנו "זהו Quarkus - מסגרת Java מקורית של Kubernetes". נראה לך איך להתחיל מאפס או להעביר פתרונות מוכנים)

В קודם בפוסט זה, בדקנו את הכלים הרלוונטיים שניתן להשתמש בהם כדי לכמת את השיפורים שהושגו כתוצאה ממודרניזציה של יישומי Java.

מאז גרסה 0.17.0, קוורקוס תומך בשימוש ב-Advanced Message Queuing Protocol (AMQP), שהוא תקן פתוח להעברת מסרים עסקיים בין אפליקציות או ארגונים.

Red Hat AMQ Online הוא שירות שנבנה על בסיס פרויקט קוד פתוח EnMase והטמעת מנגנון מסרים מבוסס פלטפורמה רד האט. לפרטים נוספים על איך זה עובד, ראה כאן (EN). היום נראה לכם כיצד לשלב בין AMQ Online ו-Quarkus לבניית מערכת הודעות מודרנית מבוססת OpenShift תוך שימוש בשתי טכנולוגיות הודעות חדשות.

ההנחה היא שכבר פרסת את AMQ Online בפלטפורמת OpenShift (אם לא, אז ראה מדריך התקנה).

כדי להתחיל, ניצור אפליקציית Quarkus שתהווה מערכת פשוטה לעיבוד הזמנות תוך שימוש בהודעות תגובתיות. אפליקציה זו תכלול מחולל הזמנות ששולח הזמנות לתור הודעות במרווח קבוע וכן מעבד הזמנות שיעבד הודעות מהתור ויפיק אישורים הניתנים לצפייה בדפדפן.

לאחר שיצרנו את האפליקציה, נראה לך כיצד להטמיע את תצורת מערכת ההודעות באפליקציה ולהשתמש ב-AMQ Online כדי לספק את המשאבים הדרושים לנו במערכת.

אפליקציית Quarkus

אפליקציית Quarkus שלנו פועלת על OpenShift והיא גרסה שונה של התוכנית amqp-quickstart. ניתן למצוא דוגמה מלאה של צד הלקוח כאן.

הזמנה מחולל

המחולל פשוט שולח באופן מונוטוני מזהי הזמנות גדלות לכתובת "ההזמנות" כל 5 שניות.

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

מעבד הזמנות

מטפל ההזמנות הוא אפילו יותר פשוט, הוא רק מחזיר מזהה אישור לכתובת ה"אישורים".

@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 אינם ידועים, ולכן יש להזריק אותם. ניתן להגדיר את נקודת הקצה ב-configmap שנוצרה על ידי 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 מותאם אישית שיקרא את אסימון האימות ממערכת הקבצים של הפוד:

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, יש להגדיר את התפקיד ואת התפקידים:

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

אז בוא נבדוק את כתובת האתר של מסלול האפליקציה (פשוט פתח את הכתובת הזו בדפדפן):

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

הדפדפן צריך להראות שהכרטיסים מתעדכנים מעת לעת כאשר הודעות נשלחות ומתקבלות על ידי AMQ Online.

סכום

אז כתבנו אפליקציית Quarkus שמשתמשת ב-AMQP להעברת הודעות, הגדרנו את האפליקציה לרוץ על פלטפורמת Red Hat OpenShift, ויישמנו את התצורה שלה על סמך תצורת AMQ Online. לאחר מכן יצרנו את המניפסטים הדרושים לאתחול מערכת ההודעות עבור האפליקציה שלנו.

בכך מסתיימת הסדרה על קווארקוס, אבל יש הרבה דברים חדשים ומעניינים לפנינו, הישארו מעודכנים!

מקור: www.habr.com