સિસ્ટમ્ડ, ઇન્ટરેક્ટિવ સ્ક્રિપ્ટ્સ અને ટાઈમર

પરિચય

જ્યારે Linux માટે ડેવલપ કરી રહ્યા હોય, ત્યારે ઇન્ટરેક્ટિવ સ્ક્રિપ્ટ્સ બનાવવાનું કાર્ય કે જે સિસ્ટમ ચાલુ અથવા બંધ હોય ત્યારે એક્ઝિક્યુટ થાય છે. સિસ્ટમ 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

સૌથી મહત્વની બાબત એ છે કે ફાઇનલ.ટાર્ગેટ પસંદ કરવું - લક્ષ્ય કે જેના પર સિસ્ટમ સ્ટાર્ટઅપ પર પહોંચવી જોઈએ. સ્ટાર્ટઅપ પ્રક્રિયા દરમિયાન, systemd નિર્ભરતાઓમાંથી પસાર થશે અને તેને જરૂરી દરેક વસ્તુને લોન્ચ કરશે.
final.target પસંદ કરવાની વિવિધ રીતો છે, મેં આ માટે લોડર વિકલ્પનો ઉપયોગ કર્યો છે.

અંતિમ પ્રક્ષેપણ આના જેવો દેખાય છે:

1. બુટલોડર શરૂ થાય છે
2. બુટલોડર final.target પેરામીટર પસાર કરીને ફર્મવેરને લોન્ચ કરવાનું શરૂ કરે છે
3. Systemd સિસ્ટમ શરૂ કરવાનું શરૂ કરે છે. અનુક્રમે તેમની અવલંબન (ઉદાહરણ તરીકે, multi-user.target) દ્વારા basic.target માંથી installer.target અથવા work.target પર જાય છે. બાદમાં સિસ્ટમને ઇચ્છિત મોડમાં કામ કરવા માટે લાવે છે

લોંચ માટે ફર્મવેર તૈયાર કરી રહ્યું છે

ફર્મવેર બનાવતી વખતે, કાર્ય હંમેશા સ્ટાર્ટઅપ સમયે સિસ્ટમની સ્થિતિને પુનઃસ્થાપિત કરવાનું અને શટ ડાઉન કરતી વખતે તેને સાચવવાનું ઉદ્ભવે છે. સ્ટેટ એટલે રૂપરેખાંકન ફાઈલો, ડેટાબેઝ ડમ્પ, ઈન્ટરફેસ સેટિંગ્સ વગેરે.

Systemd સમાન લક્ષ્યમાં પ્રક્રિયાઓને સમાંતર રીતે ચલાવે છે. એવી નિર્ભરતાઓ છે જે તમને સ્ક્રિપ્ટનો સ્ટાર્ટઅપ ક્રમ નક્કી કરવાની મંજૂરી આપે છે.

તે મારા પ્રોજેક્ટમાં કેવી રીતે કામ કરે છે ( https://habr.com/ru/post/477008/ https://github.com/skif-web/monitor)

1. સિસ્ટમ શરૂ થાય છે
2. Settings_restore.service સેવા શરૂ કરવામાં આવી છે. તે ડેટા વિભાગમાં settings.txt ફાઇલની હાજરી માટે તપાસ કરે છે. જો તે ત્યાં ન હોય, તો તેની જગ્યાએ સંદર્ભ ફાઇલ મૂકવામાં આવે છે. આગળ, સિસ્ટમ સેટિંગ્સ પુનઃસ્થાપિત થાય છે:
   • એડમિનિસ્ટ્રેટર પાસવર્ડ
   • યજમાન નામ,
   • સમય ઝોન
   • લોકેલ
   • નક્કી કરે છે કે શું તમામ મીડિયાનો ઉપયોગ થઈ રહ્યો છે. ડિફૉલ્ટ રૂપે, છબીનું કદ નાનું છે - મીડિયા પર કૉપિ અને રેકોર્ડિંગની સરળતા માટે. સ્ટાર્ટઅપ પર, તે હજુ પણ વણવપરાયેલ જગ્યા છે કે કેમ તે જોવા માટે તપાસ કરે છે. જો ત્યાં હોય, તો ડિસ્ક ફરીથી પાર્ટીશન કરવામાં આવે છે.
   • MAC એડ્રેસ પરથી મશીન-id જનરેટ કરી રહ્યું છે. DHCP દ્વારા સમાન સરનામું મેળવવા માટે આ મહત્વપૂર્ણ છે
   • નેટવર્ક સેટિંગ્સ
   • લૉગના કદને મર્યાદિત કરે છે
   • બાહ્ય ડ્રાઈવ કામ માટે તૈયાર થઈ રહી છે (જો અનુરૂપ વિકલ્પ સક્ષમ હોય અને ડ્રાઈવ નવી હોય)
3. પોસ્ટગ્રેસ્ક શરૂ કરો
4. પુનઃસ્થાપન સેવા શરૂ થાય છે. ઝબ્બીક્સ પોતે અને તેનો ડેટાબેઝ તૈયાર કરવા માટે તે જરૂરી છે:
   • ઝબ્બીક્સ ડેટાબેઝ પહેલેથી જ છે કે કેમ તે તપાસે છે. જો નહિં, તો તે શરૂઆતના ડમ્પ્સમાંથી બનાવવામાં આવે છે (ઝેબિક્સ સાથે સમાવિષ્ટ)
   • સમય ઝોનની સૂચિ બનાવવામાં આવી છે (તેમને વેબ ઇન્ટરફેસમાં પ્રદર્શિત કરવા માટે જરૂરી છે)
   • વર્તમાન 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 અને 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/રીબૂટ અને /tmp/શટડાઉન ફાઈલોનો ઉપયોગ કરીને. તમે પરિમાણો સાથે લક્ષ્યને કૉલ કરી શકતા નથી. માત્ર સેવા જ શક્ય છે.

પરંતુ હું કાર્યમાં સુગમતા અને ક્રિયાઓની ખાતરીપૂર્વકના ક્રમ માટે લક્ષ્યનો ઉપયોગ કરું છું.

જો કે, સૌથી રસપ્રદ બાબત પછીથી આવી. મશીનને બંધ/પુનઃશરૂ કરવાની જરૂર છે. અને ત્યાં 2 વિકલ્પો છે:

• રીબૂટ, શટડાઉન અને અન્ય આદેશોને તમારી સ્ક્રિપ્ટ સાથે બદલો (તે હજુ પણ systemctl માટે સિમલિંક છે) સ્ક્રિપ્ટની અંદર, my_shutdown.target પર જાઓ. અને લક્ષ્યની અંદરની સ્ક્રિપ્ટો પછી સીધું systemctl ને કૉલ કરે છે, ઉદાહરણ તરીકે, systemctl રીબૂટ
• એક સરળ વિકલ્પ, પરંતુ મને તે ગમતું નથી. બધા ઈન્ટરફેસમાં, શટડાઉન/રીબૂટ/અન્ય કૉલ કરશો નહીં, પરંતુ લક્ષ્ય systemctl isolate 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