ການປະມວນຜົນເຫດການທີ່ໄດ້ຮັບຈາກ Kafka

Hey Habr.

ເມື່ອບໍ່ດົນມານີ້ I ແບ່ງປັນປະສົບການຂອງລາວ ກ່ຽວກັບຕົວກໍານົດການທີ່ພວກເຮົາເປັນທີມສ່ວນຫຼາຍມັກຈະໃຊ້ສໍາລັບຜູ້ຜະລິດແລະຜູ້ບໍລິໂພກ Kafka ເພື່ອເຂົ້າໃກ້ການຈັດສົ່ງທີ່ຮັບປະກັນ. ໃນບົດຄວາມນີ້ຂ້າພະເຈົ້າຕ້ອງການບອກທ່ານວ່າພວກເຮົາຈັດຂະບວນການຄືນໃຫມ່ຂອງເຫດການທີ່ໄດ້ຮັບຈາກ Kafka ເປັນຜົນມາຈາກການບໍ່ສາມາດໃຊ້ໄດ້ຊົ່ວຄາວຂອງລະບົບພາຍນອກ.

ຄໍາຮ້ອງສະຫມັກທີ່ທັນສະໄຫມດໍາເນີນການໃນສະພາບແວດລ້ອມທີ່ສັບສົນຫຼາຍ. ເຫດຜົນທາງທຸລະກິດຫໍ່ຢູ່ໃນ stack ເຕັກໂນໂລຊີທີ່ທັນສະໄຫມ, ແລ່ນຢູ່ໃນຮູບພາບ Docker ຄຸ້ມຄອງໂດຍ orchestrator ເຊັ່ນ Kubernetes ຫຼື OpenShift, ແລະຕິດຕໍ່ສື່ສານກັບຄໍາຮ້ອງສະຫມັກອື່ນໆຫຼືວິທີແກ້ໄຂວິສາຫະກິດໂດຍຜ່ານລະບົບຕ່ອງໂສ້ຂອງ routers ທາງດ້ານຮ່າງກາຍແລະ virtual. ໃນສະພາບແວດລ້ອມດັ່ງກ່າວ, ບາງສິ່ງບາງຢ່າງສາມາດທໍາລາຍໄດ້, ດັ່ງນັ້ນການປະມວນຜົນເຫດການຄືນໃຫມ່ຖ້າລະບົບພາຍນອກບໍ່ສາມາດໃຊ້ໄດ້ແມ່ນສ່ວນຫນຶ່ງທີ່ສໍາຄັນຂອງຂະບວນການທຸລະກິດຂອງພວກເຮົາ.

ມັນເປັນແນວໃດກ່ອນ Kafka

ກ່ອນຫນ້ານີ້ໃນໂຄງການພວກເຮົາໃຊ້ IBM MQ ສໍາລັບການສົ່ງຂໍ້ຄວາມ asynchronous. ຖ້າມີຂໍ້ຜິດພາດເກີດຂຶ້ນໃນລະຫວ່າງການດໍາເນີນງານຂອງການບໍລິການ, ຂໍ້ຄວາມທີ່ໄດ້ຮັບສາມາດຖືກຈັດໃສ່ໃນແຖວຈົດຫມາຍຕາຍ (DLQ) ສໍາລັບການວິເຄາະຄູ່ມືຕື່ມອີກ. DLQ ຖືກສ້າງຂື້ນຢູ່ຂ້າງແຖວທີ່ເຂົ້າມາ, ຂໍ້ຄວາມຖືກໂອນພາຍໃນ IBM MQ.

