នៅក្នុងអត្ថបទនេះ ខ្ញុំនឹងចែករំលែកបទពិសោធន៍របស់ខ្ញុំក្នុងការដំឡើង CI/CD ដោយប្រើ Plesk Control Panel និង Github Actions។ ថ្ងៃនេះយើងនឹងរៀនពីរបៀបដាក់ពង្រាយគម្រោងសាមញ្ញមួយដែលមានឈ្មោះមិនស្មុគស្មាញ "Helloworld" ។ វាត្រូវបានសរសេរនៅក្នុងក្របខណ្ឌ Flask Python ជាមួយនឹងបុគ្គលិក Celery និង Angular 8 frontend ។

តំណភ្ជាប់ទៅកាន់ឃ្លាំង៖ ផ្នែកខាងក្រោយ, ផ្នែកខាងមុខ.

នៅក្នុងផ្នែកដំបូងនៃអត្ថបទ យើងនឹងពិនិត្យមើលគម្រោងរបស់យើង និងផ្នែករបស់វា។ នៅក្នុងទីពីរ យើងនឹងស្វែងយល់ពីរបៀបដំឡើង Plesk និងដំឡើងផ្នែកបន្ថែម និងសមាសធាតុចាំបាច់ (DB, RabbitMQ, Redis, Docker ជាដើម)។

នៅក្នុងផ្នែកទីបី ទីបំផុតយើងនឹងស្វែងយល់ពីរបៀបរៀបចំបំពង់សម្រាប់ដាក់ពង្រាយគម្រោងរបស់យើងទៅកាន់ម៉ាស៊ីនមេនៅក្នុងបរិស្ថាន dev និងផលិតផល។ ហើយបន្ទាប់មកយើងនឹងបើកដំណើរការគេហទំព័រនៅលើម៉ាស៊ីនមេ។

បាទ ខ្ញុំភ្លេចណែនាំខ្លួន។ ឈ្មោះរបស់ខ្ញុំគឺ Oleg Borzov ខ្ញុំជាអ្នកបង្កើត fullstack នៅក្នុងក្រុម CRM សម្រាប់អ្នកគ្រប់គ្រងប្រាក់កម្ចីនៅ Domclick ។

ទិដ្ឋភាពទូទៅនៃគម្រោង

ជាដំបូង សូមក្រឡេកមើលឃ្លាំងគម្រោងចំនួនពីរ - ផ្នែកខាងក្រោយ និងផ្នែកខាងមុខ - ហើយឆ្លងកាត់កូដ។

ផ្នែកខាងក្រោយ៖ Flask + Celery

សម្រាប់ផ្នែកខាងក្រោយ ខ្ញុំបានយកបណ្តុំដែលពេញនិយមក្នុងចំណោមអ្នកអភិវឌ្ឍន៍ Python៖ ក្របខ័ណ្ឌ Flask (សម្រាប់ API) និង Celery (សម្រាប់ជួរកិច្ចការ) ។ SQLAchemy ត្រូវបានប្រើជា ORM ។ Alembic ត្រូវបានប្រើសម្រាប់ការធ្វើចំណាកស្រុក។ សម្រាប់សុពលភាព JSON នៅក្នុងចំណុចទាញ - Marshmallow ។

В ឃ្លាំង មានឯកសារ Readme.md ជាមួយនឹងការពិពណ៌នាលម្អិតនៃរចនាសម្ព័ន្ធ និងការណែនាំសម្រាប់ដំណើរការគម្រោង។

Web Part API សាមញ្ញណាស់, មាន 6 ប៊ិច:

• /ping - ដើម្បីពិនិត្យមើលភាពអាចរកបាន;
• ដោះស្រាយសម្រាប់ការចុះឈ្មោះ ការអនុញ្ញាត ការដកសិទ្ធិ និងការទទួលបានអ្នកប្រើប្រាស់ដែលមានការអនុញ្ញាត។
• ចំណុចទាញអ៊ីមែលដែលដាក់ភារកិច្ចនៅក្នុងជួរ Celery ។

ផ្នែក Celery កាន់តែងាយស្រួល មានបញ្ហាតែមួយគត់ send_mail_task.

នៅក្នុងថតឯកសារ / conf មានថតរងពីរ៖

• docker ជាមួយ Dockerfiles ពីរ (base.dockerfile បង្កើតរូបភាពមូលដ្ឋានកម្រនិងផ្លាស់ប្តូរ Dockerfile សម្រាប់សន្និបាតសំខាន់ៗ);
• .env_files - ជាមួយឯកសារដែលមានអថេរបរិស្ថានសម្រាប់បរិស្ថានផ្សេងៗគ្នា។

