ಕ್ರಾನ್ ಉದ್ಯೋಗಗಳ ಸಂರಚನೆ

ಕ್ರಾನ್ is a commonly confusing and misconfigured aspect of the operating system. Technically, cron is just the clock daemon (/usr/sbin/cron or perhaps /usr/sbin/crond) that executes commands at specific times. However, a handful of configuration files and programs go into making up the cron package. Like many system processes, cron never ends.

The controlling files for cron are the cron-tables or crontabs. The crontabs are often located in /var/spool/cron/crontab. However, on SuSE you will find them in /var/spool/cron/tabs. The names of the files in this directory are the names of the users that submit the cron jobs.

ಇತರ ಯುನಿಕ್ಸ್ ಉಪಭಾಷೆಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, ಲಿನಕ್ಸ್ ಕ್ರಾನ್ ಡಿಮನ್ ಮುಂದಿನ ಕ್ರಾನ್ ಕೆಲಸ ಸಿದ್ಧವಾಗುವವರೆಗೆ ನಿದ್ರಿಸುವುದಿಲ್ಲ. ಬದಲಿಗೆ, ಕ್ರಾನ್ ಒಂದು ಕೆಲಸವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದಾಗ, ಅದು ಹೆಚ್ಚಿನ ಕೆಲಸಗಳಿಗಾಗಿ ನಿಮಿಷಕ್ಕೆ ಒಮ್ಮೆ ಪರಿಶೀಲಿಸುತ್ತಲೇ ಇರುತ್ತದೆ. ಜೊತೆಗೆ, ನೀವು ಕಡತಗಳನ್ನು ನೇರವಾಗಿ ಸಂಪಾದಿಸಬಾರದು. ನೀವು ಅವುಗಳನ್ನು vi ನಂತಹ ಪಠ್ಯ ಸಂಪಾದಕದೊಂದಿಗೆ ಸಂಪಾದಿಸಬಹುದು, ಆದರೂ ವಿಷಯಗಳನ್ನು ಗೊಂದಲಗೊಳಿಸುವ ಸಾಮರ್ಥ್ಯವಿದೆ. ಆದ್ದರಿಂದ, ನೀವು ಲಿನಕ್ಸ್ ಒದಗಿಸುವ ಸಾಧನವನ್ನು ಬಳಸಬೇಕುಃ ಕ್ರಾಂಟ್ಯಾಬ್. (ಹೆಚ್ಚಿನ ವಿವರಗಳಿಗಾಗಿ ಮ್ಯಾನ್-ಪೇಜ್ ನೋಡಿ)

ಕ್ರೊಂಟ್ಯಾಬ್ ಉಪಯುಕ್ತತೆಯು ಹಲವಾರು ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದೆ. ಇದು ಕ್ರೊನ್ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಕಡತಗಳನ್ನು ವ್ಯವಸ್ಥೆಗೆ ಸಲ್ಲಿಸುವ ವಿಧಾನವಾಗಿದೆ. ಎರಡನೆಯದಾಗಿ, ಇದು ನಿಮ್ಮ ಕ್ರೊಂಟ್ಯಾಬ್ನ ವಿಷಯಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಬಹುದು. ನೀವು root ಆಗಿದ್ದರೆ, ಅದು ಯಾವುದೇ ಬಳಕೆದಾರರಿಗೆ ಉದ್ಯೋಗಗಳನ್ನು ಸಲ್ಲಿಸಬಹುದು ಮತ್ತು ಪಟ್ಟಿ ಮಾಡಬಹುದು. ಸಮಸ್ಯೆಯೆಂದರೆ ಉದ್ಯೋಗಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಸಲ್ಲಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಕ್ರೊಂಟ್ಯಾಬ್ ಬಳಸಿ, ನೀವು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಎಲ್ಲಾ ಉದ್ಯೋಗಗಳನ್ನು ಸಲ್ಲಿಸಬೇಕು.

