Systemd, സംവേദനാത്മക സ്ക്രിപ്റ്റുകളും ടൈമറുകളും

ആമുഖം

ലിനക്സിനായി വികസിപ്പിക്കുമ്പോൾ, സിസ്റ്റം ഓണാക്കുമ്പോഴോ ഷട്ട്ഡൗൺ ചെയ്യുമ്പോഴോ എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്ന ഇന്ററാക്ടീവ് സ്ക്രിപ്റ്റുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ചുമതല ഉയർന്നുവരുന്നു. സിസ്റ്റം V-ൽ ഇത് എളുപ്പമായിരുന്നു, എന്നാൽ systemd-ൽ ഇത് ക്രമീകരണങ്ങൾ ചെയ്യുന്നു. എന്നാൽ അതിന് അതിന്റേതായ ടൈമറുകൾ ഉണ്ടാകാം.

എന്തുകൊണ്ടാണ് നമുക്ക് ലക്ഷ്യങ്ങൾ വേണ്ടത്?

സിസ്റ്റം 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 സിസ്റ്റം ആരംഭിക്കാൻ തുടങ്ങുന്നു. അടിസ്ഥാനം. ടാർഗെറ്റിൽ നിന്ന് ഇൻസ്റ്റാളർ. ടാർഗെറ്റിലേക്ക് തുടർച്ചയായി പോകുന്നു (ഉദാഹരണത്തിന്, 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 ഉൾപ്പെടുത്തിയിരിക്കുന്നത്)
   • സമയ മേഖലകളുടെ ഒരു ലിസ്റ്റ് സൃഷ്ടിച്ചു (വെബ് ഇന്റർഫേസിൽ അവ പ്രദർശിപ്പിക്കാൻ ആവശ്യമാണ്)
   • നിലവിലെ ഐപി കണ്ടെത്തി, അത് പ്രശ്നത്തിൽ പ്രദർശിപ്പിച്ചിരിക്കുന്നു (കൺസോളിലേക്ക് ലോഗിൻ ചെയ്യാനുള്ള ക്ഷണം)
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-ഉം എന്റെ setting_restore-ഉം ആരംഭിച്ചതിന് ശേഷം. എന്നാൽ zabbix സേവനങ്ങൾ ആരംഭിക്കുന്നതിന് മുമ്പ്.

ലോഗ്രോട്ടേറ്റിനുള്ള ടൈമർ സേവനം

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

ഇവിടെ എന്താണുള്ളത്:

• ടൈമർ വിവരണം
• സിസ്റ്റം ബൂട്ടിൽ നിന്ന് ആരംഭിക്കുന്ന ആദ്യ ആരംഭ സമയം
• കൂടുതൽ വിക്ഷേപണങ്ങളുടെ കാലയളവ്
• ടൈമർ സേവനത്തെ ആശ്രയിക്കുക. വാസ്തവത്തിൽ, ഇതാണ് ടൈമർ നിർമ്മിക്കുന്നത്

ഷട്ട്ഡൗൺ ചെയ്യുമ്പോൾ ഇന്ററാക്ടീവ് സ്ക്രിപ്റ്റും നിങ്ങളുടെ ഷട്ട്ഡൗൺ ലക്ഷ്യവും

മറ്റൊരു സംഭവവികാസത്തിൽ, മെഷീൻ ഓഫ് ചെയ്യുന്നതിനുള്ള കൂടുതൽ സങ്കീർണ്ണമായ ഒരു പതിപ്പ് എനിക്ക് ചെയ്യേണ്ടിവന്നു - എന്റെ സ്വന്തം ലക്ഷ്യത്തിലൂടെ, നിരവധി പ്രവർത്തനങ്ങൾ നടത്തുന്നതിന്. 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 റീബൂട്ട്
• ഒരു ലളിതമായ ഓപ്ഷൻ, പക്ഷേ എനിക്കത് ഇഷ്ടമല്ല. എല്ലാ ഇന്റർഫേസുകളിലും, ഷട്ട്ഡൗൺ/റീബൂട്ട്/മറ്റുള്ളവ എന്ന് വിളിക്കരുത്, എന്നാൽ ടാർഗെറ്റ് systemctl ഐസൊലേറ്റ് my_shutdown.target-ലേക്ക് നേരിട്ട് വിളിക്കുക.

ഞാൻ ആദ്യ ഓപ്ഷൻ തിരഞ്ഞെടുത്തു. systemd-ൽ, reboot (poweroff പോലെ) 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