មានឯកសារ docker-compose ចំនួនបួននៅឫសនៃគម្រោង៖

• docker-compose.local.db.yml ដើម្បីបង្កើនមូលដ្ឋានទិន្នន័យសម្រាប់ការអភិវឌ្ឍន៍;
• docker-compose.local.workers.yml សម្រាប់ការចិញ្ចឹមក្នុងស្រុករបស់កម្មករ មូលដ្ឋានទិន្នន័យ Redis និង RabbitMQ;
• docker-compose.test.yml ដើម្បីដំណើរការការធ្វើតេស្តកំឡុងពេលដាក់ពង្រាយ;
• docker-compose.yml សម្រាប់ការដាក់ពង្រាយ។

ហើយថតចុងក្រោយដែលយើងចាប់អារម្មណ៍ - .ci-cd. វាមានស្គ្រីបសែលសម្រាប់ការដាក់ពង្រាយ៖

• deploy.sh - ការចាប់ផ្តើមនៃការធ្វើចំណាកស្រុក និងការដាក់ពង្រាយ។ ដំណើរការលើម៉ាស៊ីនមេបន្ទាប់ពីការសាកល្បងសាងសង់ និងដំណើរការនៅក្នុង Github Actions;
• rollback.sh - ត្រឡប់ធុងទៅកំណែមុននៃការជួបប្រជុំគ្នា;
• curl_tg.sh - ផ្ញើការជូនដំណឹងអំពីការដាក់ពង្រាយទៅកាន់ Telegram ។

ផ្នែកខាងមុខនៅលើ Angular

ឃ្លាំងជាមួយផ្នែកខាងមុខ សាមញ្ញជាង Beck ។ ផ្នែកខាងមុខមានបីទំព័រ៖

• ទំព័រមេដែលមានទម្រង់សម្រាប់ផ្ញើអ៊ីមែល និងប៊ូតុងចេញ។
• ទំព័រចូល។
• ទំព័រចុះឈ្មោះ។

ទំព័រ​សំខាន់​មើល​ទៅ​មាន​ភាព​អស្ចារ្យ៖

មានឯកសារពីរនៅឫស Dockerfile и docker-compose.ymlក៏ដូចជាថតដែលធ្លាប់ស្គាល់ .ci-cd ជាមួយនឹងស្គ្រីបតិចជាងបន្តិចនៅក្នុងឃ្លាំងខាងក្រោយ (ស្គ្រីបដែលបានដកចេញសម្រាប់ការសាកល្បងដែលកំពុងដំណើរការ)។

ចាប់ផ្តើមគម្រោងនៅ Plesk

ចូរចាប់ផ្តើមដោយការដំឡើង Plesk និងបង្កើតការជាវសម្រាប់គេហទំព័ររបស់យើង។

ការដំឡើងផ្នែកបន្ថែម

នៅក្នុង Plesk យើងត្រូវការផ្នែកបន្ថែមចំនួនបួន៖

• Docker ដើម្បីគ្រប់គ្រង និងបង្ហាញស្ថានភាពនៃធុងនៅក្នុងផ្ទាំងគ្រប់គ្រង Plesk ដោយមើលឃើញ។
• Git ដើម្បីកំណត់រចនាសម្ព័ន្ធជំហានដាក់ពង្រាយនៅលើម៉ាស៊ីនមេ;
• Let's Encrypt ដើម្បីបង្កើត (និងបន្តដោយស្វ័យប្រវត្តិ) វិញ្ញាបនបត្រ TLS ឥតគិតថ្លៃ។
• Firewall ដើម្បីកំណត់រចនាសម្ព័ន្ធការត្រងនៃចរាចរចូល។

អ្នកអាចដំឡើងពួកវាតាមរយៈបន្ទះគ្រប់គ្រង Plesk នៅក្នុងផ្នែកបន្ថែម៖

យើងនឹងមិនពិចារណាការកំណត់លម្អិតសម្រាប់ផ្នែកបន្ថែមទេ ការកំណត់លំនាំដើមនឹងធ្វើសម្រាប់គោលបំណងសាកល្បងរបស់យើង។

បង្កើតការជាវ និងគេហទំព័រ

បន្ទាប់មកយើងត្រូវបង្កើតការជាវសម្រាប់គេហទំព័រ helloworld.ru របស់យើង ហើយបន្ថែមដែនរង dev.helloworld.ru នៅទីនោះ។