ಮೊದಲಿಗೆ, ಇದು ಸ್ವಲ್ಪ ಕಿರಿಕಿರಿಯನ್ನುಂಟುಮಾಡಬಹುದು. ಆದಾಗ್ಯೂ, ಒಂದು ಕೆಲಸವನ್ನು "ಸೇರಿಸುವ" ಪ್ರಕ್ರಿಯೆಯನ್ನು ನೋಡೋಣ. ಕ್ರಾನ್ ಕೆಲಸವನ್ನು ಸೇರಿಸಲು, ನೀವು ಮೊದಲು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕ್ರಾಂಟ್ಯಾಬ್ನ ವಿಷಯಗಳನ್ನು-l ಆಯ್ಕೆಯೊಂದಿಗೆ ಪಟ್ಟಿ ಮಾಡಬೇಕು. ನೀವು root ಆಗಿದ್ದರೆ ಮತ್ತು ಇನ್ನೊಬ್ಬ ಬಳಕೆದಾರರ ಕ್ರಾಂಟ್ಯಾಬ್ಗೆ ಏನನ್ನಾದರೂ ಸೇರಿಸಲು ಬಯಸಿದರೆ,-u ಆಯ್ಕೆಯನ್ನು ಬಳಸಿ, ನಂತರ ಬಳಕೆದಾರರ ಲೋಗ್ನೇಮ್ ಅನ್ನು ಬಳಸಿ. ನಂತರ ಈ ಕ್ರಾಂಟ್ಯಾಬ್ ಅನ್ನು ಫೈಲ್ಗೆ ಮರುನಿರ್ದೇಶಿಸಿ, ನಂತರ ನೀವು ಅದನ್ನು ಸಂಪಾದಿಸಬಹುದು. (ಕೆಲವು ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಕ್ರಾಂಟ್ಯಾಬ್ನಲ್ಲಿ-e ಇದೆ ("ಎಡಿಟ್" ಗಾಗಿ), ಇದು ನಿಮಗಾಗಿ ಎಲ್ಲಾ ಕೆಲಸಗಳನ್ನು ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಹೆಚ್ಚಿನ ವಿವರಗಳಿಗಾಗಿ ಮ್ಯಾನ್-ಪೇಜ್ ನೋಡಿ.)

ಉದಾಹರಣೆಗೆ, ನೀವು root ಬಳಕೆದಾರರಾಗಿದ್ದೀರಿ ಮತ್ತು UUCP ಬಳಕೆದಾರರ ಕ್ರಾಂಟ್ಯಾಬ್ಗೆ ಏನನ್ನಾದರೂ ಸೇರಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಹೇಳೋಣ. ಮೊದಲು, ಈ ಆಜ್ಞೆಯೊಂದಿಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕ್ರಾಂಟ್ಯಾಬ್ ನಮೂದಿನ ಔಟ್ಪುಟ್ ಅನ್ನು ಪಡೆಯಿರಿಃ

crontab -l -u uucp >/tmp/crontab.uucp

ಒಂದು ನಮೂದನ್ನು ಸೇರಿಸಲು, ಕೇವಲ ಒಂದು ಹೊಸ ಸಾಲನ್ನು ಸೇರಿಸಿ. ಕಡತವನ್ನು ಉಳಿಸಿ, ನಿಮ್ಮ ಸಂಪಾದಕನಿಂದ ಹೊರಬನ್ನಿ, ಮತ್ತು ಕ್ರಾಂಟ್ಯಾಬ್ ಉಪಯುಕ್ತತೆಯನ್ನು ಮತ್ತೆ ಚಲಾಯಿಸಿ. ಈ ಬಾರಿ, ಕಡತವನ್ನು ಪಟ್ಟಿ ಮಾಡಲು-l ಅನ್ನು ಬಿಟ್ಟುಬಿಡಿ ಆದರೆ ಕಡತದ ಹೆಸರನ್ನು ಸೇರಿಸಿ. ಕ್ರಾಂಟ್ಯಾಬ್ ಉಪಯುಕ್ತತೆಯು ಎಸ್ಟಿಡಿನ್ನಿಂದ ಇನ್ಪುಟ್ ಅನ್ನು ಸಹ ಸ್ವೀಕರಿಸಬಹುದು, ಆದ್ದರಿಂದ ನೀವು ಕಡತದ ಹೆಸರನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು ಮತ್ತು ಕ್ರಾಂಟ್ಯಾಬ್ ನಿಮಗೆ ಕಮಾಂಡ್ ಲೈನ್ನಲ್ಲಿ ಕ್ರೋಂಜಾಬ್ಗಳನ್ನು ನಮೂದಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ನೀವು ಯಾವ ವಿಧಾನವನ್ನು ಬಳಸಿದರೂ ಹಿಂದಿನ ಯಾವುದೇ ಕ್ರಾಂಟ್ಯಾಬ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲಾಗಿದೆ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ.

The file /tmp/crontab.uucp now contains the contents of UUCPs crontab. It might look something like this:

39,9 * * * * /usr/lib/uucp/uudemon.hour > /dev/null
10 * * * * /usr/lib/uucp/uudemon.poll > /dev/null
45 23 * * * ulimit 5000; /usr/lib/uucp/uudemon.clean > /dev/null
48 10,14 * * 1-5 /usr/lib/uucp/uudemon.admin > /dev/null

