ບົດຮຽນ Kubernetes ສ່ວນທີ 1: ແອັບພລິເຄຊັນ, ການບໍລິການຈຸລະພາກ ແລະເຄື່ອງບັນຈຸ

ຕາມຄໍາຮ້ອງຂໍຂອງພວກເຮົາ, Habr ໄດ້ສ້າງສູນ Kubernetes ແລະພວກເຮົາມີຄວາມຍິນດີທີ່ຈະຈັດວາງສິ່ງພິມຄັ້ງທໍາອິດໃນມັນ. ຈອງ!

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

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

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

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

ຄໍາຮ້ອງສະຫມັກທົດລອງ

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

ນີ້ແມ່ນສິ່ງທີ່ປ່ອງຢ້ຽມຕົ້ນຕໍຂອງແອັບພລິເຄຊັນນີ້ເບິ່ງຄືວ່າ.

ຄໍາຮ້ອງສະຫມັກເວັບໄຊຕ໌ສໍາລັບການວິເຄາະຄວາມຮູ້ສຶກຂອງບົດເລື່ອງ

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

• SA-Frontend ເປັນເຊີບເວີເວັບ Nginx ທີ່ໃຫ້ບໍລິການໄຟລ໌ React ຄົງທີ່.
• SA-WebApp ແມ່ນແອັບພລິເຄຊັນເວັບທີ່ຂຽນໃນ Java ທີ່ປະມວນຜົນການຮ້ອງຂໍຈາກທາງຫນ້າ.
• SA-Logic ແມ່ນແອັບພລິເຄຊັນ Python ທີ່ປະຕິບັດການວິເຄາະຄວາມຮູ້ສຶກກ່ຽວກັບຂໍ້ຄວາມ.

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

ຂໍ້ມູນໄຫຼໃນແອັບພລິເຄຊັນ

ໃນແຜນວາດຂ້າງເທິງ, ທ່ານສາມາດເບິ່ງຂັ້ນຕອນຕົວເລກຂອງລະບົບ, ສະແດງໃຫ້ເຫັນການໄຫລຂອງຂໍ້ມູນໃນຄໍາຮ້ອງສະຫມັກ. ໃຫ້​ເຮົາ​ໄປ​ເບິ່ງ​ພວກ​ເຂົາ:

1. ຕົວທ່ອງເວັບຮ້ອງຂໍໄຟລ໌ຈາກເຄື່ອງແມ່ຂ່າຍ index.html (ເຊິ່ງ, ໃນທາງກັບກັນ, ດາວໂຫລດຊຸດແອັບພລິເຄຊັນ React).
2. ຜູ້ໃຊ້ໂຕ້ຕອບກັບແອັບພລິເຄຊັນ, ນີ້ເຮັດໃຫ້ເກີດການໂທໄປຫາແອັບພລິເຄຊັນເວັບທີ່ອີງໃສ່ພາກຮຽນ spring.
3. ແອັບພລິເຄຊັນເວັບສົ່ງຕໍ່ຄໍາຮ້ອງຂໍເພື່ອປະຕິບັດການວິເຄາະຂໍ້ຄວາມໄປຫາແອັບພລິເຄຊັນ Python.
4. ແອັບພລິເຄຊັນ Python ປະຕິບັດການວິເຄາະຄວາມຮູ້ສຶກຂອງຂໍ້ຄວາມແລະສົ່ງຜົນໄດ້ຮັບເປັນການຕອບສະຫນອງຕໍ່ການຮ້ອງຂໍ.
5. ຄໍາຮ້ອງສະຫມັກພາກຮຽນ spring ສົ່ງຄໍາຕອບກັບຄໍາຮ້ອງສະຫມັກ React (ເຊິ່ງ, ໃນທາງກັບກັນ, ສະແດງໃຫ້ເຫັນຜົນໄດ້ຮັບຂອງການວິເຄາະຂໍ້ຄວາມກັບຜູ້ໃຊ້).

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

ແລ່ນແອັບພລິເຄຊັນທີ່ອີງໃສ່ບໍລິການຈຸລະພາກຢູ່ໃນເຄື່ອງທ້ອງຖິ່ນຂອງທ່ານ

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

▍ຕັ້ງຄ່າ React ສໍາລັບການພັດທະນາທ້ອງຖິ່ນ

ເພື່ອດໍາເນີນການແອັບພລິເຄຊັນ React, ທ່ານຈໍາເປັນຕ້ອງຕິດຕັ້ງແພລະຕະຟອມ Node.js ແລະ NPM ໃນຄອມພິວເຕີຂອງທ່ານ. ເມື່ອທ່ານໄດ້ຕິດຕັ້ງທັງຫມົດນີ້, ໃຊ້ terminal ເພື່ອນໍາທາງໄປຫາໂຟນເດີໂຄງການຂອງທ່ານ sa-frontend ແລະດໍາເນີນການຄໍາສັ່ງຕໍ່ໄປນີ້:

npm install

ໂດຍການແລ່ນຄໍາສັ່ງນີ້ຢູ່ໃນໂຟນເດີ node_modules ຄວາມເພິ່ງພາອາໄສຂອງແອັບພລິເຄຊັນ React ຈະຖືກໂຫລດ, ບັນທຶກທີ່ຢູ່ໃນໄຟລ໌ package.json. ເມື່ອ dependencies ຖືກດາວໂຫຼດຢູ່ໃນໂຟນເດີດຽວກັນ, ດໍາເນີນການຄໍາສັ່ງຕໍ່ໄປນີ້:

npm start

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

▍ ການກະກຽມຄໍາຮ້ອງສະຫມັກ React ສໍາລັບການຜະລິດ

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

ເພື່ອສ້າງແອັບພລິເຄຊັນ React, ອີກເທື່ອຫນຶ່ງໂດຍໃຊ້ terminal, ໄປຫາໂຟນເດີ sa-frontend ແລະດໍາເນີນການຄໍາສັ່ງຕໍ່ໄປນີ້:

npm run build

ນີ້ຈະສ້າງໄດເລກະທໍລີໃນໂຟນເດີໂຄງການ build. ມັນຈະມີໄຟລ໌ຄົງທີ່ທັງໝົດທີ່ຈໍາເປັນເພື່ອໃຫ້ແອັບພລິເຄຊັນ React ເຮັດວຽກໄດ້.

▍ໃຫ້ບໍລິການໄຟລ໌ຄົງທີ່ໂດຍໃຊ້ Nginx

ທໍາອິດທ່ານຈໍາເປັນຕ້ອງຕິດຕັ້ງແລະດໍາເນີນການເຄື່ອງແມ່ຂ່າຍເວັບໄຊຕ໌ Nginx. ມັນເປັນ ທ່ານສາມາດດາວນ໌ໂຫລດມັນແລະຊອກຫາຄໍາແນະນໍາກ່ຽວກັບວິທີການຕິດຕັ້ງແລະດໍາເນີນການມັນ. ຫຼັງຈາກນັ້ນ, ທ່ານຈໍາເປັນຕ້ອງໄດ້ຄັດລອກເນື້ອໃນຂອງໂຟນເດີ sa-frontend/build ໄປຫາໂຟນເດີ [your_nginx_installation_dir]/html.

ດ້ວຍວິທີການນີ້, ໄຟລ໌ທີ່ສ້າງຂຶ້ນໃນລະຫວ່າງຂະບວນການກໍ່ສ້າງຂອງຄໍາຮ້ອງສະຫມັກ React index.html ຈະມີຢູ່ [your_nginx_installation_dir]/html/index.html. ນີ້ແມ່ນໄຟລ໌ທີ່, ໂດຍຄ່າເລີ່ມຕົ້ນ, ເຄື່ອງແມ່ຂ່າຍ Nginx ຜະລິດເມື່ອເຂົ້າເຖິງມັນ. ເຊີບເວີຖືກຕັ້ງຄ່າໃຫ້ຟັງຢູ່ໃນພອດ 80, ແຕ່ມັນສາມາດຖືກປັບແຕ່ງຕາມທີ່ທ່ານຕ້ອງການໂດຍການດັດແກ້ໄຟລ໌ [your_nginx_installation_dir]/conf/nginx.conf.

ໃນປັດຈຸບັນເປີດຕົວທ່ອງເວັບຂອງທ່ານແລະໄປທີ່ localhost:80. ທ່ານຈະເຫັນຫນ້າຄໍາຮ້ອງສະຫມັກ React.

ຄໍາຮ້ອງສະຫມັກ React ໃຫ້ບໍລິການໂດຍເຄື່ອງແມ່ຂ່າຍ Nginx

ຖ້າຕອນນີ້ເຈົ້າໃສ່ບາງສິ່ງບາງຢ່າງເຂົ້າໄປໃນພາກສະຫນາມ Type your sentence ແລະກົດປຸ່ມ Send - ບໍ່ມີຫຍັງຈະເກີດຂຶ້ນ. ແຕ່, ຖ້າທ່ານເບິ່ງ console, ທ່ານສາມາດເບິ່ງຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດຢູ່ທີ່ນັ້ນ. ເພື່ອເຂົ້າໃຈບ່ອນທີ່ຄວາມຜິດພາດເຫຼົ່ານີ້ເກີດຂຶ້ນແທ້ໆ, ໃຫ້ພວກເຮົາວິເຄາະລະຫັດຄໍາຮ້ອງສະຫມັກ.

▍ ການວິເຄາະລະຫັດຄໍາຮ້ອງສະຫມັກດ້ານຫນ້າ

ລອງເບິ່ງລະຫັດໄຟລ໌ App.js, ພວກເຮົາສາມາດເຫັນໄດ້ວ່າການກົດປຸ່ມ Send ໂທຫາວິທີການ analyzeSentence(). ລະຫັດສໍາລັບວິທີການນີ້ແມ່ນໃຫ້ຂ້າງລຸ່ມນີ້. ກະລຸນາສັງເກດວ່າສໍາລັບແຕ່ລະເສັ້ນທີ່ມີຄໍາເຫັນຂອງແບບຟອມ # Номер, ມີຄໍາອະທິບາຍໃຫ້ຂ້າງລຸ່ມນີ້ລະຫັດ. ພວກເຮົາຈະວິເຄາະຊິ້ນສ່ວນລະຫັດອື່ນໆໃນແບບດຽວກັນ.

analyzeSentence() {
    fetch('http://localhost:8080/sentiment', {  // #1
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
                       sentence: this.textField.getValue()})// #2
    })
        .then(response => response.json())
        .then(data => this.setState(data));  // #3
}

1. URL ທີ່ຮ້ອງຂໍ POST ແມ່ນເຮັດ. ມັນສົມມຸດວ່າມີຄໍາຮ້ອງສະຫມັກທີ່ຢູ່ນີ້ທີ່ຄາດວ່າຈະມີຄໍາຮ້ອງຂໍດັ່ງກ່າວ.

2.ຮ່າງ​ການ​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​ໄດ້​ຖືກ​ສົ່ງ​ໄປ​ຫາ​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​. ນີ້ແມ່ນຕົວຢ່າງການຮ້ອງຂໍຂອງຮ່າງກາຍ:

{
    sentence: "I like yogobella!"
}

