🥇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 ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ವಿವಿಧ ಮಾರ್ಗಗಳಿವೆ, ಇದಕ್ಕಾಗಿ ನಾನು ಲೋಡರ್ ಆಯ್ಕೆಯನ್ನು ಬಳಸಿದ್ದೇನೆ.

ಅಂತಿಮ ಉಡಾವಣೆ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

ಬೂಟ್ಲೋಡರ್ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ
ಬೂಟ್‌ಲೋಡರ್ ಫೈನಲ್.ಟಾರ್ಗೆಟ್ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಹಾದುಹೋಗುವ ಮೂಲಕ ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ
Systemd ಸಿಸ್ಟಮ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಅನುಕ್ರಮವಾಗಿ ತಮ್ಮ ಅವಲಂಬನೆಗಳ ಮೂಲಕ installer.target ಅಥವಾ work.target ನಿಂದ basic.target ಗೆ ಹೋಗುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, multi-user.target). ಎರಡನೆಯದು ಸಿಸ್ಟಮ್ ಅನ್ನು ಅಪೇಕ್ಷಿತ ಕ್ರಮದಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ತರುತ್ತದೆ

ಉಡಾವಣೆಗಾಗಿ ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸಲಾಗುತ್ತಿದೆ

ಫರ್ಮ್ವೇರ್ ಅನ್ನು ರಚಿಸುವಾಗ, ಪ್ರಾರಂಭದಲ್ಲಿ ಸಿಸ್ಟಮ್ ಸ್ಥಿತಿಯನ್ನು ಮರುಸ್ಥಾಪಿಸುವ ಮತ್ತು ಸ್ಥಗಿತಗೊಳಿಸುವಾಗ ಅದನ್ನು ಉಳಿಸುವ ಕಾರ್ಯವು ಯಾವಾಗಲೂ ಉದ್ಭವಿಸುತ್ತದೆ. ರಾಜ್ಯ ಎಂದರೆ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳು, ಡೇಟಾಬೇಸ್ ಡಂಪ್‌ಗಳು, ಇಂಟರ್ಫೇಸ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಇತ್ಯಾದಿ.

Systemd ಸಮಾನಾಂತರವಾಗಿ ಒಂದೇ ಗುರಿಯಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ನಡೆಸುತ್ತದೆ. ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಆರಂಭಿಕ ಅನುಕ್ರಮವನ್ನು ನಿರ್ಧರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಅವಲಂಬನೆಗಳಿವೆ.