ಅದರ ನೋಟದ ಹೊರತಾಗಿಯೂ, ಪ್ರತಿ ಕ್ರಾಂಟಾಬ್ ನಮೂದು ಕೇವಲ ಆರು ಕ್ಷೇತ್ರಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಮೊದಲ ಐದು ಕ್ಷೇತ್ರಗಳು ಕೆಲಸವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಸಮಯವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ ಮತ್ತು ಆರನೆಯದು ನಿಜವಾದ ಆಜ್ಞೆಯಾಗಿದೆ. ಮೊದಲ ಐದು ಕ್ಷೇತ್ರಗಳನ್ನು ಸ್ಥಳ ಅಥವಾ ಟ್ಯಾಬ್ನಿಂದ ಬೇರ್ಪಡಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅನುಕ್ರಮವಾಗಿ ಈ ಕೆಳಗಿನ ಘಟಕಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆಃ

ನಿಮಿಷಗಳು (0-59)
ಗಂಟೆ (0-23)
ತಿಂಗಳ ದಿನ (1-31)
ವರ್ಷದ ತಿಂಗಳು (1-12)
ವಾರದ ದಿನ (0-6,0 = ಭಾನುವಾರ)
ಎಲ್ಲಾ ಸಂಭವನೀಯ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು, ನಕ್ಷತ್ರ ಚಿಹ್ನೆ (*) ಅನ್ನು ಬಳಸಿ. ಆ ಒಂದು ಮೌಲ್ಯವನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ನೀವು ಒಂದೇ ಮೌಲ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಹಿಂದಿನ ಉದಾಹರಣೆಯಲ್ಲಿನ ಎರಡನೇ ಸಾಲು ಮೊದಲ ಕ್ಷೇತ್ರದಲ್ಲಿ 10 ರ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ, ಅಂದರೆ ಗಂಟೆಯ ನಂತರ 10 ನಿಮಿಷಗಳು. ಇತರ ನಾಲ್ಕು ಸಮಯ ಕ್ಷೇತ್ರಗಳು ನಕ್ಷತ್ರ ಚಿಹ್ನೆಗಳಾಗಿರುವುದರಿಂದ, ಇದರರ್ಥ ಆಜ್ಞೆಯನ್ನು ಪ್ರತಿ ದಿನದ ಪ್ರತಿ ಗಂಟೆಯೂ ಗಂಟೆ ದಾಟಿದ 10 ನಿಮಿಷಗಳಲ್ಲಿ ಚಲಾಯಿಸಲಾಗುತ್ತದೆ.

ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಗಳು ಮೊದಲ ಮೌಲ್ಯ, ಡ್ಯಾಶ್ ಮತ್ತು ಅಂತಿಮ ಮೌಲ್ಯದಿಂದ ಕೂಡಿರುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ನಾಲ್ಕನೇ ಸಾಲು ವಾರದ ಅಂಕಣದಲ್ಲಿ ಒಂದು ವ್ಯಾಪ್ತಿಯನ್ನು (1-5) ಹೊಂದಿದೆ, ಅಂದರೆ ಆಜ್ಞೆಯನ್ನು ಸೋಮವಾರದಿಂದ ಶುಕ್ರವಾರದವರೆಗೆ 1-5 ದಿನಗಳಲ್ಲಿ ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ವ್ಯಾಪ್ತಿಯೊಳಗೆ ಇಲ್ಲದ ವಿವಿಧ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು, ಪ್ರತ್ಯೇಕ ಮೌಲ್ಯಗಳನ್ನು ಅಲ್ಪವಿರಾಮದಿಂದ ಬೇರ್ಪಡಿಸಿ. ನಾಲ್ಕನೇ ಉದಾಹರಣೆಯಲ್ಲಿ, ಗಂಟೆ ಕ್ಷೇತ್ರವು 10 ಮತ್ತು 14 ಎಂಬ ಎರಡು ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದೆ. ಇದರರ್ಥ ಆಜ್ಞೆಯನ್ನು ಬೆಳಿಗ್ಗೆ 10 ಮತ್ತು ಮಧ್ಯಾಹ್ನ 2 ಗಂಟೆಗೆ ಚಲಾಯಿಸಲಾಗುತ್ತದೆ.

ಸಮಯಗಳು ಸಂಯೋಜಕವಾಗಿವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣಃ


10 * 1,16 * 1-5 /usr/local/bin/command


