ວິທີການແລະເປັນຫຍັງພວກເຮົາຂຽນບໍລິການທີ່ສາມາດຂະຫຍາຍໄດ້ສູງສໍາລັບ 1C: Enterprise: Java, PostgreSQL, Hazelcast

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

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

SV ໃຊ້ບ່ອນຈັດເກັບຂໍ້ມູນແບບແຈກຢາຍ hazelcast ແລະເຄື່ອງຈັກຊອກຫາ Elasticsearch. ພວກເຮົາຍັງຈະເວົ້າກ່ຽວກັບ Java ແລະວິທີການທີ່ພວກເຮົາກໍານົດຂອບເຂດຂອງ PostgreSQL.

ການສ້າງບັນຫາ

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

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

ຂະບວນການພັດທະນາລູກຄ້າ-ເຊີບເວີ

ຄໍາຮ້ອງສະຫມັກທຸລະກິດທີ່ສ້າງຂຶ້ນໃນ 1C:ວິສາຫະກິດດໍາເນີນການໃນສາມລະດັບ client-server ສະຖາປັດຕະຍະກໍາ "DBMS - ເຄື່ອງແມ່ຂ່າຍຄໍາຮ້ອງສະຫມັກ - ລູກຄ້າ". ລະຫັດຄໍາຮ້ອງສະຫມັກທີ່ຂຽນໃນ ພາສາ 1C ໃນຕົວ, ສາມາດຖືກປະຕິບັດຢູ່ໃນເຄື່ອງແມ່ຂ່າຍຂອງແອັບພລິເຄຊັນຫຼືໃນລູກຄ້າ. ທັງຫມົດເຮັດວຽກກັບວັດຖຸຂອງຄໍາຮ້ອງສະຫມັກ (ໄດເລກະທໍລີ, ເອກະສານ, ແລະອື່ນໆ), ເຊັ່ນດຽວກັນກັບການອ່ານແລະຂຽນຖານຂໍ້ມູນ, ແມ່ນປະຕິບັດພຽງແຕ່ໃນເຄື່ອງແມ່ຂ່າຍ. ການທໍາງານຂອງແບບຟອມແລະການໂຕ້ຕອບຄໍາສັ່ງຍັງຖືກປະຕິບັດຢູ່ໃນເຄື່ອງແມ່ຂ່າຍ. ລູກຄ້າປະຕິບັດການຮັບ, ເປີດແລະສະແດງແບບຟອມ, "ການສື່ສານ" ກັບຜູ້ໃຊ້ (ຄໍາເຕືອນ, ຄໍາຖາມ ...), ການຄິດໄລ່ຂະຫນາດນ້ອຍໃນຮູບແບບທີ່ຕ້ອງການການຕອບສະຫນອງໄວ (ຕົວຢ່າງ, ການຄູນລາຄາໂດຍປະລິມານ), ເຮັດວຽກກັບໄຟລ໌ທ້ອງຖິ່ນ, ເຮັດວຽກກັບອຸປະກອນ.

ໃນລະຫັດແອັບພລິເຄຊັນ, ສ່ວນຫົວຂອງຂັ້ນຕອນ ແລະໜ້າທີ່ຕ້ອງລະບຸຢ່າງຊັດເຈນວ່າລະຫັດຈະຖືກປະຕິບັດຢູ່ໃສ - ໂດຍໃຊ້ຄໍາສັ່ງ &AtClient / &AtServer (&AtClient / &AtServer ໃນສະບັບພາສາອັງກິດຂອງພາສາ). ຕອນນີ້ນັກພັດທະນາ 1C ຈະແກ້ໄຂຂ້ອຍໂດຍກ່າວວ່າຄໍາສັ່ງແມ່ນຕົວຈິງແລ້ວ ຫຼາຍກ່ວາ, ແຕ່ສໍາລັບພວກເຮົາ, ມັນບໍ່ສໍາຄັນໃນປັດຈຸບັນ.

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

ລະຫັດທີ່ຈັດການການຄລິກປຸ່ມ: ການໂທຫາຂັ້ນຕອນເຊີບເວີຈາກລູກຄ້າຈະເຮັດວຽກ, ການໂທຫາຂັ້ນຕອນລູກຄ້າຈາກເຄື່ອງແມ່ຂ່າຍຈະບໍ່.

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

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

ການຜະລິດເອງ

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

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

Реализация

ພວກເຮົາຕັດສິນໃຈທີ່ຈະບໍ່ລວມເອົາພາກສ່ວນເຊີຟເວີຂອງ SV ໂດຍກົງເຂົ້າໃນ 1C: ແພລະຕະຟອມວິສາຫະກິດ, ແຕ່ເພື່ອປະຕິບັດມັນເປັນຜະລິດຕະພັນແຍກຕ່າງຫາກ, API ທີ່ສາມາດເອີ້ນໄດ້ຈາກລະຫັດຂອງການແກ້ໄຂຄໍາຮ້ອງສະຫມັກ 1C. ນີ້ແມ່ນເຮັດສໍາລັບເຫດຜົນຈໍານວນຫນຶ່ງ, ຫນຶ່ງໃນນັ້ນແມ່ນຂ້ອຍຕ້ອງການທີ່ຈະເຮັດໃຫ້ມັນສາມາດແລກປ່ຽນຂໍ້ຄວາມລະຫວ່າງຄໍາຮ້ອງສະຫມັກ 1C ທີ່ແຕກຕ່າງກັນ (ຕົວຢ່າງ, ລະຫວ່າງການຄຸ້ມຄອງການຄ້າແລະການບັນຊີ). ຄໍາຮ້ອງສະຫມັກ 1C ທີ່ແຕກຕ່າງກັນສາມາດດໍາເນີນການຢູ່ໃນຮຸ່ນທີ່ແຕກຕ່າງກັນຂອງ 1C: ແພລະຕະຟອມວິສາຫະກິດ, ຕັ້ງຢູ່ໃນເຄື່ອງແມ່ຂ່າຍທີ່ແຕກຕ່າງກັນ, ແລະອື່ນໆ. ໃນເງື່ອນໄຂດັ່ງກ່າວ, ການປະຕິບັດ SV ເປັນຜະລິດຕະພັນແຍກຕ່າງຫາກທີ່ຕັ້ງຢູ່ "ຂ້າງ" ຂອງການຕິດຕັ້ງ 1C ແມ່ນການແກ້ໄຂທີ່ດີທີ່ສຸດ.