1. បង្កើតការជាវសម្រាប់ដែន helloworld.ru ហើយបញ្ជាក់ពាក្យសម្ងាត់ចូលសម្រាប់អ្នកប្រើប្រាស់ប្រព័ន្ធ៖

   
   ធីកប្រអប់នៅខាងក្រោមទំព័រ ការពារដែនជាមួយ Let's Encryptប្រសិនបើយើងចង់ដំឡើង HTTPS សម្រាប់គេហទំព័រ៖

   

2. បន្ទាប់មក នៅក្នុងការជាវនេះ បង្កើត subdomain dev.helloworld.ru (ដែលអ្នកក៏អាចចេញវិញ្ញាបនបត្រ TLS ដោយឥតគិតថ្លៃផងដែរ)៖

   

ការដំឡើងសមាសភាគម៉ាស៊ីនមេ

យើងមានម៉ាស៊ីនមេជាមួយ ប្រព័ន្ធប្រតិបត្តិការ Debian Stretch 9.12 និងបានដំឡើងផ្ទាំងបញ្ជា Plesk Obsidian 18.0.27.

យើងត្រូវដំឡើង និងកំណត់រចនាសម្ព័ន្ធសម្រាប់គម្រោងរបស់យើង៖

• PostgreSQL (ក្នុងករណីរបស់យើង នឹងមានម៉ាស៊ីនមេមួយដែលមានមូលដ្ឋានទិន្នន័យពីរសម្រាប់បរិស្ថានអភិវឌ្ឍន៍ និងផលិតផល)។
• RabbitMQ (ដូចគ្នា, ដូចគ្នាជាមួយ vhosts ផ្សេងគ្នាសម្រាប់បរិស្ថាន) ។
• ករណី Redis ពីរ (សម្រាប់បរិស្ថាន dev និងផលិតផល) ។
• Docker Registry (សម្រាប់ការផ្ទុកក្នុងមូលដ្ឋាននៃរូបភាព Docker ដែលបានសាងសង់)។
• UI សម្រាប់ការចុះបញ្ជី Docker ។

PostgreSQL

Plesk បានភ្ជាប់មកជាមួយ PostgreSQL DBMS រួចហើយ ប៉ុន្តែមិនមែនជាកំណែចុងក្រោយបង្អស់ទេ (នៅពេលសរសេរ Plesk Obsidian គាំទ្រ Postgres កំណែ 8.4–10.8) ។ យើងចង់បានកំណែចុងក្រោយបំផុតសម្រាប់កម្មវិធីរបស់យើង (12.3 នៅពេលសរសេរនេះ) ដូច្នេះយើងនឹងដំឡើងវាដោយដៃ។

មានការណែនាំលម្អិតជាច្រើនសម្រាប់ការដំឡើង Postgres នៅលើ Debian នៅលើបណ្តាញ (ឧទាហរណ៍) ដូច្នេះ​ខ្ញុំ​នឹង​មិន​រៀបរាប់​ឱ្យ​បាន​លម្អិត​ទេ ខ្ញុំ​គ្រាន់​តែ​ផ្តល់​ពាក្យ​បញ្ជា​ប៉ុណ្ណោះ៖

wget -q https://www.postgresql.org/media/keys/ACCC4CF8.asc -O - | sudo apt-key add -
sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt/ stretch-pgdg main" >> /etc/apt/sources.list.d/pgdg.list'

sudo apt-get update
sudo apt-get install postgresql postgresql-contrib

ដោយហេតុថា PostgreSQL មានការកំណត់លំនាំដើមជាមធ្យម វាជាការចាំបាច់ក្នុងការកែតម្រូវការកំណត់។ នេះនឹងជួយយើង ម៉ាស៊ីនគិតលេខ៖ អ្នកត្រូវបើកបរក្នុងប៉ារ៉ាម៉ែត្រនៃម៉ាស៊ីនមេរបស់អ្នក ហើយជំនួសការកំណត់នៅក្នុងឯកសារ /etc/postgresql/12/main/postgresql.confដល់អ្នកដែលបានផ្តល់ជូន។ វាគួរតែត្រូវបានកត់សម្គាល់នៅទីនេះថាម៉ាស៊ីនគិតលេខបែបនេះមិនមែនជាគ្រាប់វេទមន្តទេ ហើយមូលដ្ឋានគួរតែត្រូវបានកែតម្រូវឱ្យកាន់តែច្បាស់លាស់ ដោយផ្អែកលើផ្នែករឹង កម្មវិធី និងភាពស្មុគស្មាញនៃសំណួររបស់អ្នក។ ប៉ុន្តែនេះគឺគ្រប់គ្រាន់ដើម្បីចាប់ផ្តើម។