3.ເມື່ອໄດ້ຮັບການຕອບສະຫນອງຕໍ່ການຮ້ອງຂໍ, ສະຖານະຂອງອົງປະກອບຈະຖືກປັບປຸງ. ນີ້ເຮັດໃຫ້ອົງປະກອບຖືກສະແດງຄືນໃຫມ່. ຖ້າພວກເຮົາໄດ້ຮັບຂໍ້ມູນ (ນັ້ນຄື, ວັດຖຸ JSON ທີ່ມີຂໍ້ມູນການປ້ອນຂໍ້ມູນແລະຄະແນນຂໍ້ຄວາມທີ່ຄິດໄລ່), ພວກເຮົາຈະອອກອົງປະກອບ Polarity, ເນື່ອງຈາກວ່າເງື່ອນໄຂທີ່ເຫມາະສົມຈະໄດ້ຮັບການຕອບສະຫນອງ. ນີ້ແມ່ນວິທີທີ່ພວກເຮົາອະທິບາຍອົງປະກອບ:

const polarityComponent = this.state.polarity !== undefined ?
    <Polarity sentence={this.state.sentence} 
              polarity={this.state.polarity}/> :
    null;

ລະຫັດປະກົດວ່າເຮັດວຽກໄດ້ດີ. ອັນນີ້ແມ່ນຫຍັງຜິດ? ຖ້າທ່ານສົມມຸດວ່າທີ່ຢູ່ທີ່ແອັບພລິເຄຊັນພະຍາຍາມສົ່ງຄໍາຮ້ອງຂໍ POST, ບໍ່ມີຫຍັງທີ່ສາມາດຍອມຮັບແລະດໍາເນີນການຄໍາຮ້ອງຂໍນີ້, ຫຼັງຈາກນັ້ນທ່ານຈະຖືກຕ້ອງຢ່າງແທ້ຈິງ. ຄື, ເພື່ອດໍາເນີນການຮ້ອງຂໍທີ່ໄດ້ຮັບຢູ່ http://localhost:8080/sentiment, ພວກເຮົາຈໍາເປັນຕ້ອງດໍາເນີນການຄໍາຮ້ອງສະຫມັກເວັບໄຊຕ໌ໂດຍອີງໃສ່ Spring.

ພວກເຮົາຕ້ອງການຄໍາຮ້ອງສະຫມັກພາກຮຽນ spring ທີ່ສາມາດຍອມຮັບຄໍາຮ້ອງຂໍ POST

▍ ຕັ້ງຄ່າແອັບພລິເຄຊັນເວັບ Spring

ເພື່ອນຳໃຊ້ແອັບພລິເຄຊັນພາກຮຽນ spring, ທ່ານຈະຕ້ອງການ JDK8 ແລະ Maven ແລະຕົວແປສະພາບແວດລ້ອມທີ່ຖືກຕັ້ງຄ່າຢ່າງຖືກຕ້ອງ. ເມື່ອເຈົ້າຕິດຕັ້ງທັງໝົດນີ້ແລ້ວ, ເຈົ້າສາມາດສືບຕໍ່ເຮັດວຽກໃນໂຄງການຂອງພວກເຮົາໄດ້.

▍ ການຫຸ້ມຫໍ່ແອັບພລິເຄຊັນເຂົ້າໄປໃນໄຟລ໌ກະປ໋ອງ

ທ່ອງໄປຫາ, ໂດຍໃຊ້ terminal, ໄປຫາໂຟນເດີ sa-webapp ແລະໃສ່ຄໍາສັ່ງຕໍ່ໄປນີ້:

mvn install

ຫຼັງຈາກແລ່ນຄໍາສັ່ງນີ້ຢູ່ໃນໂຟນເດີ sa-webapp ໄດເລກະທໍລີຈະຖືກສ້າງ target. ນີ້ແມ່ນບ່ອນທີ່ຄໍາຮ້ອງສະຫມັກ Java ຈະຕັ້ງຢູ່, ບັນຈຸຢູ່ໃນໄຟລ໌ກະປ໋ອງ, ເປັນຕົວແທນໂດຍໄຟລ໌ sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍ ແລ່ນແອັບພລິເຄຊັນ Java

ໄປທີ່ໂຟນເດີ target ແລະແລ່ນແອັບພລິເຄຊັນດ້ວຍຄໍາສັ່ງຕໍ່ໄປນີ້:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar

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

Error creating bean with name 'sentimentController': Injection of autowired dependencies failed; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'sa.logic.api.url' in value "${sa.logic.api.url}"

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

▍ ການວິເຄາະລະຫັດແອັບພລິເຄຊັນ Java

ນີ້ແມ່ນ snippet ລະຫັດທີ່ຄວາມຜິດພາດເກີດຂຶ້ນ.

@CrossOrigin(origins = "*")
@RestController
public class SentimentController {
    @Value("${sa.logic.api.url}")    // #1
    private String saLogicApiUrl;
    @PostMapping("/sentiment")
    public SentimentDto sentimentAnalysis(
        @RequestBody SentenceDto sentenceDto) 
    {
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate.postForEntity(
                saLogicApiUrl + "/analyse/sentiment",    // #2
                sentenceDto, SentimentDto.class)
                .getBody();
    }
}

1. ໃນ SentimentController ມີພາກສະຫນາມ saLogicApiUrl. ຄ່າຂອງມັນຖືກລະບຸໂດຍຊັບສິນ sa.logic.api.url.
2. ສາຍ saLogicApiUrl concatenates ກັບມູນຄ່າ /analyse/sentiment. ພວກເຂົາຮ່ວມກັນສ້າງທີ່ຢູ່ສໍາລັບການໂທຫາ microservice ທີ່ປະຕິບັດການວິເຄາະຂໍ້ຄວາມ.

▍ກໍານົດມູນຄ່າຊັບສິນ

ໃນພາກຮຽນ spring, ແຫຼ່ງມາດຕະຖານຂອງມູນຄ່າຊັບສິນແມ່ນໄຟລ໌ application.properties, ຊຶ່ງສາມາດພົບໄດ້ທີ່ sa-webapp/src/main/resources. ແຕ່ການນໍາໃຊ້ຂອງມັນບໍ່ແມ່ນວິທີດຽວທີ່ຈະກໍານົດມູນຄ່າຊັບສິນ. ນີ້ຍັງສາມາດເຮັດໄດ້ໂດຍໃຊ້ຄໍາສັ່ງຕໍ່ໄປນີ້:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URL