ຖ້າຄວາມຜິດພາດແມ່ນຊົ່ວຄາວແລະພວກເຮົາສາມາດກໍານົດມັນໄດ້ (ຕົວຢ່າງເຊັ່ນ ResourceAccessException ຢູ່ໃນການໂທ HTTP ຫຼື MongoTimeoutException ຢູ່ໃນຄໍາຮ້ອງຂໍ MongoDb), ຫຼັງຈາກນັ້ນຍຸດທະສາດການພະຍາຍາມໃຫມ່ຈະມີຜົນ. ໂດຍບໍ່ຄໍານຶງເຖິງເຫດຜົນຂອງສາຂາຂອງແອັບພລິເຄຊັນ, ຂໍ້ຄວາມຕົ້ນສະບັບໄດ້ຖືກຍ້າຍໄປຢູ່ໃນແຖວລະບົບສໍາລັບການສົ່ງທີ່ຊັກຊ້າ, ຫຼືໄປຫາແອັບພລິເຄຊັນແຍກຕ່າງຫາກທີ່ເຮັດມາດົນແລ້ວເພື່ອສົ່ງຂໍ້ຄວາມໃຫມ່. ນີ້ປະກອບມີຈໍານວນການສົ່ງຄືນໃນສ່ວນຫົວຂໍ້ຄວາມ, ເຊິ່ງຜູກມັດກັບໄລຍະການຊັກຊ້າຫຼືຈຸດສິ້ນສຸດຂອງຍຸດທະສາດລະດັບແອັບພລິເຄຊັນ. ຖ້າພວກເຮົາໄດ້ມາຮອດຈຸດສິ້ນສຸດຂອງຍຸດທະສາດແຕ່ລະບົບພາຍນອກຍັງບໍ່ສາມາດໃຊ້ໄດ້, ຫຼັງຈາກນັ້ນຂໍ້ຄວາມຈະຖືກຈັດໃສ່ໃນ DLQ ສໍາລັບການແຍກຄູ່ມື.

ຊອກຫາວິທີແກ້ໄຂ

ຊອກຫາຢູ່ໃນອິນເຕີເນັດ, ທ່ານ​ສາ​ມາດ​ຊອກ​ຫາ​ດັ່ງ​ຕໍ່​ໄປ​ນີ້​ ການຕັດສິນໃຈ. ໃນສັ້ນ, ມັນໄດ້ຖືກສະເຫນີໃຫ້ສ້າງຫົວຂໍ້ສໍາລັບແຕ່ລະໄລຍະການຊັກຊ້າແລະປະຕິບັດຄໍາຮ້ອງສະຫມັກຂອງຜູ້ບໍລິໂພກໃນດ້ານຂ້າງ, ເຊິ່ງຈະອ່ານຂໍ້ຄວາມທີ່ມີຄວາມຊັກຊ້າທີ່ຕ້ອງການ.

ເຖິງວ່າຈະມີການທົບທວນຄືນໃນທາງບວກຈໍານວນຫລາຍ, ມັນເບິ່ງຄືວ່າຂ້ອຍບໍ່ປະສົບຜົນສໍາເລັດທັງຫມົດ. ກ່ອນອື່ນ ໝົດ, ຍ້ອນວ່າຜູ້ພັດທະນາ, ນອກເຫນືອຈາກການປະຕິບັດຄວາມຕ້ອງການຂອງທຸລະກິດ, ຈະຕ້ອງໃຊ້ເວລາຫຼາຍໃນການປະຕິບັດກົນໄກທີ່ໄດ້ອະທິບາຍ.

ນອກຈາກນັ້ນ, ຖ້າການຄວບຄຸມການເຂົ້າເຖິງຖືກເປີດໃຊ້ໃນກຸ່ມ Kafka, ທ່ານຈະຕ້ອງໃຊ້ເວລາໃນການສ້າງຫົວຂໍ້ແລະສະຫນອງການເຂົ້າເຖິງທີ່ຈໍາເປັນສໍາລັບພວກເຂົາ. ນອກເຫນືອໄປຈາກນີ້, ທ່ານຈະຕ້ອງເລືອກພາລາມິເຕີ retention.ms ທີ່ຖືກຕ້ອງສໍາລັບແຕ່ລະຫົວຂໍ້ retry ເພື່ອໃຫ້ຂໍ້ຄວາມມີເວລາທີ່ຈະ reent ແລະບໍ່ຫາຍໄປຈາກມັນ. ການປະຕິບັດແລະການຮ້ອງຂໍການເຂົ້າເຖິງຈະຕ້ອງຊ້ໍາສໍາລັບແຕ່ລະບໍລິການທີ່ມີຢູ່ແລ້ວຫຼືໃຫມ່.