បន្ថែមពីលើការកំណត់ដែលបានស្នើឡើងដោយម៉ាស៊ីនគិតលេខ យើងក៏ផ្លាស់ប្តូរផងដែរ។ postgresql.confច្រកលំនាំដើម 5432 ទៅមួយទៀត (ក្នុងឧទាហរណ៍របស់យើង - 53983).

បន្ទាប់ពីផ្លាស់ប្តូរឯកសារកំណត់រចនាសម្ព័ន្ធ ចាប់ផ្តើមម៉ាស៊ីនមេ postgresql ឡើងវិញដោយប្រើពាក្យបញ្ជា៖

service postgresql restart

យើងបានដំឡើង និងកំណត់រចនាសម្ព័ន្ធ PostgreSQL ។ ឥឡូវនេះ ចូរយើងបង្កើតមូលដ្ឋានទិន្នន័យ អ្នកប្រើប្រាស់សម្រាប់ dev- និង prod-environments ហើយផ្តល់ឱ្យអ្នកប្រើប្រាស់នូវសិទ្ធិក្នុងការគ្រប់គ្រងមូលដ្ឋានទិន្នន័យ៖

$ su - postgres
postgres:~$ create database hw_dev_db_name;
CREATE DATABASE
postgres:~$ create user hw_dev_db_user with password 'hw_dev_db_password';
CREATE ROLE
postgres:~$ grant ALL privileges ON database hw_dev_db_name to hw_dev_db_user;
GRANT
postgres:~$ create database hw_prod_db_name;
CREATE DATABASE
postgres:~$ create user hw_prod_db_user with password 'hw_prod_db_password';
CREATE ROLE
postgres:~$ grant ALL privileges ON database hw_prod_db_name to hw_prod_db_user;
GRANT

RabbitMQ

ចូរបន្តទៅការដំឡើង RabbitMQ ដែលជាឈ្មួញកណ្តាលសារសម្រាប់ Celery ។ ការដំឡើងវានៅលើ Debian គឺសាមញ្ញណាស់៖

wget https://packages.erlang-solutions.com/erlang-solutions_1.0_all.deb
sudo dpkg -i erlang-solutions_1.0_all.deb

sudo apt-get update
sudo apt-get install erlang erlang-nox

sudo add-apt-repository 'deb http://www.rabbitmq.com/debian/ testing main'
wget -O- https://www.rabbitmq.com/rabbitmq-release-signing-key.asc | sudo apt-key add -

sudo apt-get update
sudo apt-get install rabbitmq-server

បន្ទាប់ពីការដំឡើងយើងត្រូវបង្កើត vhostsអ្នកប្រើប្រាស់ និងផ្តល់សិទ្ធិចាំបាច់៖

sudo rabbitmqctl add_user hw_dev_amqp_user hw_dev_amqp_password 
sudo rabbitmqctl set_user_tags hw_dev_amqp_user administrator
sudo rabbitmqctl add_vhost hw_dev_vhost
sudo rabbitmqctl set_permissions -p hw_dev_vhost hw_dev_amqp_user ".*" ".*" ".*"

sudo rabbitmqctl add_user hw_prod_amqp_user hw_prod_amqp_password 
sudo rabbitmqctl set_user_tags hw_prod_amqp_user administrator
sudo rabbitmqctl add_vhost hw_prod_vhost
sudo rabbitmqctl set_permissions -p hw_prod_vhost hw_prod_amqp_user ".*" ".*" ".*"

Redis

ឥឡូវនេះ ចូរយើងដំឡើង និងកំណត់រចនាសម្ព័ន្ធសមាសភាគចុងក្រោយសម្រាប់កម្មវិធីរបស់យើង - Redis ។ វានឹងត្រូវបានប្រើជាផ្នែកខាងក្រោយសម្រាប់រក្សាទុកលទ្ធផលនៃកិច្ចការ Celery ។

យើងនឹងលើកធុង Docker ពីរជាមួយ Redis សម្រាប់បរិស្ថាន dev និង prod ដោយប្រើផ្នែកបន្ថែម Docker សម្រាប់ Plesk ។

1. យើងទៅ Plesk ទៅកាន់ផ្នែកបន្ថែម រកមើលផ្នែកបន្ថែម Docker ហើយដំឡើងវា (យើងត្រូវការកំណែឥតគិតថ្លៃ):

   