ດັ່ງນັ້ນ, ພວກເຮົາຕັດສິນໃຈເຮັດໃຫ້ SV ເປັນຜະລິດຕະພັນແຍກຕ່າງຫາກ. ພວກເຮົາແນະນໍາໃຫ້ບໍລິສັດຂະຫນາດນ້ອຍໃຊ້ເຄື່ອງແມ່ຂ່າຍ CB ທີ່ພວກເຮົາຕິດຕັ້ງຢູ່ໃນຄລາວຂອງພວກເຮົາ (wss://1cdialog.com) ເພື່ອຫຼີກເວັ້ນການຄ່າໃຊ້ຈ່າຍເກີນທີ່ກ່ຽວຂ້ອງກັບການຕິດຕັ້ງແລະການຕັ້ງຄ່າທ້ອງຖິ່ນຂອງເຄື່ອງແມ່ຂ່າຍ. ລູກຄ້າຂະຫນາດໃຫຍ່ອາດຈະເຫັນວ່າມັນສົມຄວນທີ່ຈະຕິດຕັ້ງເຄື່ອງແມ່ຂ່າຍ CB ຂອງຕົນເອງຢູ່ທີ່ສະຖານທີ່ຂອງພວກເຂົາ. ພວກເຮົາໄດ້ໃຊ້ວິທີການທີ່ຄ້າຍຄືກັນໃນຜະລິດຕະພັນ SaaS ຟັງຂອງພວກເຮົາ 1c ສົດ - ມັນ​ຖືກ​ຜະ​ລິດ​ເປັນ​ຜະ​ລິດ​ຕະ​ພັນ​ທີ່​ຜະ​ລິດ​ຈໍາ​ນວນ​ຫຼາຍ​ສໍາ​ລັບ​ການ​ຕິດ​ຕັ້ງ​ຢູ່​ໃນ​ເວັບ​ໄຊ​ຂອງ​ລູກ​ຄ້າ​, ແລະ​ຍັງ​ໄດ້​ຖືກ​ນໍາ​ໃຊ້​ໃນ​ການ​ຟັງ​ຂອງ​ພວກ​ເຮົາ https://1cfresh.com/.

Application

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

ການສື່ສານລະຫວ່າງລູກຄ້າແລະເຄື່ອງແມ່ຂ່າຍແມ່ນຜ່ານ websocket. ມັນເຫມາະສົມກັບລະບົບເວລາທີ່ແທ້ຈິງ.

ແຄດແຈກຢາຍ

ພວກເຮົາເລືອກລະຫວ່າງ Redis, Hazelcast ແລະ Ehcache. ມັນແມ່ນປີ 2015. Redis ພຽງແຕ່ປ່ອຍຕົວກຸ່ມໃຫມ່ (ໃຫມ່ເກີນໄປ, ຢ້ານ), ມີ Sentinel ທີ່ມີຂໍ້ຈໍາກັດຫຼາຍ. Ehcache ບໍ່ຮູ້ວິທີການປະກອບເປັນກຸ່ມ (ຟັງຊັນນີ້ປາກົດຕໍ່ມາ). ພວກເຮົາໄດ້ຕັດສິນໃຈທົດລອງໃຊ້ກັບ Hazelcast 3.4.
Hazelcast ແມ່ນປະກອບເປັນກຸ່ມອອກຈາກກ່ອງ. ໃນໂຫມດໂຫນດດຽວ, ມັນບໍ່ມີປະໂຫຍດຫຼາຍແລະພຽງແຕ່ສາມາດໃຊ້ເປັນ cache - ມັນບໍ່ຮູ້ວິທີການ dump ຂໍ້ມູນໃສ່ແຜ່ນ, ຖ້າທ່ານສູນເສຍໂຫນດດຽວ, ທ່ານຈະສູນເສຍຂໍ້ມູນ. ພວກເຮົາໃຊ້ Hazelcasts ຫຼາຍອັນ, ລະຫວ່າງທີ່ພວກເຮົາສໍາຮອງຂໍ້ມູນທີ່ສໍາຄັນ. ພວກເຮົາບໍ່ສໍາຮອງຂໍ້ມູນ cache - ພວກເຮົາບໍ່ສົນໃຈມັນ.

ສໍາລັບພວກເຮົາ, Hazelcast ແມ່ນ:

• ການເກັບຮັກສາເຊດຊັນຂອງຜູ້ໃຊ້. ມັນໃຊ້ເວລາດົນທີ່ຈະໄປຫາຖານຂໍ້ມູນສໍາລັບກອງປະຊຸມທຸກໆຄັ້ງ, ດັ່ງນັ້ນພວກເຮົາຈຶ່ງເອົາກອງປະຊຸມທັງຫມົດໃນ Hazelcast.
• ແຄດ. ຖ້າທ່ານກໍາລັງຊອກຫາໂປຣໄຟລ໌ຜູ້ໃຊ້, ໃຫ້ກວດເບິ່ງ cache. ຂຽນຂໍ້ຄວາມໃຫມ່ - ເອົາໃສ່ໃນ cache.
• ຫົວຂໍ້ສໍາລັບການສື່ສານລະຫວ່າງຄໍາຮ້ອງສະຫມັກຕົວຢ່າງ. node ສ້າງເຫດການແລະວາງມັນໄວ້ໃນຫົວຂໍ້ Hazelcast. ໂນດແອັບພລິເຄຊັນອື່ນທີ່ສະໝັກໃຊ້ຫົວຂໍ້ນີ້ໄດ້ຮັບ ແລະປະມວນຜົນເຫດການ.
• locks ກຸ່ມ. ຕົວຢ່າງ, ພວກເຮົາສ້າງການສົນທະນາໂດຍໃຊ້ລະຫັດທີ່ເປັນເອກະລັກ (ການສົນທະນາດຽວພາຍໃນຖານຂໍ້ມູນ 1C):

conversationKeyChecker.check("БЕНЗОКОЛОНКА");

      doInClusterLock("БЕНЗОКОЛОНКА", () -> {

          conversationKeyChecker.check("БЕНЗОКОЛОНКА");

          createChannel("БЕНЗОКОЛОНКА");
      });

ພວກເຮົາໄດ້ກວດເບິ່ງວ່າບໍ່ມີຊ່ອງທາງ. ພວກເຮົາເອົາລັອກ, ກວດເບິ່ງມັນອີກເທື່ອຫນຶ່ງ, ແລະສ້າງມັນ. ຖ້າທ່ານບໍ່ກວດເບິ່ງການລັອກຫຼັງຈາກເອົາ lock, ມີໂອກາດທີ່ກະທູ້ອື່ນໄດ້ກວດເບິ່ງໃນເວລານັ້ນແລະໃນປັດຈຸບັນຈະພະຍາຍາມສ້າງການສົນທະນາດຽວກັນ - ແຕ່ມັນມີຢູ່ແລ້ວ. ທ່ານບໍ່ສາມາດລັອກໂດຍໃຊ້ synchronized ຫຼືປົກກະຕິ java Lock. ຜ່ານຖານຂໍ້ມູນ - ມັນຊ້າ, ແລະມັນເປັນສິ່ງທີ່ຫນ້າເສຍໃຈສໍາລັບຖານຂໍ້ມູນ; ຜ່ານ Hazelcast - ນັ້ນແມ່ນສິ່ງທີ່ທ່ານຕ້ອງການ.

ການເລືອກ DBMS

ພວກເຮົາມີປະສົບການຢ່າງກວ້າງຂວາງແລະປະສົບຜົນສໍາເລັດໃນການເຮັດວຽກກັບ PostgreSQL ແລະຮ່ວມມືກັບນັກພັດທະນາຂອງ DBMS ນີ້.

ມັນບໍ່ງ່າຍກັບກຸ່ມ PostgreSQL - ມີ XL, XC, ພົນລະເມືອງ, ແຕ່ໂດຍທົ່ວໄປເຫຼົ່ານີ້ບໍ່ແມ່ນ NoSQLs ທີ່ຂະຫນາດອອກຈາກກ່ອງ. ພວກເຮົາບໍ່ໄດ້ພິຈາລະນາ NoSQL ເປັນການເກັບຮັກສາຕົ້ນຕໍ; ມັນພຽງພໍທີ່ພວກເຮົາເອົາ Hazelcast, ເຊິ່ງພວກເຮົາບໍ່ເຄີຍເຮັດວຽກກັບມາກ່ອນ.

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

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

ທ່ານສາມາດອ່ານກ່ຽວກັບຜູ້ເຊົ່າຫຼາຍ, ຕົວຢ່າງ, ຢູ່ໃນເວັບໄຊທ໌ ຂໍ້ມູນ Citus.

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

ພວກເຮົາມີຖານຂໍ້ມູນຕົ້ນຕໍທີ່ຕາຕະລາງເສັ້ນທາງຖືກເກັບໄວ້ດ້ວຍຂໍ້ມູນກ່ຽວກັບສະຖານທີ່ຂອງຖານຂໍ້ມູນຜູ້ຈອງທັງຫມົດ.

ເພື່ອປ້ອງກັນຖານຂໍ້ມູນຫຼັກຈາກການເປັນກະຕຸກ, ພວກເຮົາຮັກສາຕາຕະລາງການກໍານົດເສັ້ນທາງ (ແລະຂໍ້ມູນທີ່ຈໍາເປັນເລື້ອຍໆອື່ນໆ) ຢູ່ໃນ cache.

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

ເນື່ອງຈາກການສູນເສຍຂໍ້ຄວາມຂອງຜູ້ໃຊ້ແມ່ນບໍ່ດີ, ພວກເຮົາຮັກສາຖານຂໍ້ມູນຂອງພວກເຮົາດ້ວຍການຈໍາລອງ. ການປະສົມປະສານຂອງ replicas synchronous ແລະ asynchronous ຊ່ວຍໃຫ້ທ່ານສາມາດຮັບປະກັນຕົວທ່ານເອງໃນກໍລະນີຂອງການສູນເສຍຖານຂໍ້ມູນຕົ້ນຕໍ. ການ​ສູນ​ເສຍ​ຂໍ້​ຄວາມ​ຈະ​ເກີດ​ຂຶ້ນ​ພຽງ​ແຕ່​ຖ້າ​ຫາກ​ວ່າ​ຖານ​ຂໍ້​ມູນ​ຕົ້ນ​ຕໍ​ແລະ replica synchronous ຂອງ​ມັນ​ລົ້ມ​ເຫຼວ​ພ້ອມ​ກັນ​.

ຖ້າການຈໍາລອງແບບ synchronous ສູນເສຍໄປ, ການຈໍາລອງແບບ asynchronous ຈະກາຍເປັນ synchronous.
ຖ້າຖານຂໍ້ມູນຕົ້ນຕໍຖືກສູນເສຍ, ການຈໍາລອງແບບ synchronous ກາຍເປັນຖານຂໍ້ມູນຕົ້ນຕໍ, ແລະການຈໍາລອງແບບ asynchronous ກາຍເປັນ replica synchronous.

Elasticsearch ສໍາລັບການຄົ້ນຫາ

ເນື່ອງຈາກວ່າ, ໃນບັນດາສິ່ງອື່ນໆ, SV ຍັງເປັນຜູ້ສົ່ງຂ່າວ, ມັນຮຽກຮ້ອງໃຫ້ມີການຄົ້ນຫາທີ່ໄວ, ສະດວກແລະມີຄວາມຍືດຫຍຸ່ນ, ໂດຍຄໍານຶງເຖິງ morphology, ການນໍາໃຊ້ການຈັບຄູ່ທີ່ບໍ່ຊັດເຈນ. ພວກເຮົາຕັດສິນໃຈບໍ່ reinvent ລໍ້ແລະນໍາໃຊ້ Elasticsearch ເຄື່ອງຈັກຊອກຫາຟຣີ, ສ້າງໂດຍອີງໃສ່ຫ້ອງສະຫມຸດ ລູຊີນ. ພວກເຮົາຍັງໃຊ້ Elasticsearch ໃນກຸ່ມ (ແມ່ບົດ – ຂໍ້ມູນ – ຂໍ້ມູນ) ເພື່ອກໍາຈັດບັນຫາໃນກໍລະນີຂອງການລົ້ມເຫຼວຂອງ nodes ຄໍາຮ້ອງສະຫມັກ.

ໃນ github ພວກເຮົາພົບເຫັນ plugin morphology ພາສາລັດເຊຍ ສໍາລັບ Elasticsearch ແລະນໍາໃຊ້ມັນ. ໃນດັດຊະນີ Elasticsearch ພວກເຮົາເກັບຮັກສາຮາກຄໍາສັບ (ທີ່ plugin ກໍານົດ) ແລະ N-grams. ເມື່ອຜູ້ໃຊ້ໃສ່ຂໍ້ຄວາມເພື່ອຄົ້ນຫາ, ພວກເຮົາຊອກຫາຂໍ້ຄວາມທີ່ພິມໃນບັນດາ N-grams. ເມື່ອບັນທຶກໄວ້ໃນດັດຊະນີ, ຄໍາວ່າ "ຂໍ້ຄວາມ" ຈະຖືກແບ່ງອອກເປັນ N-grams ຕໍ່ໄປນີ້:

[ເຫຼົ່ານັ້ນ, tek, tex, ຂໍ້ຄວາມ, ຂໍ້ຄວາມ, ek, ex, ext, ຂໍ້ຄວາມ, ks, kst, ksty, st, sty, ທ່ານ],

ແລະຮາກຂອງຄໍາວ່າ "ຂໍ້ຄວາມ" ຍັງຈະຖືກຮັກສາໄວ້. ວິທີການນີ້ຊ່ວຍໃຫ້ທ່ານສາມາດຄົ້ນຫາໃນຕອນຕົ້ນ, ໃນກາງ, ແລະໃນຕອນທ້າຍຂອງຄໍາ.

ພາບໃຫຍ່

ເຮັດຊ້ໍາຮູບໃນຕອນຕົ້ນຂອງບົດຄວາມ, ແຕ່ມີຄໍາອະທິບາຍ:

• Balancer ເປີດເຜີຍໃນອິນເຕີເນັດ; ພວກເຮົາມີ nginx, ມັນສາມາດເປັນອັນໃດກໍ່ໄດ້.
• Java application instances ຕິດຕໍ່ສື່ສານກັນຜ່ານ Hazelcast.
• ເພື່ອເຮັດວຽກກັບຊັອກເກັດເວັບທີ່ພວກເຮົາໃຊ້ ສຸດທິ.
• ຄໍາຮ້ອງສະຫມັກ Java ແມ່ນຂຽນໃນ Java 8 ແລະປະກອບດ້ວຍມັດ OSGi. ແຜນການປະກອບມີການເຄື່ອນຍ້າຍໄປຫາ Java 10 ແລະການຫັນປ່ຽນໄປສູ່ໂມດູນ.

ການພັດທະນາແລະການທົດສອບ

ໃນຂະບວນການຂອງການພັດທະນາແລະການທົດສອບ SV, ພວກເຮົາໄດ້ພົບເຫັນຫຼາຍລັກສະນະທີ່ຫນ້າສົນໃຈຂອງຜະລິດຕະພັນທີ່ພວກເຮົາໃຊ້.

ການທົດສອບການໂຫຼດແລະການຮົ່ວໄຫລຂອງຫນ່ວຍຄວາມຈໍາ

ການປ່ອຍແຕ່ລະລຸ້ນ SV ກ່ຽວຂ້ອງກັບການທົດສອບການໂຫຼດ. ມັນປະສົບຜົນສໍາເລັດເມື່ອ:

• ການທົດສອບເຮັດວຽກເປັນເວລາຫຼາຍມື້ແລະບໍ່ມີການບໍລິການລົ້ມເຫລວ
• ເວລາຕອບສະຫນອງສໍາລັບການປະຕິບັດງານທີ່ສໍາຄັນບໍ່ເກີນຂອບເຂດທີ່ສະດວກສະບາຍ
• ການ​ປະ​ຕິ​ບັດ​ການ​ຫຼຸດ​ລົງ​ເມື່ອ​ທຽບ​ໃສ່​ກັບ​ສະ​ບັບ​ຜ່ານ​ມາ​ແມ່ນ​ບໍ່​ເກີນ 10​%

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

ພວກເຮົາປະຕິບັດການທົດສອບການໂຫຼດຂອງລະບົບການໂຕ້ຕອບໃນສາມການຕັ້ງຄ່າ:

1. ການທົດສອບຄວາມກົດດັນ
2. ການເຊື່ອມຕໍ່ເທົ່ານັ້ນ
3. ການລົງທະບຽນສະມາຊິກ

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

ຕົວຢ່າງ, ນີ້ແມ່ນສ່ວນຫນຶ່ງຂອງການທົດສອບຄວາມກົດດັນເບິ່ງຄືວ່າ:

• ຜູ້ໃຊ້ເຂົ້າສູ່ລະບົບ
  • ຮ້ອງຂໍການສົນທະນາທີ່ຍັງບໍ່ໄດ້ອ່ານຂອງທ່ານ
  • 50% ແນວໂນ້ມທີ່ຈະອ່ານຂໍ້ຄວາມ
  • 50% ແນວໂນ້ມທີ່ຈະສົ່ງຂໍ້ຄວາມ
  • ຜູ້ໃຊ້ຕໍ່ໄປ:
    • ມີໂອກາດ 20% ໃນການສ້າງການສົນທະນາໃຫມ່
    • ສຸ່ມເລືອກການສົນທະນາໃດໆຂອງມັນ
    • ເຂົ້າໄປພາຍໃນ
    • ຮ້ອງຂໍຂໍ້ຄວາມ, ໂປຣໄຟລ໌ຜູ້ໃຊ້
    • ສ້າງຫ້າຂໍ້ຄວາມທີ່ສົ່ງກັບຜູ້ໃຊ້ແບບສຸ່ມຈາກການສົນທະນານີ້
    • ອອກຈາກການສົນທະນາ
    • ເຮັດຊ້ຳ 20 ເທື່ອ
    • ອອກຈາກລະບົບ, ກັບໄປທີ່ຈຸດເລີ່ມຕົ້ນຂອງສະຄຣິບ

  • chatbot ເຂົ້າໄປໃນລະບົບ (emulates ຂໍ້ຄວາມຈາກລະຫັດຄໍາຮ້ອງສະຫມັກ)
    • ມີໂອກາດ 50% ໃນການສ້າງຊ່ອງທາງໃຫມ່ສໍາລັບການແລກປ່ຽນຂໍ້ມູນ (ການສົນທະນາພິເສດ)
    • 50% ມີແນວໂນ້ມທີ່ຈະຂຽນຂໍ້ຄວາມໄປຫາຊ່ອງທາງໃດໆທີ່ມີຢູ່

ສະຖານະການ "ການເຊື່ອມຕໍ່ເທົ່ານັ້ນ" ປາກົດຂຶ້ນດ້ວຍເຫດຜົນ. ມີສະຖານະການ: ຜູ້ໃຊ້ໄດ້ເຊື່ອມຕໍ່ລະບົບ, ແຕ່ຍັງບໍ່ທັນໄດ້ມີສ່ວນຮ່ວມ. ຜູ້ໃຊ້ແຕ່ລະຄົນເປີດຄອມພິວເຕີໃນເວລາ 09:00 ຕອນເຊົ້າ, ສ້າງການເຊື່ອມຕໍ່ກັບເຄື່ອງແມ່ຂ່າຍແລະຍັງງຽບ. ຄົນເຫຼົ່ານີ້ເປັນອັນຕະລາຍ, ມີຈໍານວນຫຼາຍຂອງພວກເຂົາ - ຊຸດດຽວທີ່ພວກເຂົາມີແມ່ນ PING / PONG, ແຕ່ພວກເຂົາຮັກສາການເຊື່ອມຕໍ່ກັບເຄື່ອງແມ່ຂ່າຍ (ພວກເຂົາບໍ່ສາມາດຮັກສາມັນໄດ້ - ຈະເປັນແນວໃດຖ້າມີຂໍ້ຄວາມໃຫມ່). ການທົດສອບ reproduces ສະຖານະການທີ່ຈໍານວນຂະຫນາດໃຫຍ່ຂອງຜູ້ໃຊ້ດັ່ງກ່າວພະຍາຍາມເຂົ້າສູ່ລະບົບໃນເຄິ່ງຊົ່ວໂມງ. ມັນຄ້າຍຄືກັນກັບການທົດສອບຄວາມກົດດັນ, ແຕ່ຈຸດສຸມຂອງມັນແມ່ນຊັດເຈນກ່ຽວກັບການປ້ອນຂໍ້ມູນທໍາອິດນີ້ - ເພື່ອບໍ່ໃຫ້ມີຄວາມລົ້ມເຫລວ (ບຸກຄົນໃດຫນຶ່ງບໍ່ໄດ້ໃຊ້ລະບົບ, ແລະມັນຫຼຸດລົງແລ້ວ - ມັນເປັນການຍາກທີ່ຈະຄິດເຖິງສິ່ງທີ່ຮ້າຍແຮງກວ່າເກົ່າ).

script ການລົງທະບຽນຜູ້ສະຫມັກເລີ່ມຕົ້ນຈາກການເປີດຕົວຄັ້ງທໍາອິດ. ພວກເຮົາໄດ້ດໍາເນີນການທົດສອບຄວາມກົດດັນແລະແນ່ໃຈວ່າລະບົບບໍ່ຊ້າລົງໃນລະຫວ່າງການຕິດຕໍ່. ແຕ່ຜູ້ໃຊ້ມາແລະການລົງທະບຽນເລີ່ມຕົ້ນລົ້ມເຫລວເນື່ອງຈາກຫມົດເວລາ. ເມື່ອລົງທະບຽນພວກເຮົາໃຊ້ / dev / ສຸ່ມ, ເຊິ່ງກ່ຽວຂ້ອງກັບ entropy ຂອງລະບົບ. ເຊີບເວີບໍ່ມີເວລາທີ່ຈະສະສົມ entropy ພຽງພໍແລະເມື່ອມີການຮ້ອງຂໍ SecureRandom ໃຫມ່, ມັນ froze ສໍາລັບສິບວິນາທີ. ມີຫຼາຍວິທີອອກຈາກສະຖານະການນີ້, ຕົວຢ່າງ: ປ່ຽນໄປຫາ /dev/urandom ທີ່ປອດໄພຫນ້ອຍ, ຕິດຕັ້ງກະດານພິເສດທີ່ສ້າງ entropy, ສ້າງຕົວເລກແບບສຸ່ມລ່ວງຫນ້າແລະເກັບຮັກສາໄວ້ໃນສະນຸກເກີ. ພວກເຮົາປິດຊົ່ວຄາວບັນຫາກັບສະນຸກເກີ, ແຕ່ນັບຕັ້ງແຕ່ນັ້ນມາພວກເຮົາໄດ້ດໍາເນີນການທົດສອບແຍກຕ່າງຫາກສໍາລັບການລົງທະບຽນຜູ້ສະຫມັກໃຫມ່.

ພວກເຮົາໃຊ້ເປັນເຄື່ອງກໍາເນີດການໂຫຼດ JMeter. ມັນບໍ່ຮູ້ວິທີການເຮັດວຽກກັບ websocket; ມັນຕ້ອງການ plugin. ທໍາອິດໃນຜົນການຄົ້ນຫາສໍາລັບການສອບຖາມ "jmeter websocket" ແມ່ນ: ບົດຄວາມຈາກ BlazeMeter, ທີ່ແນະນໍາ plugin ໂດຍ Maciej Zaleski.

ນັ້ນແມ່ນບ່ອນທີ່ພວກເຮົາຕັດສິນໃຈເລີ່ມຕົ້ນ.

ເກືອບທັນທີຫຼັງຈາກເລີ່ມການທົດສອບຢ່າງຈິງຈັງ, ພວກເຮົາຄົ້ນພົບວ່າ JMeter ເລີ່ມຮົ່ວຄວາມຊົງຈໍາ.

plugin ແມ່ນເລື່ອງໃຫຍ່ແຍກຕ່າງຫາກ; ມີ 176 ດາວ, ມັນມີ 132 fork ໃນ github. ຜູ້ຂຽນເອງບໍ່ໄດ້ຫມັ້ນສັນຍາກັບມັນນັບຕັ້ງແຕ່ 2015 (ພວກເຮົາໄດ້ເອົາມັນໃນປີ 2015, ຫຼັງຈາກນັ້ນມັນບໍ່ໄດ້ເຮັດໃຫ້ເກີດຄວາມສົງໃສ), ບັນຫາ github ຈໍານວນຫນຶ່ງກ່ຽວກັບການຮົ່ວໄຫລຂອງຫນ່ວຍຄວາມຈໍາ, 7 ຄໍາຮ້ອງຂໍດຶງທີ່ບໍ່ເປີດເຜີຍ.
ຖ້າທ່ານຕັດສິນໃຈເຮັດການທົດສອບການໂຫຼດໂດຍໃຊ້ plugin ນີ້, ກະລຸນາເອົາໃຈໃສ່ກັບການສົນທະນາຕໍ່ໄປນີ້:

1. ໃນສະພາບແວດລ້ອມຫຼາຍກະທູ້, LinkedList ປົກກະຕິໄດ້ຖືກນໍາໃຊ້, ແລະຜົນໄດ້ຮັບແມ່ນ NPE ໃນ runtime. ນີ້ສາມາດແກ້ໄຂໄດ້ໂດຍການປ່ຽນໄປໃຊ້ ConcurrentLinkedDeque ຫຼືໂດຍຕັນ synchronized. ພວກເຮົາເລືອກທາງເລືອກທໍາອິດສໍາລັບຕົວເຮົາເອງ (https://github.com/maciejzaleski/JMeter-WebSocketSampler/issues/43).
2. ຄວາມ​ຈໍາ​ຮົ່ວ​ໄຫລ​; ໃນ​ເວ​ລາ​ທີ່​ຕັດ​ການ​ເຊື່ອມ​ຕໍ່​, ຂໍ້​ມູນ​ການ​ເຊື່ອມ​ຕໍ່​ບໍ່​ໄດ້​ຖືກ​ລົບ (https://github.com/maciejzaleski/JMeter-WebSocketSampler/issues/44).
3. ໃນໂຫມດການຖ່າຍທອດ (ເມື່ອ websocket ບໍ່ໄດ້ປິດໃນຕອນທ້າຍຂອງຕົວຢ່າງ, ແຕ່ຖືກນໍາໃຊ້ຕໍ່ມາໃນແຜນການ), ຮູບແບບການຕອບສະຫນອງບໍ່ເຮັດວຽກ (https://github.com/maciejzaleski/JMeter-WebSocketSampler/issues/19).

ນີ້ແມ່ນ ໜຶ່ງ ໃນຜູ້ທີ່ຢູ່ໃນ github. ສິ່ງທີ່ພວກເຮົາໄດ້ເຮັດ:

1. ໄດ້ປະຕິບັດ ສ້ອມ Elyran Kogan (@elyrank) – ມັນແກ້ໄຂບັນຫາ 1 ແລະ 3
2. ແກ້​ໄຂ​ບັນ​ຫາ 2
3. ອັບເດດ jetty ຈາກ 9.2.14 ເປັນ 9.3.12
4. Wrapped SimpleDateFormat ໃນ ThreadLocal; SimpleDateFormat ບໍ່ປອດໄພກະທູ້, ເຊິ່ງນໍາໄປສູ່ NPE ໃນເວລາແລ່ນ
5. ແກ້​ໄຂ​ຄວາມ​ຊົງ​ຈໍາ​ອື່ນ​ຮົ່ວ (ການ​ເຊື່ອມ​ຕໍ່​ໄດ້​ຖືກ​ປິດ​ຜິດ​ພາດ​ໃນ​ເວ​ລາ​ທີ່​ຕັດ​ການ​ເຊື່ອມ​ຕໍ່​)

ແລະທັນມັນໄຫຼ!

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

ສອງມື້ຜ່ານໄປ...

ຕອນນີ້ Hazelcast ກຳລັງຈະໝົດຄວາມຊົງຈຳແລ້ວ. ບັນທຶກໄດ້ສະແດງໃຫ້ເຫັນວ່າຫຼັງຈາກການທົດສອບສອງສາມມື້, Hazelcast ເລີ່ມຈົ່ມກ່ຽວກັບການຂາດຄວາມຊົງຈໍາ, ແລະຫຼັງຈາກບາງເວລາ, ກຸ່ມດັ່ງກ່າວໄດ້ແຕກແຍກ, ແລະຂໍ້ຕໍ່ສືບຕໍ່ຕາຍເທື່ອລະອັນ. ພວກເຮົາໄດ້ເຊື່ອມຕໍ່ JVisualVM ກັບ hazelcast ແລະເຫັນ " saw ເພີ່ມຂຶ້ນ" - ມັນເປັນປົກກະຕິເອີ້ນວ່າ GC, ແຕ່ບໍ່ສາມາດລ້າງຄວາມຊົງຈໍາໄດ້.

ມັນໄດ້ຫັນອອກວ່າໃນ hazelcast 3.4, ເມື່ອລຶບແຜນທີ່ / multiMap (map.destroy()), ຫນ່ວຍຄວາມຈໍາບໍ່ໄດ້ຖືກປົດປ່ອຍຢ່າງສົມບູນ:

github.com/hazelcast/hazelcast/issues/6317
github.com/hazelcast/hazelcast/issues/4888

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

public void join(Authentication auth, String sub) {
    MultiMap<UUID, Authentication> sessions = instance.getMultiMap(sub);
    sessions.put(auth.getUserId(), auth);
}

public void leave(Authentication auth, String sub) {
    MultiMap<UUID, Authentication> sessions = instance.getMultiMap(sub);
    sessions.remove(auth.getUserId(), auth);

    if (sessions.size() == 0) {
        sessions.destroy();
    }
}

ໂທ:

service.join(auth1, "НОВЫЕ_СООБЩЕНИЯ_В_ОБСУЖДЕНИИ_UUID1");
service.join(auth2, "НОВЫЕ_СООБЩЕНИЯ_В_ОБСУЖДЕНИИ_UUID1");

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

public void join(Authentication auth, String sub) {
    addValueToMap(sub, auth.getSessionId());
}

public void leave(Authentication auth, String sub) { 
    removeValueFromMap(sub, auth.getSessionId());
}

ຕາຕະລາງໄດ້ຮັບການປັບປຸງ.

ພວກເຮົາໄດ້ຮຽນຮູ້ຫຍັງອີກແດ່ກ່ຽວກັບການທົດສອບການໂຫຼດ?

1. JSR223 ຕ້ອງໄດ້ຮັບການຂຽນເປັນ groovy ແລະປະກອບມີ cache ການລວບລວມ - ມັນໄວກວ່າຫຼາຍ. ການເຊື່ອມຕໍ່.
2. ກຣາຟ Jmeter-Plugins ແມ່ນເຂົ້າໃຈງ່າຍກວ່າມາດຕະຖານ. ການເຊື່ອມຕໍ່.

ກ່ຽວກັບປະສົບການຂອງພວກເຮົາກັບ Hazelcast

Hazelcast ເປັນຜະລິດຕະພັນໃຫມ່ສໍາລັບພວກເຮົາ, ພວກເຮົາໄດ້ເລີ່ມເຮັດວຽກກັບມັນຈາກສະບັບ 3.4.1, ໃນປັດຈຸບັນເຄື່ອງແມ່ຂ່າຍການຜະລິດຂອງພວກເຮົາກໍາລັງດໍາເນີນການສະບັບ 3.9.2 (ໃນເວລາຂຽນ, ສະບັບຫລ້າສຸດຂອງ Hazelcast ແມ່ນ 3.10).

ການສ້າງ ID

ພວກເຮົາເລີ່ມຕົ້ນດ້ວຍຕົວລະບຸຈໍານວນເຕັມ. ໃຫ້ຈິນຕະນາການວ່າພວກເຮົາຕ້ອງການ Long ອື່ນສໍາລັບຫນ່ວຍງານໃຫມ່. ລໍາດັບໃນຖານຂໍ້ມູນບໍ່ເຫມາະສົມ, ຕາຕະລາງມີສ່ວນຮ່ວມໃນ sharding - ປະກົດວ່າມີຂໍ້ຄວາມ ID = 1 ໃນ DB1 ແລະຂໍ້ຄວາມ ID = 1 ໃນ DB2, ທ່ານບໍ່ສາມາດໃສ່ ID ນີ້ໃນ Elasticsearch, ຫຼືຢູ່ໃນ Hazelcast. , ແຕ່ສິ່ງທີ່ຮ້າຍແຮງທີ່ສຸດແມ່ນຖ້າທ່ານຕ້ອງການລວມເອົາຂໍ້ມູນຈາກສອງຖານຂໍ້ມູນເຂົ້າໄປໃນຫນຶ່ງ (ຕົວຢ່າງ, ການຕັດສິນໃຈວ່າຖານຂໍ້ມູນຫນຶ່ງແມ່ນພຽງພໍສໍາລັບຜູ້ຈອງເຫຼົ່ານີ້). ທ່ານສາມາດເພີ່ມ AtomicLongs ຫຼາຍໆອັນໃສ່ Hazelcast ແລະຮັກສາ counter ຢູ່ທີ່ນັ້ນ, ຫຼັງຈາກນັ້ນ, ການປະຕິບັດການໄດ້ຮັບ ID ໃຫມ່ແມ່ນ incrementAndGet ບວກກັບເວລາສໍາລັບການຮ້ອງຂໍ Hazelcast. ແຕ່ Hazelcast ມີບາງສິ່ງບາງຢ່າງທີ່ດີທີ່ສຸດ - FlakeIdGenerator. ເມື່ອຕິດຕໍ່ກັບລູກຄ້າແຕ່ລະຄົນ, ພວກເຂົາໄດ້ຮັບຂອບເຂດ ID, ຕົວຢ່າງ, ທໍາອິດ - ຈາກ 1 ຫາ 10, ທີສອງ - ຈາກ 000 ຫາ 10, ແລະອື່ນໆ. ດຽວນີ້ລູກຄ້າສາມາດອອກຕົວລະບຸຕົວຕົນໃໝ່ໄດ້ເອງຈົນກວ່າຂອບເຂດທີ່ອອກໃຫ້ມັນສິ້ນສຸດ. ມັນເຮັດວຽກຢ່າງໄວວາ, ແຕ່ເມື່ອທ່ານ restart ແອັບພລິເຄຊັນ (ແລະລູກຄ້າ Hazelcast), ລໍາດັບໃຫມ່ເລີ່ມຕົ້ນ - ດັ່ງນັ້ນການຂ້າມ, ແລະອື່ນໆ. ນອກຈາກນັ້ນ, ນັກພັດທະນາບໍ່ເຂົ້າໃຈແທ້ໆວ່າເປັນຫຍັງ IDs ເປັນຈໍານວນເຕັມ, ແຕ່ມັນບໍ່ສອດຄ່ອງກັນ. ພວກເຮົາຊັ່ງນໍ້າໜັກທຸກຢ່າງ ແລະປ່ຽນໄປໃຊ້ UUIDs.

ໂດຍວິທີທາງການ, ສໍາລັບຜູ້ທີ່ຢາກເປັນຄືກັບ Twitter, ມີຫ້ອງສະຫມຸດ Snowcast ດັ່ງກ່າວ - ນີ້ແມ່ນການປະຕິບັດຂອງ Snowflake ຢູ່ເທິງສຸດຂອງ Hazelcast. ທ່ານສາມາດເບິ່ງມັນໄດ້ທີ່ນີ້:

github.com/noctarius/snowcast
github.com/twitter/snowflake

ແຕ່​ພວກ​ເຮົາ​ບໍ່​ໄດ້​ເຂົ້າ​ໄປ​ໃກ້​ມັນ​ອີກ​ແລ້ວ​.

TransactionalMap.replace

ຄວາມແປກໃຈອີກອັນໜຶ່ງ: TransactionalMap.replace ບໍ່ເຮັດວຽກ. ນີ້ແມ່ນການທົດສອບ:

@Test
public void replaceInMap_putsAndGetsInsideTransaction() {

    hazelcastInstance.executeTransaction(context -> {
        HazelcastTransactionContextHolder.setContext(context);
        try {
            context.getMap("map").put("key", "oldValue");
            context.getMap("map").replace("key", "oldValue", "newValue");
            
            String value = (String) context.getMap("map").get("key");
            assertEquals("newValue", value);

            return null;
        } finally {
            HazelcastTransactionContextHolder.clearContext();
        }        
    });
}

Expected : newValue
Actual : oldValue

ຂ້ອຍຕ້ອງຂຽນຕົວແທນຂອງຂ້ອຍເອງໂດຍໃຊ້ getForUpdate:

protected <K,V> boolean replaceInMap(String mapName, K key, V oldValue, V newValue) {
    TransactionalTaskContext context = HazelcastTransactionContextHolder.getContext();
    if (context != null) {
        log.trace("[CACHE] Replacing value in a transactional map");
        TransactionalMap<K, V> map = context.getMap(mapName);
        V value = map.getForUpdate(key);
        if (oldValue.equals(value)) {
            map.put(key, newValue);
            return true;
        }

        return false;
    }
    log.trace("[CACHE] Replacing value in a not transactional map");
    IMap<K, V> map = hazelcastInstance.getMap(mapName);
    return map.replace(key, oldValue, newValue);
}

ທົດສອບບໍ່ພຽງແຕ່ໂຄງສ້າງຂໍ້ມູນປົກກະຕິ, ແຕ່ຍັງສະບັບການເຮັດທຸລະກໍາຂອງພວກເຂົາ. ມັນເກີດຂື້ນວ່າ IMap ເຮັດວຽກ, ແຕ່ TransactionalMap ບໍ່ມີແລ້ວ.

ໃສ່ JAR ໃໝ່ ໂດຍບໍ່ຕ້ອງຢຸດເວລາ

ຫນ້າທໍາອິດ, ພວກເຮົາໄດ້ຕັດສິນໃຈທີ່ຈະບັນທຶກວັດຖຸຂອງຫ້ອງຮຽນຂອງພວກເຮົາໃນ Hazelcast. ຕົວຢ່າງ: ພວກເຮົາມີຫ້ອງຮຽນ Application, ພວກເຮົາຕ້ອງການບັນທຶກແລະອ່ານມັນ. ບັນທຶກ:

IMap<UUID, Application> map = hazelcastInstance.getMap("application");
map.set(id, application);

ພວກເຮົາອ່ານ:

IMap<UUID, Application> map = hazelcastInstance.getMap("application");
return map.get(id);

ທຸກສິ່ງທຸກຢ່າງແມ່ນເຮັດວຽກ. ຫຼັງຈາກນັ້ນ, ພວກເຮົາໄດ້ຕັດສິນໃຈສ້າງດັດສະນີໃນ Hazelcast ເພື່ອຄົ້ນຫາໂດຍ:

map.addIndex("subscriberId", false);

ແລະໃນເວລາທີ່ຂຽນນິຕິບຸກຄົນໃຫມ່, ພວກເຂົາເຈົ້າໄດ້ເລີ່ມຕົ້ນໄດ້ຮັບ ClassNotFoundException. Hazelcast ພະຍາຍາມເພີ່ມເຂົ້າໃນດັດຊະນີ, ແຕ່ບໍ່ຮູ້ຫຍັງກ່ຽວກັບຫ້ອງຮຽນຂອງພວກເຮົາແລະຕ້ອງການ JAR ທີ່ມີຫ້ອງຮຽນນີ້ເພື່ອສະຫນອງໃຫ້ແກ່ມັນ. ພວກເຮົາເຮັດໄດ້ພຽງແຕ່ວ່າ, ທຸກສິ່ງທຸກຢ່າງໄດ້ເຮັດວຽກ, ແຕ່ບັນຫາໃຫມ່ປະກົດວ່າ: ວິທີການປັບປຸງ JAR ໂດຍບໍ່ມີການຢຸດເຊົາຢ່າງສົມບູນ? Hazelcast ບໍ່ໄດ້ເອົາ JAR ໃຫມ່ໃນລະຫວ່າງການອັບເດດ node-by-node. ໃນຈຸດນີ້ພວກເຮົາໄດ້ຕັດສິນໃຈວ່າພວກເຮົາສາມາດດໍາລົງຊີວິດໂດຍບໍ່ມີການຄົ້ນຫາດັດສະນີ. ຫຼັງຈາກທີ່ທັງຫມົດ, ຖ້າທ່ານໃຊ້ Hazelcast ເປັນຮ້ານທີ່ສໍາຄັນ, ແລ້ວທຸກສິ່ງທຸກຢ່າງຈະເຮັດວຽກບໍ? ບໍ່ແມ່ນແທ້. ນີ້ອີກເທື່ອຫນຶ່ງພຶດຕິກໍາຂອງ IMap ແລະ TransactionalMap ແມ່ນແຕກຕ່າງກັນ. ບ່ອນທີ່ IMap ບໍ່ສົນໃຈ, TransactionalMap ຖິ້ມຄວາມຜິດພາດ.

IMap. ພວກເຮົາຂຽນ 5000 ວັດຖຸ, ອ່ານໃຫ້ເຂົາເຈົ້າ. ທຸກສິ່ງທຸກຢ່າງແມ່ນຄາດວ່າຈະ.

@Test
void get5000() {
    IMap<UUID, Application> map = hazelcastInstance.getMap("application");
    UUID subscriberId = UUID.randomUUID();

    for (int i = 0; i < 5000; i++) {
        UUID id = UUID.randomUUID();
        String title = RandomStringUtils.random(5);
        Application application = new Application(id, title, subscriberId);
        
        map.set(id, application);
        Application retrieved = map.get(id);
        assertEquals(id, retrieved.getId());
    }
}

ແຕ່ມັນບໍ່ໄດ້ເຮັດວຽກຢູ່ໃນທຸລະກໍາ, ພວກເຮົາໄດ້ຮັບ ClassNotFoundException:

@Test
void get_transaction() {
    IMap<UUID, Application> map = hazelcastInstance.getMap("application_t");
    UUID subscriberId = UUID.randomUUID();
    UUID id = UUID.randomUUID();

    Application application = new Application(id, "qwer", subscriberId);
    map.set(id, application);
    
    Application retrievedOutside = map.get(id);
    assertEquals(id, retrievedOutside.getId());

    hazelcastInstance.executeTransaction(context -> {
        HazelcastTransactionContextHolder.setContext(context);
        try {
            TransactionalMap<UUID, Application> transactionalMap = context.getMap("application_t");
            Application retrievedInside = transactionalMap.get(id);

            assertEquals(id, retrievedInside.getId());
            return null;
        } finally {
            HazelcastTransactionContextHolder.clearContext();
        }
    });
}

ໃນ 3.8, ກົນໄກການປັບໃຊ້ຫ້ອງຮຽນຜູ້ໃຊ້ປາກົດ. ທ່ານສາມາດກໍານົດຫນຶ່ງ master node ແລະປັບປຸງໄຟລ໌ JAR ໃນມັນ.

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

ເຮັດແນວໃດພວກເຮົາຮັບປະກັນປະສິດທິພາບສູງ

ສີ່ການເດີນທາງໄປຫາ Hazelcast - ດີ, ສອງໄປຫາຖານຂໍ້ມູນ - ບໍ່ດີ

ການໄປທີ່ແຄດສໍາລັບຂໍ້ມູນແມ່ນດີກວ່າທີ່ຈະໄປຫາຖານຂໍ້ມູນ, ແຕ່ທ່ານບໍ່ຕ້ອງການເກັບຮັກສາບັນທຶກທີ່ບໍ່ໄດ້ໃຊ້. ພວກເຮົາອອກຈາກການຕັດສິນໃຈກ່ຽວກັບສິ່ງທີ່ຈະ cache ຈົນກ່ວາຂັ້ນຕອນສຸດທ້າຍຂອງການພັດທະນາ. ເມື່ອຟັງຊັນໃຫມ່ຖືກລະຫັດ, ພວກເຮົາເປີດການບັນທຶກການສອບຖາມທັງຫມົດໃນ PostgreSQL (log_min_duration_statement ເປັນ 0) ແລະດໍາເນີນການທົດສອບການໂຫຼດສໍາລັບ 20 ນາທີ. ການນໍາໃຊ້ບັນທຶກທີ່ເກັບກໍາ, utilities ເຊັ່ນ pgFouine ແລະ pgBadger ສາມາດສ້າງບົດລາຍງານການວິເຄາະ. ໃນບົດລາຍງານ, ພວກເຮົາຕົ້ນຕໍຊອກຫາການສອບຖາມຊ້າແລະເລື້ອຍໆ. ສໍາລັບການສອບຖາມທີ່ຊ້າ, ພວກເຮົາສ້າງແຜນການປະຕິບັດ (ອະທິບາຍ) ແລະປະເມີນວ່າຄໍາຖາມດັ່ງກ່າວສາມາດເລັ່ງໄດ້. ການຮ້ອງຂໍເລື້ອຍໆສໍາລັບຂໍ້ມູນການປ້ອນຂໍ້ມູນດຽວກັນເຫມາະສົມກັບ cache. ພວກເຮົາພະຍາຍາມຮັກສາແບບສອບຖາມ "ຮາບພຽງ", ຕາຕະລາງຫນຶ່ງຕໍ່ຄໍາຖາມ.

ການດໍາເນີນງານ

SV ເປັນບໍລິການອອນໄລນ໌ໄດ້ຖືກປະຕິບັດໃນພາກຮຽນ spring ຂອງ 2017, ແລະເປັນຜະລິດຕະພັນແຍກຕ່າງຫາກ, SV ໄດ້ຖືກປ່ອຍອອກມາໃນເດືອນພະຈິກ 2017 (ໃນເວລານັ້ນຢູ່ໃນສະຖານະພາບສະບັບເບຕ້າ).

ໃນຫຼາຍກວ່າຫນຶ່ງປີຂອງການດໍາເນີນງານ, ບໍ່ມີບັນຫາທີ່ຮ້າຍແຮງໃນການດໍາເນີນງານຂອງການບໍລິການອອນໄລນ໌ CB. ພວກເຮົາຕິດຕາມກວດກາການບໍລິການອອນໄລນ໌ໂດຍຜ່ານ Zabbix, ເກັບ​ກໍາ​ແລະ​ນໍາ​ໃຊ້​ຈາກ​ ໄມ້ໄຜ່.

ການແຈກຢາຍເຊີບເວີ SV ແມ່ນສະໜອງໃນຮູບແບບຂອງແພັກເກັດພື້ນເມືອງ: RPM, DEB, MSI. Plus ສໍາລັບ Windows ພວກເຮົາສະຫນອງການຕິດຕັ້ງດຽວໃນຮູບແບບຂອງ EXE ດຽວທີ່ຕິດຕັ້ງເຄື່ອງແມ່ຂ່າຍ, Hazelcast ແລະ Elasticsearch ໃນເຄື່ອງດຽວ. ພວກເຮົາໃນເບື້ອງຕົ້ນໄດ້ກ່າວເຖິງການຕິດຕັ້ງລຸ້ນນີ້ເປັນ “ສາທິດ” ເວີຊັ່ນ, ແຕ່ມັນໄດ້ກາຍເປັນທີ່ຈະແຈ້ງແລ້ວວ່ານີ້ແມ່ນທາງເລືອກໃນການນຳໃຊ້ທີ່ນິຍົມທີ່ສຸດ.

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