ಪ್ರತಿ ಗಂಟೆಯ ನಂತರ 10 ನಿಮಿಷಗಳ ನಂತರ ಮೊದಲ ಮತ್ತು ಹದಿನಾರನೇ ದಿನದಂದು ಮತ್ತು ಸೋಮವಾರದಿಂದ ಶುಕ್ರವಾರದವರೆಗೆ ಕಮಾಂಡ್ ಅನ್ನು ಚಲಾಯಿಸಲಾಗುತ್ತದೆ. ಮೊದಲ ಅಥವಾ ಹದಿನಾರನೇ ವಾರಾಂತ್ಯದಲ್ಲಿದ್ದರೆ, ಕಮಾಂಡ್ ಇನ್ನೂ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಏಕೆಂದರೆ ತಿಂಗಳ ಕ್ಷೇತ್ರವು ಅನ್ವಯಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಮೊದಲನೆಯದು ಸೋಮವಾರವಾಗಿದ್ದರೆ, ಕಮಾಂಡ್ ಅನ್ನು ಎರಡು ಬಾರಿ ನಡೆಸಲಾಗುತ್ತದೆ ಎಂದು ಇದರ ಅರ್ಥವಲ್ಲ.

ಕ್ರಾಂಟ್ಯಾಬ್ ನಮೂದನ್ನು ಕೇವಲ ಪ್ರತಿ ಗಂಟೆ ಅಥವಾ ಪ್ರತಿ ದಿನಕ್ಕಿಂತ ವಿಭಿನ್ನ ಮಧ್ಯಂತರಗಳಲ್ಲಿ ಓಡುವಂತೆ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ಪ್ರತಿ ಎರಡು ನಿಮಿಷಗಳಿಗೊಮ್ಮೆ ಅಥವಾ ಪ್ರತಿ ಮೂರು ಗಂಟೆಗಳಿಗೊಮ್ಮೆ ಕ್ರಾಂಟ್ಯಾಬ್ನಲ್ಲಿ ಪ್ರತಿ ಪ್ರತ್ಯೇಕ ನಮೂದನ್ನು ಹಾಕದೆ ಗ್ರ್ಯಾನುಲಾರಿಟಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

ನಾವು ಹಿಂದಿನ ಆಜ್ಞೆಯನ್ನು ಗಂಟೆಯ ನಂತರ 10 ನಿಮಿಷಗಳಲ್ಲಿ ಅಲ್ಲ, ಆದರೆ ಪ್ರತಿ ಹತ್ತು ನಿಮಿಷಗಳಿಗೊಮ್ಮೆ ಚಲಾಯಿಸಲು ಬಯಸಿದ್ದೇವೆ ಎಂದು ಹೇಳೋಣ. ನಾವು ಈ ರೀತಿ ಕಾಣುವ ನಮೂದನ್ನು ಮಾಡಬಹುದು.:


0,10,20,30,40,50 * 1,16 * 1-5 /usr/local/bin/command


ಇದು ಪ್ರತಿ 10 ನಿಮಿಷಗಳಿಗೊಮ್ಮೆ ನಡೆಯುತ್ತದೆಃ ಗಂಟೆಯ ಕೊನೆಯಲ್ಲಿ, 10 ನಿಮಿಷಗಳ ನಂತರ, 20 ನಿಮಿಷಗಳ ನಂತರ, ಮತ್ತು ಹೀಗೆ. ಜೀವನವನ್ನು ಸುಲಭಗೊಳಿಸಲು, ನಾವು ಈ ರೀತಿಯ ನಮೂದನ್ನು ರಚಿಸಬಹುದುಃ


*/10 * 1,16 * 1-5 /usr/local/bin/command


ಈ ವಾಕ್ಯರಚನೆಯು ಕೆಲವು ನಿರ್ವಾಹಕರಿಗೆ ಹೊಸದಾಗಿರಬಹುದು. (ಇದು ನನಗೆ.) ನಿರ್ದಿಷ್ಟ ಮಧ್ಯಂತರದೊಳಗೆ (ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರತಿ ನಿಮಿಷಕ್ಕೆ), ಪ್ರತಿ ಹಲವು ನಿಮಿಷಗಳಿಗೊಮ್ಮೆ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ; ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರತಿ 10 ನಿಮಿಷಗಳಿಗೊಮ್ಮೆ ಎಂದು ಸ್ಲಾಶ್ (/) ಹೇಳುತ್ತದೆ.

ನಾವು ಒಂದು ವ್ಯಾಪ್ತಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದರೂ ಸಹ ಇದನ್ನು ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಕೆಲಸವು ಗಂಟೆಯ ನಂತರ 20 ನಿಮಿಷಗಳು ಮತ್ತು ಗಂಟೆಯ ನಂತರ 40 ನಿಮಿಷಗಳ ನಡುವೆ ಮಾತ್ರ ನಡೆಯಬೇಕಿದ್ದರೆ, ನಮೂದು ಈ ರೀತಿ ಕಾಣಿಸಬಹುದುಃ