2. ចូលទៅកាន់ផ្នែកបន្ថែមដែលបានដំឡើង ស្វែងរករូបភាពតាមរយៈការស្វែងរក redis bitnami ហើយដំឡើងកំណែចុងក្រោយបំផុត៖

   

3. យើងចូលទៅក្នុងកុងតឺន័រដែលបានទាញយក ហើយកែតម្រូវការកំណត់៖ បញ្ជាក់ច្រក ទំហំ RAM អតិបរមាដែលបានបែងចែក ពាក្យសម្ងាត់នៅក្នុងអថេរបរិស្ថាន និងម៉ោនកម្រិតសំឡេង៖

   

4. យើងអនុវត្តជំហានទី 2-3 សម្រាប់កុងតឺន័រ prod នៅក្នុងការកំណត់ យើងគ្រាន់តែផ្លាស់ប្តូរប៉ារ៉ាម៉ែត្រប៉ុណ្ណោះ៖ ច្រក ពាក្យសម្ងាត់ ទំហំ RAM និងផ្លូវទៅកាន់ថតកម្រិតសំឡេងនៅលើម៉ាស៊ីនមេ៖

   

បញ្ជីឈ្មោះ Docker

បន្ថែមពីលើសេវាកម្មមូលដ្ឋាន វាជាការល្អក្នុងការដាក់ឃ្លាំងរូបភាព Docker របស់អ្នកនៅលើម៉ាស៊ីនមេ។ ជាសំណាងល្អ ពេលនេះទំហំម៉ាស៊ីនមេគឺថោកណាស់ (ពិតជាថោកជាងការជាវ DockerHub) ហើយដំណើរការនៃការបង្កើតឃ្លាំងឯកជនគឺសាមញ្ញណាស់។

យើងចង់មាន៖

• ឃ្លាំង Docker ដែលការពារដោយពាក្យសម្ងាត់អាចចូលប្រើបាននៅលើដែនរង https://docker.helloworld.ru;
• UI សម្រាប់មើលរូបភាពនៅក្នុងឃ្លាំង មាននៅ https://docker-ui.helloworld.ru.

ចំពោះបញ្ហានេះ:

1. ចូរបង្កើតដែនរងពីរនៅក្នុង Plesk ក្នុងការជាវរបស់យើង៖ docker.helloworld.ru និង docker-ui.helloworld.ru ហើយកំណត់រចនាសម្ព័ន្ធ Let's Encrypt វិញ្ញាបនបត្រសម្រាប់ពួកគេ។
2. បន្ថែមឯកសារទៅថតដែនរង docker.helloworld.ru docker-compose.yml ជាមួយនឹងខ្លឹមសារដូចនេះ៖

   version: "3"
   
   services:
     docker-registry:
       image: "registry:2"
       restart: always
       ports:
         - "53985:5000"
       environment:
         REGISTRY_AUTH: htpasswd
         REGISTRY_AUTH_HTPASSWD_REALM: basic-realm
         REGISTRY_AUTH_HTPASSWD_PATH: /auth/.htpasswd
         REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY: /data
       volumes:
         - ./.docker-registry.htpasswd:/auth/.htpasswd
         - ./data:/data
   
     docker-registry-ui:
       image: konradkleine/docker-registry-frontend:v2
       restart: always
       ports:
         - "53986:80"
       environment:
         VIRTUAL_HOST: '*, https://*'
         ENV_DOCKER_REGISTRY_HOST: 'docker-registry'
         ENV_DOCKER_REGISTRY_PORT: 5000
       links:
         - 'docker-registry'
   

3. នៅក្រោម SSH យើងនឹងបង្កើតឯកសារ .htpasswd សម្រាប់ការអនុញ្ញាតជាមូលដ្ឋាននៅក្នុងឃ្លាំង Docker៖

   htpasswd -bBc .htpasswd hw_docker_admin hw_docker_password

4. ប្រមូលនិងលើកធុង៖

   docker-compose up -d

5. ហើយយើងត្រូវប្តូរទិស Nginx ទៅកាន់កុងតឺន័ររបស់យើង។ នេះអាចត្រូវបានធ្វើតាមរយៈ Plesk ។

ជំហានខាងក្រោមត្រូវធ្វើសម្រាប់ដែនរង docker.helloworld.ru និង docker-ui.helloworld.ru៖