ຕອນນີ້ໃຫ້ເບິ່ງວ່າກົນໄກໃນພາກຮຽນ spring ໂດຍທົ່ວໄປແລະພາກຮຽນ spring-kafka ໂດຍສະເພາະແມ່ນສະຫນອງພວກເຮົາສໍາລັບ reprocessing ຂໍ້ຄວາມ. Spring-kafka ມີການເພິ່ງພາອາໄສແບບຂ້າມຜ່ານຂອງພາກຮຽນ spring-retry, ເຊິ່ງສະຫນອງການບໍ່ມີຕົວຕົນສໍາລັບການຄຸ້ມຄອງ BackOffPolicies ທີ່ແຕກຕ່າງກັນ. ນີ້ແມ່ນເຄື່ອງມືທີ່ມີຄວາມຍືດຫຍຸ່ນພໍສົມຄວນ, ແຕ່ຂໍ້ບົກຜ່ອງທີ່ສໍາຄັນຂອງມັນແມ່ນການເກັບຮັກສາຂໍ້ຄວາມສໍາລັບການສົ່ງຄືນໃນຫນ່ວຍຄວາມຈໍາຂອງແອັບພລິເຄຊັນ. ນີ້ໝາຍຄວາມວ່າການຣີສະຕາດແອັບພລິເຄຊັນ ເນື່ອງຈາກການອັບເດດ ຫຼືຄວາມຜິດພາດໃນການປະຕິບັດງານຈະສົ່ງຜົນໃຫ້ສູນເສຍຂໍ້ຄວາມທັງໝົດທີ່ຍັງລໍຖ້າການປະມວນຜົນຄືນໃໝ່. ເນື່ອງຈາກຈຸດນີ້ແມ່ນສໍາຄັນສໍາລັບລະບົບຂອງພວກເຮົາ, ພວກເຮົາບໍ່ໄດ້ພິຈາລະນາມັນຕື່ມອີກ.

spring-kafka ຕົວຂອງມັນເອງສະຫນອງການປະຕິບັດຫຼາຍຢ່າງຂອງ ContainerAwareErrorHandler, ສໍາລັບການຍົກຕົວຢ່າງ SeekToCurrentErrorHandler, ທີ່​ທ່ານ​ສາ​ມາດ​ປະ​ມວນ​ຜົນ​ຂໍ້​ຄວາມ​ຕໍ່​ມາ​ໂດຍ​ບໍ່​ມີ​ການ​ປ່ຽນ​ແປງ​ການ​ຊົດ​ເຊີຍ​ໃນ​ກໍ​ລະ​ນີ​ທີ່​ມີ​ຄວາມ​ຜິດ​ພາດ​. ເລີ່ມຕົ້ນດ້ວຍເວີຊັນຂອງ spring-kafka 2.3, ມັນເປັນໄປໄດ້ທີ່ຈະຕັ້ງຄ່າ BackOffPolicy.