20-40 * 1,16 * 1-5 /usr/local/bin/command


ನೀವು ಈ ಸಮಯದಲ್ಲಿ ಅದನ್ನು ಓಡಿಸಲು ಬಯಸಿದರೆ, ಆದರೆ ಪ್ರತಿ ಮೂರು ನಿಮಿಷಗಳಿಗೊಮ್ಮೆ ಮಾತ್ರ? ಸಾಲು ಈ ರೀತಿ ಕಾಣಿಸಬಹುದುಃ


20-40/3 * 1,16 * 1-5 /usr/local/bin/command


ವಿಷಯಗಳನ್ನು ಇನ್ನಷ್ಟು ಸಂಕೀರ್ಣಗೊಳಿಸಲು, ನೀವು ಆಜ್ಞೆಯನ್ನು ಪ್ರತಿ ಎರಡು ನಿಮಿಷಗಳಿಗೊಮ್ಮೆ ಗಂಟೆ ಮತ್ತು 20 ನಿಮಿಷಗಳ ನಡುವೆ, ಪ್ರತಿ ಮೂರು ನಿಮಿಷಗಳಿಗೊಮ್ಮೆ 20 ಮತ್ತು 40 ನಿಮಿಷಗಳ ನಡುವೆ, ನಂತರ ಪ್ರತಿ 5 ನಿಮಿಷಗಳಿಗೊಮ್ಮೆ 40 ನಿಮಿಷಗಳ ನಂತರ ಮತ್ತು ಗಂಟೆಯ ನಡುವೆ ಚಲಾಯಿಸಲು ನೀವು ಬಯಸಿದ್ದೀರಿ ಎಂದು ನೀವು ಹೇಳಬಹುದು.


0-20/2,21-40/3,41-59/5 * 1,16 * 1-5 /usr/local/bin/command


ಬಹಳಷ್ಟು ಲಿನಕ್ಸ್ ಉಪಭಾಷೆಗಳು ಮಾಡುವ ಒಂದು ಒಳ್ಳೆಯ ಕೆಲಸವೆಂದರೆ ವಾರದ ದಿನಗಳು ಮತ್ತು ತಿಂಗಳುಗಳಿಗೆ ಸಂಕ್ಷೇಪಣಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಿಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುವುದು. ಫ್ರೈ 5ರ ಬದಲಿಗೆ ಶುಕ್ರವಾರ ಎಂದು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ತುಂಬಾ ಸುಲಭ.

ಸಮಯ ಕ್ಷೇತ್ರಗಳಲ್ಲಿನ ಕೆಲವು ದೋಷಗಳನ್ನು ಹೊರತುಪಡಿಸಿ, ಕ್ರಾನ್ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವವರೆಗೆ ದೋಷಗಳನ್ನು ವರದಿ ಮಾಡಲಾಗುವುದಿಲ್ಲ. ಎಲ್ಲಾ ದೋಷ ಸಂದೇಶಗಳು ಮತ್ತು ಔಟ್ಪುಟ್ಗಳನ್ನು ಬಳಕೆದಾರರಿಗೆ ಮೇಲ್ ಮಾಡಲಾಗುತ್ತದೆ. ಕನಿಷ್ಠ ಕ್ರೊಂಟ್ಯಾಬ್ ಮ್ಯಾನ್-ಪೇಜ್ ಇದನ್ನೇ ಹೇಳುತ್ತದೆ ಮತ್ತು ಅದು ಮೂಲಭೂತವಾಗಿ ನಿಜವಾಗಿದೆ. ಆದಾಗ್ಯೂ, ನೀವು ಹಿಂದಿನ ಉದಾಹರಣೆಗಳಲ್ಲಿ ನೋಡುವಂತೆ, ನೀವು STDout ಅನ್ನು/dev/null ಗೆ ಮರುನಿರ್ದೇಶಿಸುತ್ತಿದ್ದೀರಿ. ನೀವು ಬಯಸಿದರೆ, ನೀವು ಅಲ್ಲಿ STDERR ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸಬಹುದು ಮತ್ತು ಯಾವುದೇ ದೋಷಗಳಿವೆಯೇ ಎಂದು ನಿಮಗೆ ಕಾಣಿಸುವುದಿಲ್ಲ.