ផ្នែក ឧបករណ៍ Dev គេហទំព័ររបស់យើងទៅ ច្បាប់ប្រូកស៊ី Docker:

ហើយបន្ថែមច្បាប់ទៅចរាចរចូលប្រូកស៊ីទៅកាន់កុងតឺន័ររបស់យើង៖

1. យើងពិនិត្យមើលថាយើងអាចចូលកុងតឺន័ររបស់យើងពីម៉ាស៊ីនក្នុងស្រុក៖

   $ docker login docker.helloworld.ru -u hw_docker_admin -p hw_docker_password
   WARNING! Using --password via the CLI is insecure. Use --password-stdin.
   Login Succeeded

2. តោះពិនិត្យមើលប្រតិបត្តិការនៃដែនរង docker-ui.helloworld.ru៖

   
   នៅពេលអ្នកចុចលើ Browse repositories នោះ browser នឹងបង្ហាញផ្ទាំងអនុញ្ញាត ដែលអ្នកត្រូវបញ្ចូល username និង password សម្រាប់ repository។ បន្ទាប់ពីនោះ យើងនឹងត្រូវបានបញ្ជូនបន្តទៅទំព័រដែលមានបញ្ជីឃ្លាំង (សម្រាប់ពេលនេះ វានឹងទទេសម្រាប់អ្នក)៖

   

ការបើកច្រកនៅក្នុង Plesk Firewall

បន្ទាប់ពីដំឡើង និងកំណត់រចនាសម្ព័ន្ធសមាសភាគ យើងត្រូវបើកច្រកដើម្បីឱ្យសមាសធាតុអាចចូលប្រើបានពី Docker containers និងបណ្តាញខាងក្រៅ។

តោះមើលពីរបៀបធ្វើវាដោយប្រើផ្នែកបន្ថែម Firewall សម្រាប់ Plesk ដែលយើងដំឡើងមុន។

1. ទៅ ឧបករណ៍ និងការកំណត់> ការកំណត់> ជញ្ជាំងភ្លើង:
   
2. ទៅ កែប្រែច្បាប់ជញ្ជាំងភ្លើង Plesk > បន្ថែមច្បាប់ផ្ទាល់ខ្លួន ហើយបើកច្រក TCP ខាងក្រោមសម្រាប់បណ្តាញរង Docker (172.0.0.0 / 8):
   RabbitMQ: 1883, 4369, 5671-5672, 25672, 61613-61614
   Redis: 32785, 32786

   

3. យើងក៏នឹងបន្ថែមច្បាប់ដែលនឹងបើកច្រក PostgreSQL និងផ្ទាំងគ្រប់គ្រង RabbitMQ ទៅពិភពខាងក្រៅ៖

   

4. អនុវត្តច្បាប់ដោយប្រើប៊ូតុងអនុវត្តការផ្លាស់ប្តូរ៖

   

ការដំឡើង CI/CD នៅក្នុង Github Actions

ចូរយើងចុះទៅផ្នែកដែលគួរឱ្យចាប់អារម្មណ៍បំផុត - បង្កើតបំពង់បង្ហូរបញ្ចូលគ្នាជាបន្តបន្ទាប់ និងបញ្ជូនគម្រោងរបស់យើងទៅម៉ាស៊ីនមេ។

បំពង់នេះនឹងមានពីរផ្នែក៖

• បង្កើតរូបភាព និងដំណើរការសាកល្បង (សម្រាប់ផ្នែកខាងក្រោយ) - នៅផ្នែកខាង Github;
• កំពុងដំណើរការការធ្វើចំណាកស្រុក (សម្រាប់ផ្នែកខាងក្រោយ) និងការដាក់ពង្រាយកុងតឺន័រ - នៅលើម៉ាស៊ីនមេ។

ដាក់ពង្រាយទៅ Plesk

ចូរ​ដោះស្រាយ​ចំណុច​ទី​ពីរ​ជា​មុន​សិន (ព្រោះ​ចំណុច​ទី​មួយ​អាស្រ័យ​លើ​វា)។

យើងនឹងកំណត់រចនាសម្ព័ន្ធដំណើរការដាក់ពង្រាយដោយប្រើផ្នែកបន្ថែម Git សម្រាប់ Plesk ។

ពិចារណាឧទាហរណ៍ជាមួយបរិស្ថាន Prod សម្រាប់ឃ្លាំង Backend ។

1. យើងចូលទៅកាន់ការជាវគេហទំព័រ Helloworld របស់យើង ហើយចូលទៅកាន់ផ្នែករង Git៖

   

