ប្រព័ន្ធ ស្គ្រីបអន្តរកម្ម និងកម្មវិធីកំណត់ម៉ោង

សេចក្តីណែនាំ

នៅពេលអភិវឌ្ឍសម្រាប់លីនុច ភារកិច្ចនៃការបង្កើតស្គ្រីបអន្តរកម្មដែលត្រូវបានប្រតិបត្តិនៅពេលដែលប្រព័ន្ធត្រូវបានបើក ឬបិទកើតឡើង។ នៅក្នុងប្រព័ន្ធ V វាងាយស្រួល ប៉ុន្តែជាមួយនឹង systemd វាធ្វើការកែតម្រូវ។ ប៉ុន្តែវាអាចមានកម្មវិធីកំណត់ម៉ោងរបស់វា។

ហេតុអ្វីបានជាយើងត្រូវការគោលដៅ?

វាត្រូវបានសរសេរជាញឹកញាប់ថាគោលដៅបម្រើជា analogue នៃកម្រិតរត់នៅក្នុងប្រព័ន្ធ V -init ។ ខ្ញុំមិនយល់ស្របជាមូលដ្ឋានទេ។ មានពួកវាច្រើនជាងនេះ ហើយអ្នកអាចបែងចែកកញ្ចប់ជាក្រុម ហើយឧទាហរណ៍ បើកដំណើរការក្រុមសេវាកម្មដោយប្រើពាក្យបញ្ជាតែមួយ ហើយធ្វើសកម្មភាពបន្ថែម។ ជាងនេះទៅទៀត ពួកគេមិនមានឋានានុក្រមទេ មានតែភាពអាស្រ័យប៉ុណ្ណោះ។

ឧទាហរណ៍នៃគោលដៅនៅពេលបើកដំណើរការ (ទិដ្ឋភាពទូទៅនៃលក្ខណៈ) ជាមួយនឹងដំណើរការស្គ្រីបអន្តរកម្ម

ការពិពណ៌នាអំពីគោលដៅខ្លួនឯង៖

cat installer.target
[Unit]
Description=My installer
Requires=multi-user.target 
Conflicts=rescue.service rescue.target
After=multi-user.target rescue.service rescue.target 
AllowIsolate=yes
Wants=installer.service

គោលដៅនេះនឹងចាប់ផ្តើមនៅពេលដែល multi-user.target ត្រូវបានចាប់ផ្តើម ហើយហៅទៅ installer.service។ ទោះយ៉ាងណាក៏ដោយ អាចមានសេវាកម្មបែបនេះជាច្រើន។

cat installer.service
[Unit]
# описание
Description=installer interactive dialog

[Service]
# Запустить один раз, когда остальное будет запущенно
Type=idle
# Команда запуска - вызов скрипта
ExecStart=/usr/bin/installer.sh
# Интерактивное взаимодействие с пользователем через tty3
StandardInput=tty
TTYPath=/dev/tty3
TTYReset=yes
TTYVHangup=yes

[Install]
WantedBy=installer.target

ហើយចុងក្រោយ ឧទាហរណ៍នៃស្គ្រីបដែលកំពុងដំណើរការ៖

#!/bin/bash
# Переходим в tty3
chvt 3
echo "Install, y/n ?"
read user_answer

អ្វីដែលសំខាន់បំផុតគឺជ្រើសរើស final.target - គោលដៅដែលប្រព័ន្ធគួរតែមកដល់នៅពេលចាប់ផ្តើម។ កំឡុងពេលចាប់ផ្តើមដំណើរការ systemd នឹងឆ្លងកាត់ភាពអាស្រ័យ និងចាប់ផ្តើមអ្វីគ្រប់យ៉ាងដែលវាត្រូវការ។
មានវិធីផ្សេងគ្នាដើម្បីជ្រើសរើស final.target ខ្ញុំបានប្រើជម្រើសកម្មវិធីទាញយកសម្រាប់វា។

ការបាញ់បង្ហោះចុងក្រោយមើលទៅដូចនេះ៖

1. កម្មវិធីចាប់ផ្ដើមប្រព័ន្ធចាប់ផ្តើម
2. កម្មវិធីចាប់ផ្ដើមប្រព័ន្ធចាប់ផ្តើមដំណើរការកម្មវិធីបង្កប់ដោយឆ្លងកាត់ប៉ារ៉ាម៉ែត្រ final.target
3. Systemd ចាប់ផ្តើមដំណើរការប្រព័ន្ធ។ បន្តទៅ installer.target ឬ work.target ពី basic.target តាមរយៈភាពអាស្រ័យរបស់ពួកគេ (ឧទាហរណ៍ multi-user.target)។ ក្រោយមកទៀតនាំប្រព័ន្ធឱ្យដំណើរការក្នុងរបៀបដែលចង់បាន