ನನ್ನ ಯೋಜನೆಯಲ್ಲಿ ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ( https://habr.com/ru/post/477008/ https://github.com/skif-web/monitor)

ವ್ಯವಸ್ಥೆಯು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ
settings_restore.service ಸೇವೆಯನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ. ಇದು ಡೇಟಾ ವಿಭಾಗದಲ್ಲಿ settings.txt ಫೈಲ್ ಇರುವಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಅದು ಇಲ್ಲದಿದ್ದರೆ, ಒಂದು ಉಲ್ಲೇಖ ಫೈಲ್ ಅನ್ನು ಅದರ ಸ್ಥಳದಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ, ಮುಂದೆ, ಸಿಸ್ಟಮ್ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಮರುಸ್ಥಾಪಿಸಲಾಗುತ್ತದೆ:
- ನಿರ್ವಾಹಕರ ಗುಪ್ತಪದ
- ಹೋಸ್ಟ್ ಹೆಸರು,
- ಸಮಯ ವಲಯ
- ಸ್ಥಳ
- ಎಲ್ಲಾ ಮಾಧ್ಯಮಗಳನ್ನು ಬಳಸಲಾಗುತ್ತಿದೆಯೇ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಚಿತ್ರದ ಗಾತ್ರವು ಚಿಕ್ಕದಾಗಿದೆ - ಮಾಧ್ಯಮಕ್ಕೆ ನಕಲಿಸಲು ಮತ್ತು ರೆಕಾರ್ಡಿಂಗ್ ಮಾಡಲು ಸುಲಭವಾಗಿದೆ. ಪ್ರಾರಂಭದಲ್ಲಿ, ಇನ್ನೂ ಬಳಕೆಯಾಗದ ಸ್ಥಳವಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇದ್ದರೆ, ಡಿಸ್ಕ್ ಅನ್ನು ಮರುವಿಭಜಿಸಲಾಗಿದೆ.
- MAC ವಿಳಾಸದಿಂದ ಯಂತ್ರ-ಐಡಿ ರಚಿಸಲಾಗುತ್ತಿದೆ. DHCP ಮೂಲಕ ಅದೇ ವಿಳಾಸವನ್ನು ಪಡೆಯಲು ಇದು ಮುಖ್ಯವಾಗಿದೆ
- ನೆಟ್‌ವರ್ಕ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು
- ಲಾಗ್‌ಗಳ ಗಾತ್ರವನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತದೆ
- ಬಾಹ್ಯ ಡ್ರೈವ್ ಅನ್ನು ಕೆಲಸಕ್ಕಾಗಿ ಸಿದ್ಧಪಡಿಸಲಾಗುತ್ತಿದೆ (ಅನುಗುಣವಾದ ಆಯ್ಕೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿದ್ದರೆ ಮತ್ತು ಡ್ರೈವ್ ಹೊಸದಾಗಿದ್ದರೆ)
postgresq ಪ್ರಾರಂಭಿಸಿ
ಪುನಃಸ್ಥಾಪನೆ ಸೇವೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. Zabbix ಸ್ವತಃ ಮತ್ತು ಅದರ ಡೇಟಾಬೇಸ್ ಅನ್ನು ತಯಾರಿಸಲು ಇದು ಅಗತ್ಯವಿದೆ:
- ಈಗಾಗಲೇ zabbix ಡೇಟಾಬೇಸ್ ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಇದನ್ನು ಇನಿಶಿಯಲೈಸೇಶನ್ ಡಂಪ್‌ಗಳಿಂದ ರಚಿಸಲಾಗಿದೆ (ಝಬ್ಬಿಕ್ಸ್‌ನೊಂದಿಗೆ ಸೇರಿಸಲಾಗಿದೆ)
- ಸಮಯ ವಲಯಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಲಾಗಿದೆ (ಅವುಗಳನ್ನು ವೆಬ್ ಇಂಟರ್ಫೇಸ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲು ಅಗತ್ಯವಿದೆ)
- ಪ್ರಸ್ತುತ IP ಕಂಡುಬಂದಿದೆ, ಅದನ್ನು ಸಮಸ್ಯೆಯಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ (ಕನ್ಸೋಲ್‌ಗೆ ಲಾಗ್ ಇನ್ ಮಾಡಲು ಆಹ್ವಾನ)
ಆಮಂತ್ರಣವು ಬದಲಾಗುತ್ತದೆ - ಕೆಲಸ ಮಾಡಲು ಸಿದ್ಧ ಎಂಬ ನುಡಿಗಟ್ಟು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ
ಫರ್ಮ್ವೇರ್ ಬಳಕೆಗೆ ಸಿದ್ಧವಾಗಿದೆ

ಸೇವಾ ಫೈಲ್‌ಗಳು ಮುಖ್ಯವಾಗಿವೆ, ಅವುಗಳು ಅವುಗಳ ಉಡಾವಣೆಯ ಅನುಕ್ರಮವನ್ನು ಹೊಂದಿಸುತ್ತವೆ

[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 ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

ಮತ್ತು ಎರಡನೇ ಸೇವೆ (ಝಬ್ಬಿಕ್ಸ್ ತಯಾರಿ)

#!/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 ಮತ್ತು my 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 ನಲ್ಲಿ, ರೀಬೂಟ್ (ಪವರ್‌ಆಫ್‌ನಂತೆ) 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

Systemd, ಸಂವಾದಾತ್ಮಕ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಮತ್ತು ಟೈಮರ್‌ಗಳು