2. បញ្ចូលតំណទៅឃ្លាំង Github របស់យើងទៅក្នុងវាល "ឃ្លាំង Git ពីចម្ងាយ" ហើយផ្លាស់ប្តូរថតលំនាំដើម httpdocs ទៅមួយផ្សេងទៀត (ឧ។ /httpdocs/hw_back):

   

3. ចម្លងសោសាធារណៈ SSH ពីជំហានមុន និង បន្ថែម វាមាននៅក្នុងការកំណត់ Github ។
4. យើងចុចយល់ព្រមនៅលើអេក្រង់ក្នុងជំហានទី 2 បន្ទាប់ពីនោះយើងផ្ទេរទៅទំព័រឃ្លាំងនៅ Plesk ។ ឥឡូវនេះយើងត្រូវកំណត់រចនាសម្ព័ន្ធឃ្លាំងដើម្បីធ្វើបច្ចុប្បន្នភាពលើការប្តេជ្ញាចិត្តទៅកាន់សាខាមេ។ ដើម្បីធ្វើដូចនេះសូមចូលទៅកាន់ ការកំណត់ឃ្លាំង និងរក្សាទុកតម្លៃ Webhook URL (យើងនឹងត្រូវការវានៅពេលក្រោយនៅពេលដំឡើង Github Actions)៖

   

5. នៅក្នុងវាលសកម្មភាពនៅលើអេក្រង់ពីកថាខណ្ឌមុន សូមបញ្ចូលស្គ្រីបដើម្បីចាប់ផ្តើមការដាក់ពង្រាយ៖

   cd {REPOSITORY_ABSOLUTE_PATH}
   .ci-cd/deploy.sh {ENV} {DOCKER_REGISTRY_HOST} {DOCKER_USER} {DOCKER_PASSWORD} {TG_BOT_TOKEN} {TG_CHAT_ID} 

   ដែលជាកន្លែង:

   {REPOSITORY_ABSOLUTE_PATH} - ផ្លូវទៅកាន់ថត prod នៃឃ្លាំង backend នៅលើ server;
   {ENV} - បរិស្ថាន (dev / prod) ក្នុងករណីរបស់យើង។ prod;
   {DOCKER_REGISTRY_HOST} - ម៉ាស៊ីននៃឃ្លាំង docker របស់យើង។
   {TG_BOT_TOKEN} - សញ្ញាសម្ងាត់ Telegram bot;
   {TG_CHAT_ID} - លេខសម្គាល់នៃការជជែក / ឆានែលសម្រាប់ការផ្ញើការជូនដំណឹង។

   ឧទាហរណ៍ស្គ្រីប៖

   cd /var/www/vhosts/helloworld.ru/httpdocs/hw_back/
   .ci-cd/deploy.sh dev docker.helloworld.ru docker_user docker_password 12345678:AAbcdEfghCH1vGbCasdfSAs0K5PALDsaw -1001234567890

6. បន្ថែមអ្នកប្រើប្រាស់ពីការជាវរបស់យើងទៅក្រុម Docker (ដូច្នេះពួកគេអាចគ្រប់គ្រងធុង):

   sudo usermod -aG docker helloworld_admin

បរិយាកាស dev សម្រាប់ឃ្លាំង backend និង frontend ត្រូវបានតំឡើងតាមរបៀបដូចគ្នា។

បំពង់ដាក់ពង្រាយនៅក្នុង Github Actions

ចូរបន្តទៅការដំឡើងផ្នែកដំបូងនៃបំពង់ CI/CD របស់យើងនៅក្នុង Github Actions ។

កម្មវិធីខាងក្រោយ។

បំពង់បង្ហូរប្រេងត្រូវបានពិពណ៌នានៅក្នុង ឯកសារ deploy.yml.

ប៉ុន្តែ​មុន​ពេល​ញែក​វា សូម​បំពេញ​អថេរ​សម្ងាត់​ដែល​យើង​ត្រូវ​ការ​ក្នុង Github ។ ដើម្បីធ្វើដូចនេះសូមចូលទៅកាន់ ការកំណត់ -> អាថ៌កំបាំង:

• DOCKER_REGISTRY - ម៉ាស៊ីននៃឃ្លាំង Docker របស់យើង (docker.helloworld.ru);
• DOCKER_LOGIN - ចូលទៅកាន់ឃ្លាំង Docker;
• DOCKER_PASSWORD - ពាក្យសម្ងាត់ទៅវា;
• DEPLOY_HOST - ម៉ាស៊ីនដែលបន្ទះគ្រប់គ្រង Plesk មាន (ឧទាហរណ៍៖ Helloworld.ru: 8443 ឬ 123.4.56.78៖ ៨៤៤៣);
• DEPLOY_BACK_PROD_TOKEN - សញ្ញាសម្ងាត់សម្រាប់ការដាក់ពង្រាយទៅកាន់ prod-repository នៅលើ server (យើងទទួលបានវានៅក្នុង Deployment in Plesk p. 4);
• DEPLOY_BACK_DEV_TOKEN - សញ្ញាសម្ងាត់សម្រាប់ដាក់ពង្រាយទៅកាន់ឃ្លាំង dev នៅលើម៉ាស៊ីនមេ។

ដំណើរការដាក់ពង្រាយគឺសាមញ្ញ និងមានបីជំហានសំខាន់ៗ៖

• ការកសាងនិងបោះពុម្ពរូបភាពនៅក្នុងឃ្លាំងរបស់យើង;
• កំពុងដំណើរការការធ្វើតេស្តនៅក្នុងកុងតឺន័រដោយផ្អែកលើរូបភាពដែលបានសាងសង់ថ្មីៗ។
• ការដាក់ពង្រាយទៅបរិយាកាសដែលចង់បានអាស្រ័យលើសាខា (dev/master) ។

Frontend ។

ឯកសារ deploy.yml សម្រាប់ឃ្លាំងខាងមុខ ខុសគ្នាបន្តិចបន្តួចពី Beck's ។ វាខ្វះជំហានជាមួយនឹងការធ្វើតេស្តដែលកំពុងដំណើរការ និងផ្លាស់ប្តូរឈ្មោះសញ្ញាសម្ងាត់សម្រាប់ការដាក់ឱ្យប្រើប្រាស់។ អាថ៌កំបាំងសម្រាប់ឃ្លាំងខាងមុខដោយវិធីនេះចាំបាច់ត្រូវបំពេញដោយឡែកពីគ្នា។

ការរៀបចំគេហទំព័រ

ចរាចរប្រូកស៊ីតាមរយៈ Nginx

យើង​បាន​មក​ដល់​ទី​បញ្ចប់​ហើយ។ វានៅសល់តែដើម្បីកំណត់រចនាសម្ព័ន្ធប្រូកស៊ីនៃចរាចរចូលនិងចេញទៅកាន់កុងតឺន័ររបស់យើងតាមរយៈ Nginx ។ យើងបានគ្របដណ្តប់ដំណើរការនេះរួចហើយនៅក្នុងជំហានទី 5 នៃការដំឡើង Docker Registry ។ ដូចគ្នានេះដែរគួរតែត្រូវបានធ្វើម្តងទៀតសម្រាប់ផ្នែកខាងក្រោយនិងផ្នែកខាងមុខនៅក្នុងបរិស្ថាន dev និងផលិតផល។

ខ្ញុំនឹងផ្តល់រូបថតអេក្រង់នៃការកំណត់។

កម្មវិធីខាងក្រោយ។

Frontend ។

Важноеуточнение. URL ទាំងអស់នឹងត្រូវបានប្រូកស៊ីទៅកុងតឺន័រផ្នែកខាងមុខ លើកលែងតែអ្នកដែលចាប់ផ្តើមជាមួយ /api/ - ពួកគេនឹងត្រូវបានបញ្ជូនទៅកាន់ធុងខាងក្រោយ (ដូច្នេះ នៅក្នុងធុងខាងក្រោយ អ្នកដោះស្រាយទាំងអស់ត្រូវតែចាប់ផ្តើមជាមួយ /api/).

លទ្ធផល

ឥឡូវនេះគេហទំព័ររបស់យើងគួរតែមាននៅ helloworld.ru និង dev.helloworld.ru (prod- និង dev-environments រៀងគ្នា)។

សរុបមក យើងបានរៀនពីរបៀបរៀបចំកម្មវិធីសាមញ្ញមួយនៅក្នុង Flask និង Angular ហើយរៀបចំបំពង់បង្ហូរប្រេងនៅក្នុង Github Actions ដើម្បីបញ្ជូនវាទៅម៉ាស៊ីនមេដែលកំពុងដំណើរការ Plesk ។

ខ្ញុំ​នឹង​ចម្លង​តំណ​ទៅ​ឃ្លាំង​ដោយ​ប្រើ​កូដ៖ ផ្នែកខាងក្រោយ, ផ្នែកខាងមុខ.

ប្រភព: www.habr.com