កំពុងរៀបចំកម្មវិធីបង្កប់សម្រាប់ការបើកដំណើរការ

នៅពេលបង្កើតកម្មវិធីបង្កប់ ភារកិច្ចតែងតែកើតឡើងនៃការស្ដារស្ថានភាពប្រព័ន្ធនៅពេលចាប់ផ្តើម ហើយរក្សាទុកវានៅពេលបិទ។ រដ្ឋមានន័យថាឯកសារកំណត់រចនាសម្ព័ន្ធ ការបោះចោលមូលដ្ឋានទិន្នន័យ ការកំណត់ចំណុចប្រទាក់។ល។

Systemd ដំណើរការដំណើរការក្នុងគោលដៅតែមួយស្របគ្នា។ មានភាពអាស្រ័យដែលអនុញ្ញាតឱ្យអ្នកកំណត់លំដាប់ចាប់ផ្តើមនៃស្គ្រីប។

តើវាដំណើរការយ៉ាងដូចម្តេចនៅក្នុងគម្រោងរបស់ខ្ញុំ ( https://habr.com/ru/post/477008/ https://github.com/skif-web/monitor)

1. ប្រព័ន្ធចាប់ផ្តើម
2. សេវាកម្ម settings_restore.service ត្រូវបានបើកដំណើរការ។ វាពិនិត្យរកមើលវត្តមាននៃឯកសារ settings.txt នៅក្នុងផ្នែកទិន្នន័យ។ ប្រសិនបើវាមិននៅទីនោះទេ ឯកសារយោងត្រូវបានដាក់នៅកន្លែងរបស់វា។ បន្ទាប់មក ការកំណត់ប្រព័ន្ធត្រូវបានស្ដារឡើងវិញ៖
   • ពាក្យសម្ងាត់អ្នកគ្រប់គ្រង
   • ឈ្មោះម៉ាស៊ីន,
   • ល្វែងម៉ោង
   • មូលដ្ឋាន
   • កំណត់ថាតើប្រព័ន្ធផ្សព្វផ្សាយទាំងអស់កំពុងត្រូវបានប្រើប្រាស់ដែរឬទេ។ តាមលំនាំដើម ទំហំរូបភាពគឺតូច - សម្រាប់ភាពងាយស្រួលនៃការចម្លង និងថតទៅកាន់ប្រព័ន្ធផ្សព្វផ្សាយ។ នៅពេលចាប់ផ្តើម វាពិនិត្យមើលថាតើវានៅមានកន្លែងទំនេរឬអត់។ ប្រសិនបើមាន ថាសត្រូវបានបែងចែកឡើងវិញ។
   • ការបង្កើតលេខសម្គាល់ម៉ាស៊ីនពីអាសយដ្ឋាន MAC ។ នេះមានសារៈសំខាន់សម្រាប់ការទទួលបានអាសយដ្ឋានដូចគ្នាតាមរយៈ DHCP
   • ការកំណត់​ប​ណ្តា​ញ
   • កំណត់ទំហំនៃកំណត់ហេតុ
   • ដ្រាយខាងក្រៅកំពុងត្រូវបានរៀបចំសម្រាប់ការងារ (ប្រសិនបើជម្រើសដែលត្រូវគ្នាត្រូវបានបើក ហើយដ្រាយគឺថ្មី)
3. ចាប់ផ្តើម postgresq
4. សេវាកម្មស្តារឡើងវិញចាប់ផ្តើម។ វាចាំបាច់ដើម្បីរៀបចំ zabbix ខ្លួនវា និងមូលដ្ឋានទិន្នន័យរបស់វា៖
   • ពិនិត្យមើលថាតើមានមូលដ្ឋានទិន្នន័យ zabbix រួចហើយឬនៅ។ ប្រសិនបើមិនមែនទេ វាត្រូវបានបង្កើតពីការបោះចោលការចាប់ផ្ដើម (រួមបញ្ចូលជាមួយ zabbix)
   • បញ្ជីនៃតំបន់ពេលវេលាត្រូវបានបង្កើត (ចាំបាច់ត្រូវបង្ហាញពួកវានៅក្នុងចំណុចប្រទាក់គេហទំព័រ)
   • IP បច្ចុប្បន្នត្រូវបានរកឃើញ វាត្រូវបានបង្ហាញនៅក្នុងបញ្ហា (ការអញ្ជើញឱ្យចូលកុងសូល)
5. ការអញ្ជើញផ្លាស់ប្តូរ - ឃ្លាត្រៀមខ្លួនរួចរាល់ដើម្បីធ្វើការលេចឡើង
6. កម្មវិធីបង្កប់គឺរួចរាល់សម្រាប់ការប្រើប្រាស់

ឯកសារសេវាកម្មមានសារៈសំខាន់ ពួកគេជាអ្នកកំណត់លំដាប់នៃការបើកដំណើរការរបស់ពួកគេ។

[Unit]
Description=restore system settings
Before=network.service prepare.service postgresql.service systemd-networkd.service systemd-resolved.service

[Service]
Type=oneshot
ExecStart=/usr/bin/settings_restore.sh

[Install]
WantedBy=multi-user.target

ដូចដែលអ្នកអាចមើលឃើញ ខ្ញុំបានដំឡើងភាពអាស្រ័យ ដូច្នេះស្គ្រីបរបស់ខ្ញុំនឹងដំណើរការដំបូង ហើយមានតែបន្ទាប់មកបណ្តាញនឹងឡើង ហើយ DBMS នឹងចាប់ផ្តើម។

និងសេវាកម្មទីពីរ (ការរៀបចំ zabbix)

#!/bin/sh
[Unit]
Description=monitor prepare system
After=postgresql.service settings_restore.service
Before=zabbix-server.service zabbix-agent.service

[Service]
Type=oneshot
ExecStart=/usr/bin/prepare.sh

[Install]
WantedBy=multi-user.target

វាមានភាពស្មុគស្មាញបន្តិចនៅទីនេះ។ ការបើកដំណើរការក៏មាននៅក្នុង multi-user.target ប៉ុន្តែបន្ទាប់ពីចាប់ផ្តើម postgresql DBMS និងការកំណត់របស់ខ្ញុំឡើងវិញ។ ប៉ុន្តែមុនពេលចាប់ផ្តើមសេវាកម្ម zabbix ។

សេវាកំណត់ពេលសម្រាប់ logrotate

Systemd អាចជំនួស CRON ។ ធ្ងន់ធ្ងរ។ ជាងនេះទៅទៀត ភាពត្រឹមត្រូវ​មិន​ដល់​មួយ​នាទី​ទេ ប៉ុន្តែ​រហូត​ដល់​វិនាទី (តើ​វា​ត្រូវ​ការ​យ៉ាង​ណា) ឬ​អ្នក​អាច​បង្កើត​កម្មវិធី​កំណត់​ម៉ោង​ឯកត្តជន ដែល​ហៅ​តាម​រយៈ​ពេល​វេលា​ពី​ព្រឹត្តិការណ៍​មួយ។
វាគឺជាកម្មវិធីកំណត់ពេលវេលាឯកត្តជនដែលរាប់ពេលវេលាពីការចាប់ផ្តើមនៃម៉ាស៊ីនដែលខ្ញុំបានបង្កើត។
វានឹងត្រូវការឯកសារ 2
logrotateTimer.service - ការពិពណ៌នាពិតប្រាកដនៃសេវាកម្ម៖

[Unit]
Description=run logrotate

[Service]
ExecStart=logrotate /etc/logrotate.conf
TimeoutSec=300

វាសាមញ្ញ - ការពិពណ៌នាអំពីពាក្យបញ្ជាចាប់ផ្តើម។
ឯកសារទីពីរ logrotateTimer.timer គឺជាកន្លែងដែលកម្មវិធីកំណត់ម៉ោងដំណើរការ៖

[Unit]
Description=Run logrotate

[Timer]
OnBootSec=15min
OnUnitActiveSec=15min

[Install]
WantedBy=timers.target

តើមានអ្វីនៅទីនេះ៖

• ការពិពណ៌នាអំពីកម្មវិធីកំណត់ពេលវេលា
• ពេលចាប់ផ្តើមដំបូង ចាប់ផ្តើមពីការចាប់ផ្តើមប្រព័ន្ធ
• រយៈពេលនៃការបើកដំណើរការបន្ថែមទៀត
• ការពឹងផ្អែកលើសេវាកម្មវិធីកំណត់ម៉ោង។ តាមពិតនេះគឺជាខ្សែអក្សរដែលបង្កើតកម្មវិធីកំណត់ម៉ោង

ស្គ្រីបអន្តរកម្មនៅពេលបិទ និងគោលដៅបិទរបស់អ្នក។

នៅក្នុងការអភិវឌ្ឍន៍មួយផ្សេងទៀត ខ្ញុំត្រូវធ្វើកំណែស្មុគស្មាញបន្ថែមទៀតនៃការបិទម៉ាស៊ីន - តាមរយៈគោលដៅផ្ទាល់ខ្លួនរបស់ខ្ញុំ ដើម្បីអនុវត្តសកម្មភាពជាច្រើន។ ជាធម្មតាវាត្រូវបានណែនាំឱ្យបង្កើតសេវាកម្ម oneshot ជាមួយជម្រើស RemainAfterExit ប៉ុន្តែវារារាំងអ្នកពីការបង្កើតស្គ្រីបអន្តរកម្ម។

ប៉ុន្តែការពិតគឺថាពាក្យបញ្ជាដែលបើកដោយជម្រើស ExecOnStop ត្រូវបានប្រតិបត្តិនៅខាងក្រៅ TTY! វាងាយស្រួលក្នុងការត្រួតពិនិត្យ - បិទភ្ជាប់ពាក្យបញ្ជា tty ហើយរក្សាទុកលទ្ធផលរបស់វា។

ដូច្នេះហើយ ខ្ញុំបានអនុវត្តការបិទតាមគោលដៅរបស់ខ្ញុំ។ ខ្ញុំមិនអះអាងថាត្រឹមត្រូវ 100% ទេ ប៉ុន្តែវាដំណើរការ!
របៀបដែលវាត្រូវបានធ្វើ (ក្នុងន័យទូទៅ):
ខ្ញុំបានបង្កើតគោលដៅ my_shutdown.target ដែលមិនអាស្រ័យលើនរណាម្នាក់៖
my_shutdown.target

[Unit]
Description=my shutdown
AllowIsolate=yes
Wants=my_shutdown.service 

នៅពេលទៅដល់គោលដៅនេះ (តាមរយៈ systemctl isolate my_shutdwn.target) វាបានបើកដំណើរការសេវាកម្ម my_shutdown.service ដែលភារកិច្ចគឺសាមញ្ញ - ដើម្បីប្រតិបត្តិស្គ្រីប my_shutdown.sh៖

[Unit]
Description=MY shutdown

[Service]
Type=oneshot
ExecStart=/usr/bin/my_shutdown.sh
StandardInput=tty
TTYPath=/dev/tty3
TTYReset=yes
TTYVHangup=yes

WantedBy=my_shutdown.target

• នៅខាងក្នុងស្គ្រីបនេះខ្ញុំអនុវត្តសកម្មភាពចាំបាច់។ អ្នកអាចបន្ថែមស្គ្រីបជាច្រើនទៅកាន់គោលដៅសម្រាប់ភាពបត់បែន និងភាពងាយស្រួល៖

my_shutdown.sh

#!/bin/bash --login
if [ -f /tmp/reboot ];then
    command="systemctl reboot"
elif [ -f /tmp/shutdown ]; then
    command="systemctl poweroff"
fi
#Вот здесь нужные команды
#Например, cp /home/user/data.txt /storage/user/
    $command

ចំណាំ។ ដោយប្រើឯកសារ /tmp/reboot និង /tmp/shutdown ។ អ្នកមិនអាចហៅគោលដៅជាមួយប៉ារ៉ាម៉ែត្របានទេ។ មានតែសេវាកម្មប៉ុណ្ណោះដែលអាចធ្វើបាន។

ប៉ុន្តែខ្ញុំប្រើគោលដៅដើម្បីឱ្យមានភាពបត់បែនក្នុងការងារ និងលំដាប់នៃសកម្មភាពដែលមានការធានា។

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

• ជំនួសការបិទបើកឡើងវិញ ការបិទ និងពាក្យបញ្ជាផ្សេងទៀត (ពួកវានៅតែជាតំណភ្ជាប់ទៅ systemctl) ជាមួយនឹងស្គ្រីបរបស់អ្នក។ នៅខាងក្នុងស្គ្រីប សូមចូលទៅកាន់ my_shutdown.target។ ហើយស្គ្រីបខាងក្នុងគោលដៅ បន្ទាប់មកហៅទៅ systemctl ដោយផ្ទាល់ ឧទាហរណ៍ systemctl reboot
• ជម្រើសសាមញ្ញជាង ប៉ុន្តែខ្ញុំមិនចូលចិត្តវាទេ។ នៅក្នុងចំណុចប្រទាក់ទាំងអស់ មិនត្រូវហៅ shutdown/reboot/other នោះទេ ប៉ុន្តែហៅទៅកាន់ target systemctl ដាច់ដោយឡែក my_shutdown.target

ខ្ញុំបានជ្រើសរើសជម្រើសដំបូង។ នៅក្នុង systemd, reboot (ដូចជា poweroff) គឺជា symlinks ទៅ systemd ។

ls -l /sbin/poweroff 
lrwxrwxrwx 1 root root 14 сен 30 18:23 /sbin/poweroff -> /bin/systemctl

ដូច្នេះ អ្នកអាចជំនួសពួកវាដោយស្គ្រីបផ្ទាល់ខ្លួនរបស់អ្នក៖
ចាប់ផ្ដើមឡើងវិញ

#!/bin/sh
    touch /tmp/reboot
    sudo systemctl isolate my_shutdown.target
fi

ប្រភព: www.habr.com