ಔಟ್ಪುಟ್ ಅನ್ನು ಬಳಕೆದಾರರಿಗೆ ಮೇಲ್ ಮಾಡಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಕ್ರೋಂಜಾಬ್ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತಿರುವ ನಿಜವಾದ ಟರ್ಮಿನಲ್ ಇಲ್ಲ. ಆದ್ದರಿಂದ, ದೋಷಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲು ಯಾವುದೇ ಪರದೆ ಇಲ್ಲ. ಜೊತೆಗೆ, ಇನ್ಪುಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸಲು ಕೀಬೋರ್ಡ್ ಇಲ್ಲ. ಅಂದರೆ ನೀವು ಕ್ರಾನ್ ಕೆಲಸಕ್ಕೆ ಇನ್ಪುಟ್ ನೀಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದರ್ಥವೇ? ಇಲ್ಲ. ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ಗಳ ಮೇಲಿನ ಚರ್ಚೆಗೆ ಹಿಂತಿರುಗಿ ಯೋಚಿಸಿ. ನಾವು ಎಸ್ಟಿಡಿನ್, ಎಸ್ಟಿಡೌಟ್ ಮತ್ತು ಎಸ್ಟಿಡಿಆರ್ಆರ್ ಅನ್ನು ಮರು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ಈ ರೀತಿಯಲ್ಲಿ ಅವರು ಫೈಲ್ಗಳನ್ನು ಸೂಚಿಸಬಹುದು ಮತ್ತು ನಾವು ನಿರೀಕ್ಷಿಸಿದಂತೆ ವರ್ತಿಸಬಹುದು.

ನಾನು ಗಮನಸೆಳೆಯಲು ಬಯಸುವ ಒಂದು ವಿಷಯವೆಂದರೆ, ಕ್ರಾಂಟ್ಯಾಬ್ನ ಕಮಾಂಡ್ ಕ್ಷೇತ್ರದಲ್ಲಿ ಮರುನಿರ್ದೇಶನವನ್ನು ಮಾಡುವುದನ್ನು ನಾನು ಶಿಫಾರಸು ಮಾಡುವುದಿಲ್ಲ. ನಾನು ಅಲ್ಲಿ ಸಾಧ್ಯವಾದಷ್ಟು ಕಡಿಮೆ ಮಾಡಲು ಇಷ್ಟಪಡುತ್ತೇನೆ. ಬದಲಿಗೆ, ನಾನು ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ಗೆ ಸಂಪೂರ್ಣ ಮಾರ್ಗವನ್ನು ಹಾಕುತ್ತೇನೆ. ನಂತರ ನಾನು ಸರಳವಾದ ಯಾವುದಾದರೊದರೊಂದಿಗೆ ಕ್ರಾಂಟ್ಯಾಬ್ ನಮೂದನ್ನು ಪರೀಕ್ಷಿಸಬಹುದು. ಅದು ಕೆಲಸ ಮಾಡಿದ ನಂತರ, ನಾನು ಕ್ರಾಂಜೋಬ್ ಅನ್ನು ಮರುಹಂಚಿಕೆ ಮಾಡದೆಯೇ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಬಹುದು.

ಕ್ರಾನ್ ನಿಖರವಾಗಿಲ್ಲ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ. ಇದು ಪ್ರತಿ ನಿಮಿಷದ ಮೇಲ್ಭಾಗಕ್ಕೆ ತನ್ನನ್ನು ತಾನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಿಕೊಳ್ಳುತ್ತದೆ. ನೀವು ಗಡಿಯಾರದ ಉಬ್ಬುಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳುವ ಕಾರ್ಯನಿರತ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ನಿಗದಿತ ಸಮಯದ ನಂತರ ಒಂದೆರಡು ನಿಮಿಷಗಳವರೆಗೆ ಕೆಲಸಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ. ಜೊತೆಗೆ, ಹೆಚ್ಚಿನ ಆದ್ಯತೆಗಳನ್ನು ಹೊಂದಿರುವ ಇತರ ಪ್ರಕ್ರಿಯೆಗಳು ಕ್ರಾನ್ ಕೆಲಸಗಳನ್ನು ವಿಳಂಬಗೊಳಿಸಬಹುದು. ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, (ವಿಶೇಷವಾಗಿ ಅತ್ಯಂತ ಕಾರ್ಯನಿರತ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ) ಉದ್ಯೋಗಗಳನ್ನು ಪ್ರತಿ ನಿಮಿಷವೂ ಚಲಾಯಿಸಿದರೆ ಅವುಗಳನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು.