ວິທີການນີ້ອະນຸຍາດໃຫ້ຂໍ້ຄວາມທີ່ຖືກປຸງແຕ່ງຄືນໃຫມ່ເພື່ອຢູ່ລອດການເລີ່ມຕົ້ນໃຫມ່ຂອງແອັບພລິເຄຊັນ, ແຕ່ມັນຍັງບໍ່ມີກົນໄກ DLQ. ພວກເຮົາໄດ້ເລືອກທາງເລືອກນີ້ໃນຕອນຕົ້ນຂອງ 2019, ເຊື່ອວ່າໃນແງ່ດີວ່າ DLQ ຈະບໍ່ຈໍາເປັນ (ພວກເຮົາໂຊກດີແລະຕົວຈິງແລ້ວບໍ່ຕ້ອງການມັນຫຼັງຈາກຫຼາຍເດືອນຂອງການດໍາເນີນງານຄໍາຮ້ອງສະຫມັກທີ່ມີລະບົບການປຸງແຕ່ງດັ່ງກ່າວ). ຄວາມຜິດພາດຊົ່ວຄາວເຮັດໃຫ້ SeekToCurrentErrorHandler ໄຟໄໝ້. ຂໍ້ຜິດພາດທີ່ຍັງເຫຼືອໄດ້ຖືກພິມອອກໃນບັນທຶກ, ສົ່ງຜົນໃຫ້ມີການຊົດເຊີຍ, ແລະການປຸງແຕ່ງສືບຕໍ່ກັບຂໍ້ຄວາມຕໍ່ໄປ.

ການຕັດສິນໃຈສຸດທ້າຍ

ການປະຕິບັດໂດຍອີງໃສ່ SeekToCurrentErrorHandler ໄດ້ກະຕຸ້ນໃຫ້ພວກເຮົາພັດທະນາກົນໄກຂອງຕົນເອງສໍາລັບການສົ່ງຂໍ້ຄວາມຄືນໃຫມ່.

ກ່ອນອື່ນ ໝົດ, ພວກເຮົາຕ້ອງການໃຊ້ປະສົບການທີ່ມີຢູ່ແລະຂະຫຍາຍມັນຂື້ນກັບເຫດຜົນຂອງແອັບພລິເຄຊັນ. ສໍາລັບຄໍາຮ້ອງສະຫມັກຕາມເຫດຜົນເສັ້ນ, ມັນຈະເປັນການດີທີ່ສຸດທີ່ຈະຢຸດການອ່ານຂໍ້ຄວາມໃຫມ່ໃນໄລຍະເວລາສັ້ນໆທີ່ກໍານົດໂດຍຍຸດທະສາດການລອງໃຫມ່. ສໍາລັບຄໍາຮ້ອງສະຫມັກອື່ນໆ, ຂ້ອຍຕ້ອງການຈຸດດຽວທີ່ຈະບັງຄັບໃຊ້ຍຸດທະສາດການລອງໃຫມ່. ນອກຈາກນັ້ນ, ຈຸດດຽວນີ້ຕ້ອງມີຫນ້າທີ່ DLQ ສໍາລັບທັງສອງວິທີການ.

ຍຸດທະສາດການລອງໃຫມ່ຂອງມັນເອງຕ້ອງຖືກເກັບໄວ້ໃນແອັບພລິເຄຊັນ, ເຊິ່ງມີຄວາມຮັບຜິດຊອບໃນການດຶງຂໍ້ມູນໄລຍະຕໍ່ໄປເມື່ອມີຂໍ້ຜິດພາດຊົ່ວຄາວເກີດຂື້ນ.

ການຢຸດເຊົາຜູ້ບໍລິໂພກສໍາລັບຄໍາຮ້ອງສະຫມັກ Linear Logic

ເມື່ອເຮັດວຽກກັບພາກຮຽນ spring-kafka, ລະຫັດເພື່ອຢຸດຜູ້ບໍລິໂພກອາດຈະມີລັກສະນະເຊັ່ນນີ້:

public void pauseListenerContainer(MessageListenerContainer listenerContainer, 
                                   Instant retryAt) {
        if (nonNull(retryAt) && listenerContainer.isRunning()) {
            listenerContainer.stop();
            taskScheduler.schedule(() -> listenerContainer.start(), retryAt);
            return;
        }
        // to DLQ
    }

ໃນຕົວຢ່າງ, retryAt ແມ່ນເວລາທີ່ຈະ restart MessageListenerContainer ຖ້າມັນຍັງແລ່ນຢູ່. ການເປີດຕົວໃຫມ່ຈະເກີດຂື້ນໃນກະທູ້ແຍກຕ່າງຫາກທີ່ເປີດຕົວໃນ TaskScheduler, ການປະຕິບັດທີ່ສະຫນອງໃຫ້ໂດຍພາກຮຽນ spring.