ມູນຄ່າຂອງຊັບສິນນີ້ຄວນຊີ້ໄປຫາທີ່ຢູ່ຂອງແອັບພລິເຄຊັນ Python ຂອງພວກເຮົາ.

ໂດຍການຕັ້ງຄ່າມັນ, ພວກເຮົາບອກຄໍາຮ້ອງສະຫມັກເວັບ Spring ບ່ອນທີ່ມັນຈໍາເປັນຕ້ອງໄປປະຕິບັດຄໍາຮ້ອງຂໍການວິເຄາະຂໍ້ຄວາມ.

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

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000

ລະບົບຂອງພວກເຮົາຂາດແອັບພລິເຄຊັນ Python

ໃນປັດຈຸບັນທັງຫມົດທີ່ພວກເຮົາຕ້ອງເຮັດແມ່ນດໍາເນີນການຄໍາຮ້ອງສະຫມັກ Python ແລະລະບົບຈະເຮັດວຽກຕາມທີ່ຄາດໄວ້.

▍ ຕັ້ງຄ່າແອັບພລິເຄຊັນ Python

ເພື່ອແລ່ນແອັບພລິເຄຊັນ Python, ທ່ານຕ້ອງມີ Python 3 ແລະ Pip ຕິດຕັ້ງ, ແລະຕົວແປສະພາບແວດລ້ອມທີ່ເຫມາະສົມຕ້ອງຖືກຕັ້ງຄ່າຢ່າງຖືກຕ້ອງ.

▍ ການຕິດຕັ້ງການເພິ່ງພາອາໄສ

ໄປທີ່ໂຟນເດີໂຄງການຂອງທ່ານ sa-logic/sa ແລະດໍາເນີນການຄໍາສັ່ງຕໍ່ໄປນີ້:

python -m pip install -r requirements.txt
python -m textblob.download_corpora

▍ ເປີດໃຊ້ແອັບພລິເຄຊັນ

ຫຼັງຈາກການຕິດຕັ້ງ dependencies, ພວກເຮົາພ້ອມທີ່ຈະດໍາເນີນການຄໍາຮ້ອງສະຫມັກ:

python sentiment_analysis.py

ຫຼັງຈາກແລ່ນຄໍາສັ່ງນີ້, ພວກເຮົາຈະຖືກບອກຕໍ່ໄປນີ້:

* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

ນີ້ຫມາຍຄວາມວ່າຄໍາຮ້ອງສະຫມັກແມ່ນແລ່ນແລະລໍຖ້າການຮ້ອງຂໍຢູ່ທີ່ localhost:5000/

▍ ການຄົ້ນຄວ້າລະຫັດ

ລອງເບິ່ງລະຫັດແອັບພລິເຄຊັນ Python ເພື່ອເຂົ້າໃຈວ່າມັນຕອບສະໜອງຕໍ່ການຮ້ອງຂໍແນວໃດ:

from textblob import TextBlob
from flask import Flask, request, jsonify
app = Flask(__name__)                                   #1
@app.route("/analyse/sentiment", methods=['POST'])      #2
def analyse_sentiment():
    sentence = request.get_json()['sentence']           #3
    polarity = TextBlob(sentence).sentences[0].polarity #4
    return jsonify(                                     #5
        sentence=sentence,
        polarity=polarity
    )
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)                #6

1. ການເລີ່ມຕົ້ນວັດຖຸ Flask.
2. ການລະບຸທີ່ຢູ່ສໍາລັບການປະຕິບັດຄໍາຮ້ອງຂໍ POST ກັບມັນ.
3. ດຶງເອົາຊັບສິນ sentence ຈາກ​ອົງ​ການ​ຮ້ອງ​ຂໍ​.
4. ການເລີ່ມຕົ້ນວັດຖຸທີ່ບໍ່ເປີດເຜີຍຊື່ TextBlob ແລະໄດ້ຮັບມູນຄ່າ polarity ສໍາລັບປະໂຫຍກທໍາອິດທີ່ໄດ້ຮັບຢູ່ໃນຮ່າງກາຍຂອງຄໍາຮ້ອງຂໍ (ໃນກໍລະນີຂອງພວກເຮົາ, ນີ້ແມ່ນປະໂຫຍກດຽວທີ່ຖືກສົ່ງໄປສໍາລັບການວິເຄາະ).
5. ກັບຄືນຄໍາຕອບທີ່ຮ່າງກາຍປະກອບດ້ວຍຂໍ້ຄວາມຂອງປະໂຫຍກແລະຕົວຊີ້ວັດການຄິດໄລ່ສໍາລັບມັນ polarity.
6. ເປີດຕົວແອັບພລິເຄຊັນ Flask, ເຊິ່ງຈະມີຢູ່ 0.0.0.0:5000 (ທ່ານຍັງສາມາດເຂົ້າເຖິງມັນໄດ້ໂດຍໃຊ້ການກໍ່ສ້າງແບບຟອມ localhost:5000).

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

ການບໍລິການຈຸນລະພາກທັງໝົດທີ່ປະກອບເປັນແອັບພລິເຄຊັນຖືກນຳໄປສູ່ການເຮັດວຽກ

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

ໃນພາກຕໍ່ໄປ, ພວກເຮົາຈະສົນທະນາກ່ຽວກັບວິທີການດໍາເນີນການ microservices ຂອງພວກເຮົາໃນ Docker containers. ນີ້ແມ່ນສິ່ງຈໍາເປັນເພື່ອກະກຽມຄໍາຮ້ອງສະຫມັກທີ່ຈະດໍາເນີນການຢູ່ໃນກຸ່ມ Kubernetes.

Docker containers

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

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

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

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

▍ ການໃຫ້ບໍລິການໄຟລ໌ຄົງທີ່ຂອງແອັບພລິເຄຊັນ React ໂດຍໃຊ້ເຄື່ອງສະເໝືອນ