ಎರಡು ಕಡತಗಳ ಮೂಲಕ ಕ್ರಾನ್ ಸೌಲಭ್ಯಕ್ಕೆ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸಲಾಗಿದೆ, ಎರಡೂ/ಇತ್ಯಾದಿಗಳಲ್ಲಿ. ನಿಮ್ಮ ಬಳಿ cron.allow ಕಡತವಿದ್ದರೆ, ಯಾವ ಬಳಕೆದಾರರಿಗೆ ಕ್ರಾನ್ ಬಳಸಲು ಅನುಮತಿ ಇದೆ ಎಂಬುದನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. cron.deny ನಿರ್ದಿಷ್ಟವಾಗಿ ಯಾರು ಕ್ರಾನ್ ಅನ್ನು ಬಳಸಲು ಅನುಮತಿಸುವುದಿಲ್ಲ ಎಂದು ಹೇಳುತ್ತದೆ. ಎರಡೂ ಕಡತಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ, ಸಿಸ್ಟಮ್ ಬಳಕೆದಾರರಿಗೆ ಮಾತ್ರ ಪ್ರವೇಶವಿದೆ. ಆದಾಗ್ಯೂ, ನೀವು ಪ್ರತಿಯೊಬ್ಬರೂ ಪ್ರವೇಶವನ್ನು ಹೊಂದಲು ಬಯಸಿದರೆ, cron.deny ಕಡತವನ್ನು ರಚಿಸಿ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಯಾರಿಗೂ ಪ್ರವೇಶವನ್ನು ನಿರಾಕರಿಸಲಾಗುವುದಿಲ್ಲ.

It is often useful for root to run jobs as a different user without having to switch users (for example, using the su command). Most Linux dialects provide a mechanism in the form of the /etc/crontab file. This file is typically only writable by root and in some cases, only root can read it (which is often necessary in high security environments). The general syntax is the same as the standard crontabs, with a couple of exceptions.

ಮೊದಲ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಹೆಡರ್, ಇದನ್ನು ನೀವು ಇಲ್ಲಿ ನೋಡಬಹುದುಃ


ಎಸ್. ಎಚ್. ಇ. ಎಲ್. ಎಲ್. =/ಬಿನ್/ಎಸ್.
ಪಥ್ =/ಯು. ಎಸ್. ಆರ್/ಬಿನ್ಃ/ಯು. ಎಸ್. ಆರ್/ಎಸ್. ಬಿನ್ಃ/ಎಸ್. ಬಿನ್ಃ/ಯು. ಎಸ್. ಆರ್/ಲಿಬ್/ನ್ಯೂಸ್/ಬಿನ್
ಮೈಲ್ಟೊ = root
#
#ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು cron.hourly, cron.daily, cron.weekly, ಮತ್ತು cron.monthly ನಲ್ಲಿ ಪರಿಶೀಲಿಸಿ.
#

59 * * * * root rm -f /var/spool/cron/lastrun/cron.hourly
14 0 * * * root rm -f /var/spool/cron/lastrun/cron.daily
29 0 * * 6 root rm -f /var/spool/cron/lastrun/cron.weekly
44 0 1 * * root rm -f /var/spool/cron/lastrun/cron.monthly

ಎಸ್. ಎಚ್. ಇ. ಎಲ್. ಎಲ್. ವೇರಿಯೇಬಲ್ ಪ್ರತಿ ಕಮಾಂಡ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಶೆಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಪಿಎಚ್. ಎಚ್ ವೇರಿಯೇಬಲ್ ಸಾಮಾನ್ಯ ಪಿಎಚ್ ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯೇಬಲ್ನಂತೆಯೇ ಇರುತ್ತದೆ ಮತ್ತು ಹುಡುಕಾಟದ ಮಾರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ದೋಷ ಸಂದೇಶಗಳು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಆಜ್ಞೆಗಳ ಪ್ರಮಾಣಿತ ಔಟ್ಪುಟ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಇಮೇಲ್ ಸಂದೇಶಗಳನ್ನು ಯಾರು ಪಡೆಯಬೇಕು ಎಂದು ಮೈಲ್ಟೋ ವೇರಿಯೇಬಲ್ ಹೇಳುತ್ತದೆ.

The structure of the actual entries is pretty much the same with the exception of the user name (root in each case here). This way, the root users (or whoever can edit /etc/crontab) can define which user executes the command. Keep in mind that this can be a big security hole. If someone can write to this file, they can create an entry that runs as root and therefore has complete control of the system.

ಕ್ರಾನ್ "ಸೂಟ್" ನಲ್ಲಿರುವ ಮುಂದಿನ ಆಜ್ಞೆಯು ಅ. ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಮಯದಲ್ಲಿ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಇದರ ಕಾರ್ಯವಾಗಿದೆ. ವ್ಯತ್ಯಾಸವೆಂದರೆ ಒಮ್ಮೆ ಅಟ್ ಜಾಬ್ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ, ಅದು ವ್ಯವಸ್ಥೆಯಿಂದ ಕಣ್ಮರೆಯಾಗುತ್ತದೆ. ಕ್ರಾನ್ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ಎರಡು ಕಡತಗಳು, at.allow ಮತ್ತು at.deny, ಅಟ್ ಪ್ರೋಗ್ರಾಂನ ಮೇಲೆ ಅದೇ ಪರಿಣಾಮವನ್ನು ಬೀರುತ್ತವೆ.