ພວກເຮົາຊອກຫາຄ່າ retryAt ດ້ວຍວິທີຕໍ່ໄປນີ້:

1. ມູນຄ່າຂອງເຄົາເຕີການໂທຄືນແມ່ນເບິ່ງຂຶ້ນ.
2. ອີງຕາມການນັບມູນຄ່າ, ໄລຍະການຊັກຊ້າໃນປັດຈຸບັນໃນຍຸດທະສາດການລອງໃຫມ່ແມ່ນຊອກຫາ. ຍຸດທະສາດໄດ້ຖືກປະກາດຢູ່ໃນແອັບພລິເຄຊັນຕົວມັນເອງ; ພວກເຮົາເລືອກຮູບແບບ JSON ເພື່ອເກັບຮັກສາມັນ.
3. ໄລຍະຫ່າງທີ່ພົບເຫັນຢູ່ໃນອາເຣ JSON ປະກອບມີຈໍານວນວິນາທີຫຼັງຈາກການປະມວນຜົນຈະຕ້ອງຊ້ໍາອີກ. ຈໍານວນວິນາທີນີ້ຖືກເພີ່ມໃສ່ເວລາປະຈຸບັນເພື່ອສ້າງຄ່າສໍາລັບ retryAt.
4. ຖ້າບໍ່ພົບໄລຍະຫ່າງ, ຄ່າຂອງ retryAt ແມ່ນ null ແລະຂໍ້ຄວາມຈະຖືກສົ່ງໄປຫາ DLQ ສໍາລັບການວິເຄາະຄູ່ມື.

ດ້ວຍວິທີການນີ້, ທັງຫມົດທີ່ຍັງເຫຼືອແມ່ນເພື່ອບັນທຶກຈໍານວນການໂທຊ້ໍາກັນສໍາລັບແຕ່ລະຂໍ້ຄວາມທີ່ກໍາລັງດໍາເນີນການ, ຕົວຢ່າງໃນຫນ່ວຍຄວາມຈໍາຂອງແອັບພລິເຄຊັນ. ການຮັກສາການນັບການພະຍາຍາມຄືນໃຫມ່ໃນຫນ່ວຍຄວາມຈໍາແມ່ນບໍ່ສໍາຄັນສໍາລັບວິທີການນີ້, ເນື່ອງຈາກວ່າຄໍາຮ້ອງສະຫມັກ logic ເສັ້ນບໍ່ສາມາດຈັດການການປຸງແຕ່ງທັງຫມົດ. ບໍ່ຄືກັບພາກຮຽນ spring-retry, restart app ຈະບໍ່ເຮັດໃຫ້ຂໍ້ຄວາມທັງຫມົດທີ່ສູນເສຍໄປເພື່ອ reprocessed, ແຕ່ພຽງແຕ່ຈະ restart ຍຸດທະສາດ.

ວິທີການນີ້ຊ່ວຍເອົາການໂຫຼດອອກຈາກລະບົບພາຍນອກ, ເຊິ່ງອາດຈະບໍ່ສາມາດໃຊ້ໄດ້ເນື່ອງຈາກການໂຫຼດຫນັກຫຼາຍ. ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ນອກເຫນືອຈາກການປຸງແຕ່ງໃຫມ່, ພວກເຮົາບັນລຸການປະຕິບັດຮູບແບບ ວົງຈອນວົງຈອນ.