ພະຍາຍາມຈັດການບໍລິການຂອງໄຟລ໌ຄົງທີ່ໂດຍໃຊ້ virtual machines, ພວກເຮົາຈະພົບຂໍ້ເສຍດັ່ງຕໍ່ໄປນີ້:

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

ເຊີບເວີເວັບ Nginx ໃຫ້ບໍລິການໄຟລ໌ຄົງທີ່ທີ່ແລ່ນຢູ່ໃນເຄື່ອງສະເໝືອນ

ຖ້າເຄື່ອງບັນຈຸຖືກໃຊ້ເພື່ອແກ້ໄຂບັນຫາທີ່ຄ້າຍຄືກັນ, ຫຼັງຈາກນັ້ນ, ໃນການປຽບທຽບກັບເຄື່ອງ virtual, ຄວາມເຂັ້ມແຂງຕໍ່ໄປນີ້ສາມາດສັງເກດເຫັນ:

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

ເຊີບເວີເວັບ Nginx ໃຫ້ບໍລິການໄຟລ໌ຄົງທີ່ທີ່ແລ່ນຢູ່ໃນຖັງ

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

▍ ການສ້າງຮູບພາບບັນຈຸສໍາລັບຄໍາຮ້ອງສະຫມັກ React

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

ກ່ອນທີ່ພວກເຮົາຈະເລີ່ມຕົ້ນເຮັດວຽກກັບໄຟລ໌ Dockerfile, ໃຫ້ຈື່ສິ່ງທີ່ພວກເຮົາໄດ້ເຮັດເພື່ອກະກຽມໄຟລ໌ຄໍາຮ້ອງສະຫມັກ React ສໍາລັບການອັບໂຫລດໄປຍັງເຄື່ອງແມ່ຂ່າຍຂອງ Nginx:

1. ການສ້າງຊຸດຄໍາຮ້ອງສະຫມັກ React (npm run build).
2. ກຳລັງເລີ່ມເຊີບເວີ Nginx.
3. ຄັດລອກເນື້ອຫາໄດເລກະທໍລີ build ຈາກໂຟນເດີໂຄງການ sa-frontend ໄປທີ່ໂຟນເດີເຊີບເວີ nginx/html.

ຂ້າງລຸ່ມນີ້ທ່ານສາມາດເບິ່ງຂະຫນານລະຫວ່າງການສ້າງ container ແລະຂັ້ນຕອນຂ້າງເທິງນີ້ປະຕິບັດໃນຄອມພິວເຕີທ້ອງຖິ່ນຂອງທ່ານ.

▍ ກຳລັງກະກຽມ Dockerfile ສຳລັບແອັບພລິເຄຊັນ SA-Frontend

ຄໍາແນະນໍາທີ່ຈະບັນຈຸຢູ່ໃນ Dockerfile ສຳ ລັບການສະ ໝັກ SA-Frontend, ປະກອບດ້ວຍພຽງແຕ່ສອງທີມ. ຄວາມຈິງແລ້ວແມ່ນວ່າທີມງານພັດທະນາ Nginx ໄດ້ກະກຽມພື້ນຖານ ຮູບພາບ ສໍາລັບ Nginx, ທີ່ພວກເຮົາຈະໃຊ້ເພື່ອສ້າງຮູບພາບຂອງພວກເຮົາ. ນີ້ແມ່ນສອງຂັ້ນຕອນທີ່ພວກເຮົາຕ້ອງການອະທິບາຍ:

1. ພື້ນຖານຂອງຮູບພາບຄວນຈະເປັນຮູບພາບ Nginx.
2. ເນື້ອໃນໂຟນເດີ sa-frontend/build ຈໍາ​ເປັນ​ຕ້ອງ​ໄດ້​ຮັບ​ການ​ຄັດ​ລອກ​ໄປ​ໃນ​ໂຟນ​ເດີ​ຮູບ​ພາບ​ nginx/html.

ຖ້າທ່ານໄປຈາກຄໍາອະທິບາຍນີ້ໄປຫາໄຟລ໌ Dockerfile, ຫຼັງຈາກນັ້ນມັນຈະເບິ່ງຄືວ່ານີ້:

FROM nginx
COPY build /usr/share/nginx/html

ດັ່ງທີ່ເຈົ້າສາມາດເຫັນໄດ້, ທຸກສິ່ງທຸກຢ່າງຢູ່ທີ່ນີ້ແມ່ນງ່າຍດາຍຫຼາຍ, ແລະເນື້ອໃນຂອງໄຟລ໌ເຖິງແມ່ນວ່າສາມາດອ່ານໄດ້ແລະເຂົ້າໃຈໄດ້. ໄຟລ໌ນີ້ບອກລະບົບທີ່ຈະເອົາຮູບພາບ nginx ກັບທຸກສິ່ງທຸກຢ່າງທີ່ມີຢູ່ໃນມັນ, ແລະຄັດລອກເນື້ອຫາຂອງໄດເລກະທໍລີ build ໄປຫາໄດເລກະທໍລີ nginx/html.

ໃນທີ່ນີ້ທ່ານອາດຈະມີຄໍາຖາມກ່ຽວກັບວິທີທີ່ຂ້ອຍຮູ້ວ່າບ່ອນໃດແທ້ທີ່ເຈົ້າຕ້ອງການຄັດລອກໄຟລ໌ຈາກໂຟນເດີ build, ນັ້ນແມ່ນ, ບ່ອນທີ່ເສັ້ນທາງມາຈາກ /usr/share/nginx/html. ໃນຄວາມເປັນຈິງ, ບໍ່ມີຫຍັງສັບສົນຢູ່ທີ່ນີ້. ຄວາມຈິງແມ່ນວ່າຂໍ້ມູນທີ່ກ່ຽວຂ້ອງສາມາດພົບເຫັນຢູ່ໃນ ລາຍລະອຽດ ຮູບພາບ.