ಬ್ಯಾಚ್ ಕಮಾಂಡ್ ಅನ್ನು ಒಮ್ಮೆ ಕಮಾಂಡ್ಗಳನ್ನು ಚಲಾಯಿಸಲು ಸಹ ಬಳಸಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಬ್ಯಾಚ್ನೊಂದಿಗೆ ಸಲ್ಲಿಸಿದ ಕಮಾಂಡ್ಗಳು ಸಿಸ್ಟಮ್ಗೆ ಬಂದಾಗ ರನ್ ಆಗುತ್ತವೆ, ಅಂದರೆ ಸಿಸ್ಟಮ್ ಕಡಿಮೆ ಕಾರ್ಯನಿರತವಾಗಿರುವಾಗ, ಉದಾಹರಣೆಗೆ, ಮಧ್ಯರಾತ್ರಿಯಲ್ಲಿ. ಅಂತಹ ಕೆಲಸಗಳು ಸಿಸ್ಟಮ್ನ ಲೋಡ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ಇಡೀ ದಿನ ವ್ಯಾಪಿಸುವ ಸಾಧ್ಯತೆಯಿದೆ.

ಗಮನಿಸಬೇಕಾದ ಒಂದು ವಿಷಯವೆಂದರೆ ಅಟ್ ಮತ್ತು ಬ್ಯಾಚ್ನ ನಡವಳಿಕೆ. ಎರಡೂ ಕಮಾಂಡ್ ಲೈನ್ನಿಂದ ಕಮಾಂಡ್ಗಳ ಹೆಸರುಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ ಮತ್ತು ಕಮಾಂಡ್ಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳಾಗಿ ಅಲ್ಲ. ನೀವು ಮೊದಲು ಕಮಾಂಡ್ ಅನ್ನು ಹೊಸ ಸಾಲಿಗೆ ತರಬೇಕು, ಅಲ್ಲಿ ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸುವ ಕಮಾಂಡ್ಗಳನ್ನು ಇನ್ಪುಟ್ ಮಾಡುತ್ತೀರಿ. ಪ್ರತಿ ಕಮಾಂಡ್ ನಂತರ, ಎಂಟರ್ ಒತ್ತಿರಿ. ನೀವು ಪೂರ್ಣಗೊಳಿಸಿದಾಗ, ಸಿ. ಟಿ. ಆರ್. ಎಲ್-ಡಿ ಒತ್ತಿರಿ.

ಈ ಎರಡು ಆಜ್ಞೆಗಳು ಎಸ್. ಟಿ. ಡಿ. ಐ. ಎನ್ ನಿಂದ ಆಜ್ಞೆಗಳನ್ನು ಸ್ವೀಕರಿಸುವುದರಿಂದ, ನೀವು ಪ್ರತಿ ಬಾರಿಯೂ ಹೊಸ ಸಾಲಿನಲ್ಲಿ ಆಜ್ಞೆಯನ್ನು ಇನ್ಪುಟ್ ಮಾಡಬಹುದು. ಒಂದು ಸಾಧ್ಯತೆಯೆಂದರೆ ಕಡತದಿಂದ ಇನ್ಪುಟ್ ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸುವುದು. ಉದಾಹರಣೆಗೆ


ಈಗ + 1 ಗಂಟೆ <ಕಮಾಂಡ್ _ ಲಿಸ್ಟ್


ಅಲ್ಲಿ ಕಮಾಂಡ್ ಲಿಸ್ಟ್ ಎಂಬುದು ಕಮಾಂಡ್ಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿರುವ ಕಡತವಾಗಿದೆ. ನೀವು ಪೈಪ್ನ ಕೊನೆಯಲ್ಲಿ (ಅಥವಾ ಬ್ಯಾಚ್) ಅನ್ನು ಸಹ ಹೊಂದಿರಬಹುದು.


ಕ್ಯಾಟ್ ಕಮಾಂಡ್ ಲಿಸ್ಟ್ | ಈಗ + 1 ಗಂಟೆ

ಕ್ಯಾಟ್ ಕಮಾಂಡ್ ಲಿಸ್ಟ್ | ಬ್ಯಾಚ್

Another interesting thing about both at and batch is that they create a kind of shell script to execute your command. When you run at or batch, a file is created in /usr/spool/cron/atjobs. This file contains the system variables that you would normally have defined, plus some other information that is contained in /usr/lib/cron.proto. This essentially creates an environment as though you had logged in.