ໃນກໍລະນີຂອງພວກເຮົາ, ຂອບເຂດຄວາມຜິດພາດແມ່ນພຽງແຕ່ 1, ແລະເພື່ອຫຼຸດຜ່ອນການຢຸດລະບົບເນື່ອງຈາກການຢຸດຊົ່ວຄາວຂອງເຄືອຂ່າຍ, ພວກເຮົາໃຊ້ຍຸດທະສາດການພະຍາຍາມໃຫມ່ທີ່ມີຄວາມລະອຽດຫຼາຍທີ່ມີໄລຍະການ latency ຂະຫນາດນ້ອຍ. ນີ້ອາດຈະບໍ່ເຫມາະສົມສໍາລັບການນໍາໃຊ້ກຸ່ມທັງຫມົດ, ດັ່ງນັ້ນຄວາມສໍາພັນລະຫວ່າງຂອບເຂດຄວາມຜິດພາດແລະຄ່າໄລຍະຫ່າງຕ້ອງໄດ້ຮັບການຄັດເລືອກໂດຍອີງໃສ່ຄຸນລັກສະນະຂອງລະບົບ.

ແອັບພລິເຄຊັນແຍກຕ່າງຫາກສໍາລັບການປະມວນຜົນຂໍ້ຄວາມຈາກແອັບພລິເຄຊັນທີ່ມີເຫດຜົນທີ່ບໍ່ກໍານົດ

ນີ້ແມ່ນຕົວຢ່າງຂອງລະຫັດທີ່ສົ່ງຂໍ້ຄວາມໄປຫາແອັບພລິເຄຊັນດັ່ງກ່າວ (Retryer), ເຊິ່ງຈະສົ່ງໄປທີ່ຫົວຂໍ້ DESTINATION ເມື່ອຮອດເວລາ RETRY_AT:

public <K, V> void retry(ConsumerRecord<K, V> record, String retryToTopic, 
                         Instant retryAt, String counter, String groupId, Exception e) {
        Headers headers = ofNullable(record.headers()).orElse(new RecordHeaders());
        List<Header> arrayOfHeaders = 
            new ArrayList<>(Arrays.asList(headers.toArray()));
        updateHeader(arrayOfHeaders, GROUP_ID, groupId::getBytes);
        updateHeader(arrayOfHeaders, DESTINATION, retryToTopic::getBytes);
        updateHeader(arrayOfHeaders, ORIGINAL_PARTITION, 
                     () -> Integer.toString(record.partition()).getBytes());
        if (nonNull(retryAt)) {
            updateHeader(arrayOfHeaders, COUNTER, counter::getBytes);
            updateHeader(arrayOfHeaders, SEND_TO, "retry"::getBytes);
            updateHeader(arrayOfHeaders, RETRY_AT, retryAt.toString()::getBytes);
        } else {
            updateHeader(arrayOfHeaders, REASON, 
                         ExceptionUtils.getStackTrace(e)::getBytes);
            updateHeader(arrayOfHeaders, SEND_TO, "backout"::getBytes);
        }
        ProducerRecord<K, V> messageToSend =
            new ProducerRecord<>(retryTopic, null, null, record.key(), record.value(), arrayOfHeaders);
        kafkaTemplate.send(messageToSend);
    }

ຕົວຢ່າງສະແດງໃຫ້ເຫັນວ່າຂໍ້ມູນຈໍານວນຫລາຍຖືກສົ່ງຢູ່ໃນສ່ວນຫົວ. ມູນຄ່າຂອງ RETRY_AT ແມ່ນພົບໃນລັກສະນະດຽວກັນກັບກົນໄກການພະຍາຍາມຄືນໃໝ່ຜ່ານຈຸດຢຸດຂອງຜູ້ບໍລິໂພກ. ນອກຈາກ DESTINATION ແລະ RETRY_AT ພວກເຮົາຜ່ານ:

• GROUP_ID, ໂດຍທີ່ພວກເຮົາຈັດກຸ່ມຂໍ້ຄວາມສໍາລັບການວິເຄາະຄູ່ມືແລະການຄົ້ນຫາທີ່ງ່າຍດາຍ.
• ORIGINAL_PARTITION ເພື່ອພະຍາຍາມຮັກສາຜູ້ບໍລິໂພກດຽວກັນສໍາລັບການປຸງແຕ່ງຄືນໃຫມ່. ພາລາມິເຕີນີ້ສາມາດເປັນ null, ໃນກໍລະນີນີ້, ການແບ່ງປັນໃຫມ່ຈະໄດ້ຮັບໂດຍໃຊ້ປຸ່ມ record.key() ຂອງຂໍ້ຄວາມຕົ້ນສະບັບ.
• ອັບເດດຄ່າ COUNTER ເພື່ອປະຕິບັດຕາມຍຸດທະສາດການລອງອີກຄັ້ງ.
• SEND_TO ແມ່ນຕົວຊີ້ບອກຄົງທີ່ວ່າຂໍ້ຄວາມຖືກສົ່ງເພື່ອປະມວນຜົນຄືນໃໝ່ເມື່ອຮອດ RETRY_AT ຫຼືວາງໄວ້ໃນ DLQ.
• ເຫດຜົນ - ເຫດຜົນວ່າເປັນຫຍັງການປະມວນຜົນຂໍ້ຄວາມຖືກລົບກວນ.

Retryer ເກັບຮັກສາຂໍ້ຄວາມສໍາລັບການສົ່ງຄືນແລະການວິເຄາະດ້ວຍຕົນເອງໃນ PostgreSQL. ເຄື່ອງຈັບເວລາເລີ່ມວຽກງານທີ່ຊອກຫາຂໍ້ຄວາມດ້ວຍ RETRY_AT ແລະສົ່ງພວກມັນກັບຄືນໄປຫາພາກສ່ວນ ORIGINAL_PARTITION ຂອງຫົວຂໍ້ DESTINATION ດ້ວຍລະຫັດ record.key().

ເມື່ອສົ່ງແລ້ວ, ຂໍ້ຄວາມຈະຖືກລຶບອອກຈາກ PostgreSQL. ການວິເຄາະຂໍ້ຄວາມດ້ວຍຕົນເອງເກີດຂຶ້ນໃນ UI ງ່າຍໆທີ່ພົວພັນກັບ Retryer ຜ່ານ REST API. ລັກສະນະຕົ້ນຕໍຂອງມັນແມ່ນການສົ່ງຄືນຫຼືລຶບຂໍ້ຄວາມຈາກ DLQ, ເບິ່ງຂໍ້ມູນຄວາມຜິດພາດແລະການຊອກຫາຂໍ້ຄວາມ, ຕົວຢ່າງໂດຍຊື່ຂໍ້ຜິດພາດ.

ເນື່ອງຈາກການຄວບຄຸມການເຂົ້າເຖິງໄດ້ຖືກເປີດໃຊ້ຢູ່ໃນກຸ່ມຂອງພວກເຮົາ, ມັນຈໍາເປັນຕ້ອງໄດ້ຮ້ອງຂໍການເຂົ້າເຖິງຫົວຂໍ້ທີ່ Retryer ກໍາລັງຟັງຕື່ມອີກ, ແລະອະນຸຍາດໃຫ້ Retryer ຂຽນໄປຫາຫົວຂໍ້ DESTINATION. ນີ້ແມ່ນຄວາມບໍ່ສະດວກ, ແຕ່, ບໍ່ເຫມືອນກັບວິທີການຫົວຂໍ້ໄລຍະຫ່າງ, ພວກເຮົາມີ DLQ ແລະ UI ເຕັມຮູບແບບເພື່ອຈັດການມັນ.

ມີບາງກໍລະນີເມື່ອຫົວຂໍ້ທີ່ເຂົ້າມາຖືກອ່ານໂດຍກຸ່ມຜູ້ບໍລິໂພກທີ່ແຕກຕ່າງກັນຫຼາຍ, ຄໍາຮ້ອງສະຫມັກຂອງພວກເຂົາປະຕິບັດເຫດຜົນທີ່ແຕກຕ່າງກັນ. ການປະມວນຜົນຂໍ້ຄວາມຄືນໃໝ່ຜ່ານ Retryer ສຳລັບໜຶ່ງໃນແອັບພລິເຄຊັນເຫຼົ່ານີ້ຈະສົ່ງຜົນໃຫ້ຊ້ຳກັບອີກອັນໜຶ່ງ. ເພື່ອປ້ອງກັນນີ້, ພວກເຮົາສ້າງຫົວຂໍ້ແຍກຕ່າງຫາກສໍາລັບການປຸງແຕ່ງຄືນໃຫມ່. ຫົວຂໍ້ທີ່ເຂົ້າມາແລະລອງໃຫມ່ສາມາດອ່ານໄດ້ໂດຍຜູ້ບໍລິໂພກດຽວກັນໂດຍບໍ່ມີຂໍ້ຈໍາກັດໃດໆ.