▍ ການສ້າງຮູບພາບແລະອັບໂຫລດມັນໃສ່ບ່ອນເກັບມ້ຽນ

ກ່ອນທີ່ພວກເຮົາສາມາດເຮັດວຽກກັບຮູບພາບສໍາເລັດຮູບ, ພວກເຮົາຈໍາເປັນຕ້ອງໄດ້ຊຸກດັນໃຫ້ມັນກັບ repository ຮູບພາບ. ເພື່ອເຮັດສິ່ງນີ້, ພວກເຮົາຈະໃຊ້ເວທີການໂຮດຮູບພາບເມຄຟຣີ Docker Hub. ໃນຂັ້ນຕອນຂອງການເຮັດວຽກນີ້, ທ່ານຈໍາເປັນຕ້ອງເຮັດດັ່ງຕໍ່ໄປນີ້:

1. ຕິດຕັ້ງ Docker.
2. ລົງທະບຽນຢູ່ໃນເວັບໄຊທ໌ Docker Hub.
3. ເຂົ້າສູ່ລະບົບບັນຊີຂອງທ່ານໂດຍການແລ່ນຄໍາສັ່ງຕໍ່ໄປນີ້ຢູ່ໃນ terminal:

   docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"

ໃນປັດຈຸບັນທ່ານຈໍາເປັນຕ້ອງໃຊ້ terminal ເພື່ອໄປທີ່ໄດເລກະທໍລີ sa-frontend ແລະດໍາເນີນການຄໍາສັ່ງຕໍ່ໄປນີ້ຢູ່ທີ່ນັ້ນ:

docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend .

ທີ່ນີ້ແລະຕໍ່ໄປໃນຄໍາສັ່ງທີ່ຄ້າຍຄືກັນ $DOCKER_USER_ID ຄວນຖືກແທນທີ່ດ້ວຍຊື່ຜູ້ໃຊ້ Docker Hub ຂອງທ່ານ. ຕົວຢ່າງ, ສ່ວນຫນຶ່ງຂອງຄໍາສັ່ງນີ້ອາດຈະເບິ່ງຄືວ່ານີ້: rinormaloku/sentiment-analysis-frontend.

ໃນກໍລະນີນີ້, ຄໍາສັ່ງນີ້ສາມາດສັ້ນໂດຍການຖອນອອກຈາກມັນ -f Dockerfile, ເນື່ອງຈາກໄຟລ໌ນີ້ມີຢູ່ໃນໂຟນເດີທີ່ພວກເຮົາກໍາລັງປະຕິບັດຄໍາສັ່ງນີ້.

ເພື່ອສົ່ງຮູບພາບສໍາເລັດຮູບໄປຫາບ່ອນເກັບມ້ຽນ, ພວກເຮົາຕ້ອງການຄໍາສັ່ງຕໍ່ໄປນີ້:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

ຫຼັງຈາກເຮັດສຳເລັດແລ້ວ, ໃຫ້ກວດເບິ່ງລາຍຊື່ຂອງບ່ອນເກັບມ້ຽນຂອງທ່ານໃນ Docker Hub ເພື່ອເຂົ້າໃຈວ່າການອັບໂຫລດຮູບພາບໄປໃສ່ບ່ອນເກັບຂໍ້ມູນຄລາວສຳເລັດຫຼືບໍ່.

▍ແລ່ນຕູ້ຄອນເທນເນີ

ໃນປັດຈຸບັນທຸກຄົນສາມາດດາວນ໌ໂຫລດແລະດໍາເນີນການຮູບພາບ, ເອີ້ນວ່າ $DOCKER_USER_ID/sentiment-analysis-frontend. ເພື່ອເຮັດສິ່ງນີ້, ທ່ານຈໍາເປັນຕ້ອງດໍາເນີນການຄໍາສັ່ງດັ່ງຕໍ່ໄປນີ້:

docker pull $DOCKER_USER_ID/sentiment-analysis-frontend
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

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

• ເລກ ທຳ ອິດ 80 — ນີ້​ແມ່ນ​ເລກ​ພອດ​ແມ່​ຂ່າຍ (ນັ້ນ​ແມ່ນ​, ຄອມ​ພິວ​ເຕີ​ທ້ອງ​ຖິ່ນ​)​.
• ຕົວເລກທີສອງ 80 ແມ່ນທ່າເຮືອຂອງຖັງທີ່ຄໍາຮ້ອງຂໍຄວນໄດ້ຮັບການສົ່ງຕໍ່.

ພິຈາລະນາຕົວຢ່າງຕໍ່ໄປນີ້.

ການສົ່ງຕໍ່ພອດ

ລະບົບປ່ຽນເສັ້ນທາງການຮ້ອງຂໍຈາກພອດ <hostPort> ໄປທີ່ທ່າເຮືອ <containerPort>. ນັ້ນແມ່ນ, ການເຂົ້າເຖິງທ່າເຮືອ 80 ຄອມພິວເຕີຖືກໂອນໄປຫາພອດ 80 ບັນຈຸ.

ຕັ້ງແຕ່ທ່າເຮືອ 80 ເປີດຢູ່ໃນຄອມພິວເຕີທ້ອງຖິ່ນ, ຫຼັງຈາກນັ້ນທ່ານສາມາດເຂົ້າເຖິງຄໍາຮ້ອງສະຫມັກຈາກຄອມພິວເຕີນີ້ຢູ່ທີ່ localhost:80. ຖ້າລະບົບຂອງທ່ານບໍ່ສະຫນັບສະຫນູນ Docker, ແອັບພລິເຄຊັນສາມາດດໍາເນີນການຢູ່ໃນເຄື່ອງ virtual Docker, ທີ່ຢູ່ຂອງມັນຈະເບິ່ງຄືວ່າ. <docker-machine ip>:80. ເພື່ອຊອກຫາທີ່ຢູ່ IP ຂອງເຄື່ອງ virtual Docker, ທ່ານສາມາດນໍາໃຊ້ຄໍາສັ່ງ docker-machine ip.

ໃນຈຸດນີ້, ຫຼັງຈາກສົບຜົນສໍາເລັດການເປີດຕົວກ່ອງບັນຈຸຄໍາຮ້ອງສະຫມັກດ້ານຫນ້າ, ທ່ານຄວນຈະສາມາດເປີດຫນ້າຂອງມັນຢູ່ໃນຕົວທ່ອງເວັບ.

▍ໄຟລ໌ .dockerignore

ການ​ເກັບ​ກໍາ​ຮູບ​ພາບ​ຂອງ​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​ SA-Frontend, ພວກເຮົາສາມາດສັງເກດເຫັນວ່າຂະບວນການນີ້ກາຍເປັນຊ້າທີ່ສຸດ. ອັນນີ້ເກີດຂຶ້ນເພາະວ່າ ບໍລິບົດການສ້າງຮູບພາບຕ້ອງຖືກສົ່ງໄປຫາ Docker daemon. ໄດເລກະທໍລີທີ່ເປັນຕົວແທນຂອງການສ້າງບໍລິບົດແມ່ນຖືກກໍານົດເປັນອາກິວເມັນສຸດທ້າຍຂອງຄໍາສັ່ງ docker build. ໃນກໍລະນີຂອງພວກເຮົາ, ມີຈຸດຢູ່ໃນຕອນທ້າຍຂອງຄໍາສັ່ງນີ້. ນີ້ເຮັດໃຫ້ໂຄງສ້າງຕໍ່ໄປນີ້ຖືກລວມເຂົ້າໃນສະພາບການກໍ່ສ້າງ:

sa-frontend:
|   .dockerignore
|   Dockerfile
|   package.json
|   README.md
+---build
+---node_modules
+---public
---src

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

node_modules
src
public

ເອກະສານ .dockerignore ຕ້ອງຢູ່ໃນໂຟນເດີດຽວກັນກັບໄຟລ໌ Dockerfile. ໃນປັດຈຸບັນການສ້າງຮູບພາບຈະໃຊ້ເວລາບໍ່ເທົ່າໃດວິນາທີ.

ຕອນນີ້ໃຫ້ພວກເຮົາເຮັດວຽກກ່ຽວກັບຮູບພາບສໍາລັບຄໍາຮ້ອງສະຫມັກ Java.

▍ ການສ້າງຮູບພາບບັນຈຸສໍາລັບຄໍາຮ້ອງສະຫມັກ Java

ເຈົ້າຮູ້ຫຍັງ, ທ່ານໄດ້ຮຽນຮູ້ທຸກຢ່າງທີ່ເຈົ້າຕ້ອງການຮູ້ເພື່ອສ້າງຮູບພາບບັນຈຸ. ນັ້ນແມ່ນເຫດຜົນທີ່ວ່າພາກນີ້ຈະສັ້ນຫຼາຍ.

ເປີດໄຟລ໌ Dockerfileເຊິ່ງຢູ່ໃນໂຟນເດີໂຄງການ sa-webapp. ຖ້າທ່ານອ່ານຂໍ້ຄວາມຂອງໄຟລ໌ນີ້, ທ່ານຈະເຫັນພຽງແຕ່ສອງການກໍ່ສ້າງໃຫມ່ໃນມັນ, ເລີ່ມຕົ້ນດ້ວຍຄໍາສໍາຄັນ ENV и EXPOSE:

ENV SA_LOGIC_API_URL http://localhost:5000
…
EXPOSE 8080

ຄໍາສໍາຄັນ ENV ອະນຸຍາດໃຫ້ທ່ານປະກາດຕົວແປສະພາບແວດລ້ອມພາຍໃນ Docker containers. ໂດຍສະເພາະ, ໃນກໍລະນີຂອງພວກເຮົາ, ມັນອະນຸຍາດໃຫ້ທ່ານລະບຸ URL ເພື່ອເຂົ້າເຖິງ API ຂອງແອັບພລິເຄຊັນທີ່ປະຕິບັດການວິເຄາະຂໍ້ຄວາມ.

ຄໍາສໍາຄັນ EXPOSE ອະນຸຍາດໃຫ້ທ່ານບອກ Docker ໃຫ້ເປີດພອດ. ພວກເຮົາຈະໃຊ້ພອດນີ້ໃນຂະນະທີ່ແລ່ນແອັບພລິເຄຊັນ. ທີ່ນີ້ທ່ານສາມາດສັງເກດເຫັນວ່າໃນ Dockerfile ສຳ ລັບການສະ ໝັກ SA-Frontend ບໍ່ມີຄໍາສັ່ງດັ່ງກ່າວ. ນີ້ແມ່ນພຽງແຕ່ສໍາລັບຈຸດປະສົງເອກະສານ, ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ການກໍ່ສ້າງນີ້ແມ່ນມີຈຸດປະສົງສໍາລັບຜູ້ທີ່ຈະອ່ານ Dockerfile.

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

▍ ການສ້າງຮູບພາບບັນຈຸສໍາລັບແອັບພລິເຄຊັນ Python

ຖ້າທ່ານເບິ່ງເນື້ອໃນຂອງເອກະສານ Dockerfile ໃນໂຟນເດີ sa-logic, ຫຼັງຈາກນັ້ນທ່ານຈະບໍ່ພົບສິ່ງໃຫມ່ສໍາລັບຕົວທ່ານເອງຢູ່ທີ່ນັ້ນ. ຄໍາສັ່ງສໍາລັບການກໍ່ສ້າງຮູບພາບແລະສົ່ງມັນໄປ repository ຄວນຈະຄຸ້ນເຄີຍກັບທ່ານແລ້ວ, ແຕ່, ເຊັ່ນດຽວກັນກັບຄໍາຮ້ອງສະຫມັກອື່ນໆຂອງພວກເຮົາ, ພວກເຂົາເຈົ້າສາມາດພົບເຫັນຢູ່ໃນໄຟລ໌. README.md ໃນໂຟນເດີ sa-logic.