ໂດຍຄ່າເລີ່ມຕົ້ນວິທີການນີ້ບໍ່ໄດ້ສະຫນອງການທໍາງານຂອງ breaker ວົງຈອນ, ຢ່າງໃດກໍຕາມ, ມັນສາມາດຖືກເພີ່ມເຂົ້າໃນຄໍາຮ້ອງສະຫມັກການນໍາໃຊ້ spring-cloud-netflix ຫຼືໃຫມ່ ຕົວຕັດວົງຈອນຟັງພາກຮຽນ spring, ຫໍ່ສະຖານທີ່ບ່ອນທີ່ການບໍລິການພາຍນອກຖືກເອີ້ນວ່າເປັນ abstractions ທີ່ເຫມາະສົມ. ນອກຈາກນັ້ນ, ມັນເປັນໄປໄດ້ທີ່ຈະເລືອກເອົາຍຸດທະສາດສໍາລັບ ປະລິມານ ຮູບແບບ, ເຊິ່ງຍັງສາມາດເປັນປະໂຫຍດ. ຕົວຢ່າງ, ໃນພາກຮຽນ spring-cloud-netflix ນີ້ອາດຈະເປັນສະນຸກເກີ thread ຫຼື semaphore.

ສະຫລຸບ

ດັ່ງນັ້ນ, ພວກເຮົາມີຄໍາຮ້ອງສະຫມັກແຍກຕ່າງຫາກທີ່ອະນຸຍາດໃຫ້ພວກເຮົາເຮັດຊ້ໍາການປະມວນຜົນຂໍ້ຄວາມຖ້າຫາກວ່າລະບົບພາຍນອກໃດບໍ່ສາມາດໃຊ້ໄດ້ຊົ່ວຄາວ.

ຫນຶ່ງໃນຂໍ້ໄດ້ປຽບຕົ້ນຕໍຂອງຄໍາຮ້ອງສະຫມັກແມ່ນວ່າມັນສາມາດຖືກນໍາໃຊ້ໂດຍລະບົບພາຍນອກທີ່ເຮັດວຽກຢູ່ໃນກຸ່ມ Kafka ດຽວກັນ, ໂດຍບໍ່ມີການດັດແປງທີ່ສໍາຄັນຢູ່ຂ້າງຂອງພວກເຂົາ! ຄໍາຮ້ອງສະຫມັກດັ່ງກ່າວພຽງແຕ່ຈະຕ້ອງເຂົ້າເຖິງຫົວຂໍ້ retry, ຕື່ມຂໍ້ມູນໃສ່ໃນບາງສ່ວນຫົວ Kafka ແລະສົ່ງຂໍ້ຄວາມໄປຫາ Retryer. ບໍ່ຈໍາເປັນຕ້ອງຍົກສູງໂຄງສ້າງພື້ນຖານໃດໆ. ແລະເພື່ອຫຼຸດຜ່ອນຈໍານວນຂໍ້ຄວາມທີ່ຖືກໂອນຈາກແອັບພລິເຄຊັນໄປຫາ Retryer ແລະກັບຄືນ, ພວກເຮົາໄດ້ກໍານົດຄໍາຮ້ອງສະຫມັກທີ່ມີເຫດຜົນເສັ້ນແລະດໍາເນີນການຄືນໃຫມ່ໂດຍຜ່ານການຢຸດຂອງຜູ້ບໍລິໂພກ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com