▍ ການທົດສອບຄໍາຮ້ອງສະຫມັກບັນຈຸ

ເຈົ້າເຊື່ອບາງສິ່ງທີ່ເຈົ້າບໍ່ໄດ້ທົດສອບໄດ້ບໍ? ຂ້ອຍບໍ່ສາມາດຄືກັນ. ມາທົດສອບຖັງຂອງພວກເຮົາ.

1. ໃຫ້ເປີດຕົວບັນຈຸແອັບພລິເຄຊັນ sa-logic ແລະຕັ້ງຄ່າມັນເພື່ອຟັງຢູ່ໃນພອດ 5050:

   docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic

2. ໃຫ້ເປີດຕົວບັນຈຸແອັບພລິເຄຊັນ sa-webapp ແລະຕັ້ງຄ່າມັນເພື່ອຟັງຢູ່ໃນພອດ 8080. ນອກຈາກນັ້ນ, ພວກເຮົາຈໍາເປັນຕ້ອງໄດ້ກໍາຫນົດຄ່າພອດທີ່ແອັບພລິເຄຊັນ Python ຈະຟັງການຮ້ອງຂໍຈາກແອັບພລິເຄຊັນ Java ໂດຍການມອບຫມາຍຕົວແປສະພາບແວດລ້ອມຄືນໃຫມ່. SA_LOGIC_API_URL:

   $ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://<container_ip or docker machine ip>:5000' $DOCKER_USER_ID/sentiment-analysis-web-app

ເພື່ອຮຽນຮູ້ວິທີການຊອກຫາທີ່ຢູ່ IP ຂອງ Docker container ຫຼື virtual machine, ເບິ່ງໄຟລ໌ README.

ໃຫ້ເປີດຕົວບັນຈຸແອັບພລິເຄຊັນ sa-frontend:

docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

ໃນປັດຈຸບັນທຸກສິ່ງທຸກຢ່າງແມ່ນກຽມພ້ອມທີ່ຈະໄປຫາທີ່ຢູ່ໃນຕົວທ່ອງເວັບ localhost:80 ແລະພະຍາຍາມຄໍາຮ້ອງສະຫມັກ.

ກະລຸນາສັງເກດວ່າຖ້າທ່ານປ່ຽນພອດສໍາລັບ sa-webapp, ຫຼືຖ້າທ່ານໃຊ້ Docker virtual machine, ທ່ານຈະຕ້ອງແກ້ໄຂໄຟລ໌ App.js ຈາກໂຟນເດີ sa-frontendໂດຍການປ່ຽນທີ່ຢູ່ IP ຫຼືໝາຍເລກພອດໃນວິທີການ analyzeSentence(), ການທົດແທນຂໍ້ມູນໃນປະຈຸບັນແທນທີ່ຈະເປັນຂໍ້ມູນລ້າສະໄຫມ. ຫຼັງຈາກນີ້, ທ່ານຈໍາເປັນຕ້ອງປະກອບຮູບພາບແລະນໍາໃຊ້ມັນ.

ນີ້ແມ່ນສິ່ງທີ່ແຜນວາດຄໍາຮ້ອງສະຫມັກຂອງພວກເຮົາເບິ່ງຄືວ່າໃນປັດຈຸບັນ.

ການບໍລິການຈຸນລະພາກດໍາເນີນການຢູ່ໃນບັນຈຸ

ສະຫຼຸບ: ເປັນຫຍັງພວກເຮົາຕ້ອງການກຸ່ມ Kubernetes?

ພວກເຮົາພຽງແຕ່ໄດ້ກວດກາໄຟລ໌ Dockerfile, ໄດ້ເວົ້າກ່ຽວກັບວິທີການສ້າງຮູບພາບແລະຊຸກດັນໃຫ້ພວກເຂົາໄປຫາບ່ອນເກັບ Docker. ນອກຈາກນັ້ນ, ພວກເຮົາໄດ້ຮຽນຮູ້ວິທີການເລັ່ງການປະກອບຮູບພາບໂດຍໃຊ້ໄຟລ໌ .dockerignore. ດັ່ງນັ້ນ, ການບໍລິການຈຸນລະພາກຂອງພວກເຮົາໃນປັດຈຸບັນດໍາເນີນການຢູ່ໃນ Docker containers. ໃນທີ່ນີ້ທ່ານອາດຈະມີຄໍາຖາມທີ່ສົມເຫດສົມຜົນຢ່າງສົມບູນກ່ຽວກັບວ່າເປັນຫຍັງພວກເຮົາຕ້ອງການ Kubernetes. ສ່ວນທີສອງຂອງເອກະສານນີ້ຈະຖືກອຸທິດໃຫ້ກັບການຕອບຄໍາຖາມນີ້. ໃນເວລານີ້, ພິຈາລະນາຄໍາຖາມຕໍ່ໄປນີ້:
ໃຫ້ສົມມຸດວ່າຄໍາຮ້ອງສະຫມັກເວັບໄຊຕ໌ຂອງພວກເຮົາສໍາລັບການວິເຄາະຂໍ້ຄວາມໄດ້ກາຍເປັນທີ່ນິຍົມທົ່ວໂລກ. ຫຼາຍລ້ານຄຳຮ້ອງຂໍມາຫາລາວທຸກນາທີ. ນີ້ຫມາຍຄວາມວ່າ microservices sa-webapp и sa-logic ຈະຢູ່ພາຍໃຕ້ການໂຫຼດອັນໃຫຍ່ຫຼວງ. ວິທີການຂະຫນາດຕູ້ຄອນເທນເນີທີ່ໃຊ້ microservices?

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