La klasikaĵo skribis ke feliĉaj horoj ne rigardas. En tiuj sovaĝaj tempoj ekzistis nek programistoj nek Unikso, sed hodiaŭ programistoj certe scias: cron konservos tempon anstataŭ ili.

Komandliniaj utilecoj estas kaj malforto kaj tasko por mi. sed, awk, wc, cut kaj aliaj malnovaj programoj estas rulitaj per skriptoj en niaj serviloj ĉiutage. Multaj el ili estas desegnitaj kiel taskoj por cron, planilo originale de la 70-aj jaroj.

Longe mi uzis cron supraĵe, sen eniri detalojn, sed iun tagon, kiam mi renkontis eraron dum rulado de skripto, mi decidis detale esplori ĝin. Tiel aperis ĉi tiu artikolo, skribante ĝin mi konatiĝis kun POSIX crontab, la ĉefaj cron-opcioj en popularaj Linuksaj distribuoj kaj la strukturo de kelkaj el ili.

Ĉu vi uzas Linukson kaj rulas cron-taskojn? Ĉu vi interesiĝas pri sistema aplika arkitekturo en Unikso? Tiam ni estas survoje!

Enhavo

Origino de specioj
POSIX crontab
Plej vendisto - Vixie cron 3.0pl1
cron sur Debian kaj Ubuntu
kunulo sur Red Hat, Fedora kaj CentOS
kunulo en SLES kaj openSUSE
Vixie cron-aparato
Antaŭparolo

Origino de specioj

Perioda ekzekuto de uzant- aŭ sistemprogramoj estas evidenta neceso en ĉiuj operaciumoj. Tial programistoj antaŭ longe rimarkis la bezonon de servoj, kiuj ebligas al ili centre plani kaj efektivigi taskojn.

Unikso-similaj operaciumoj spuras siajn originojn reen al Versio 7 Unikso, evoluigita en la 70-aj jaroj de la lasta jarcento ĉe Bell Labs, inkluzive de la fama Ken Thompson. Versio 7 Unikso ankaŭ inkludis cron, servon por regule ruli superuzanttaskojn.

Tipa moderna cron estas simpla programo, sed la operacia algoritmo de la originala versio estis eĉ pli simpla: la servo vekiĝis unufoje ĉiuminute, legis tabelon kun taskoj el ununura dosiero (/etc/lib/crontab) kaj plenumis por la superuzanto tiuj taskoj kiuj devus esti plenumitaj en la nuna momento.

Poste, plibonigitaj versioj de la simpla kaj utila servo estis liveritaj kun ĉiuj Unikso-similaj operaciumoj.

Ĝeneraligitaj priskriboj de la crontab-formato kaj la bazaj principoj de la funkciado de la utileco estis inkluditaj en la ĉefnormo de Unikso-similaj operaciumoj - POSIX - en 1992, kaj tiel cron de fakta normo iĝis laŭjure normo.

En 1987, Paul Vixie, enketinte Uniksajn uzantojn pri iliaj deziroj pri cron, publikigis alian version de la demono kiu korektis kelkajn el la problemoj de tradicia cron kaj vastigis la sintakson de tabeldosieroj.

Per la tria versio de Vixie cron komencis plenumi POSIX-postulojn, krome, la programo havis liberalan permesilon, aŭ pli ĝuste tute ne estis permesilo, krom la deziroj en la README: la aŭtoro ne donas garantiojn, la nomo de la aŭtoro. ne povas esti forigita, kaj la programo povas esti vendita nur kune kun fontkodo. Ĉi tiuj postuloj montriĝis kongruaj kun la principoj de libera programaro kiu akiris popularecon en tiuj jaroj, do kelkaj el la ŝlosilaj Linukso-distribuoj kiuj aperis komence de la 90-aj jaroj prenis Vixie cron kiel sian sistemon kaj daŭre evoluigas ĝin hodiaŭ.

Aparte, Red Hat kaj SUSE evoluigas forkon de Vixie cron - cronie, kaj Debian kaj Ubuntu uzas la originan eldonon de Vixie cron kun multaj flikoj.

Ni unue konatiĝu kun la uzant-utilo crontab priskribita en POSIX, post kio ni rigardos la sintaksajn etendaĵojn provizitajn en Vixie cron kaj la uzon de variaĵoj de Vixie cron en popularaj Linuksaj distribuoj. Kaj finfine, la ĉerizo sur la kuko estas la analizo de la cron daemon-aparato.

POSIX crontab

Se la origina cron ĉiam funkciis por la superuzanto, modernaj planistoj ofte traktas taskojn de ordinaraj uzantoj, kio estas pli sekura kaj oportuna.

Crons estas liveritaj kiel aro de du programoj: la konstante kuranta cron-demono kaj la crontab ilo disponebla por uzantoj. Ĉi-lasta permesas redakti taskotabelojn specifajn por ĉiu uzanto en la sistemo, dum la demono lanĉas taskojn de uzanto kaj sistemaj tabeloj.

В POSIX-normo la konduto de la demono neniel estas priskribita kaj nur la uzantprogramo estas formaligita kroniko. La ekzisto de mekanismoj por lanĉi uzanttaskojn estas kompreneble subkomprenata, sed ne detale priskribita.

Vokante la ilon crontab, vi povas fari kvar aferojn: redakti la taskotabelon de uzanto en la redaktilo, ŝargi tabelon el dosiero, montri la nunan taskotabelon kaj malplenigi la taskotabelon. Ekzemploj de kiel funkcias la ilo crontab:

crontab -e # редактировать таблицу задач
crontab -l # показать таблицу задач
crontab -r # удалить таблицу задач
crontab path/to/file.crontab # загрузить таблицу задач из файла

Kiam oni vokas crontab -e la redaktilo specifita en la norma mediovariablo estos uzata EDITOR.

La taskoj mem estas priskribitaj en la sekva formato:

# строки-комментарии игнорируются
#
# задача, выполняемая ежеминутно
* * * * * /path/to/exec -a -b -c
# задача, выполняемая на 10-й минуте каждого часа
10 * * * * /path/to/exec -a -b -c
# задача, выполняемая на 10-й минуте второго часа каждого дня и использующая перенаправление стандартного потока вывода
10 2 * * * /path/to/exec -a -b -c > /tmp/cron-job-output.log

La unuaj kvin kampoj de la registroj: minutoj [1..60], horoj [0..23], tagoj de la monato [1..31], monatoj [1..12], tagoj de la semajno [0. .6], kie 0 estas dimanĉo. La lasta, sesa, kampo estas linio kiu estos ekzekutita de la norma komanda interpretisto.

En la unuaj kvin kampoj, valoroj povas esti listigitaj apartigitaj per komoj:

# задача, выполняемая в первую и десятую минуты каждого часа
1,10 * * * * /path/to/exec -a -b -c

Aŭ kun streketo:

# задача, выполняемая в каждую из первых десяти минут каждого часа
0-9 * * * * /path/to/exec -a -b -c

Uzanta aliro al taskoplanado estas reguligita en POSIX per la cron.allow kaj cron.deny dosieroj, kiuj listigas uzantojn kun aliro al crontab kaj uzantoj sen aliro al la programo, respektive. La normo neniel reguligas la lokon de ĉi tiuj dosieroj.

Laŭ la normo, almenaŭ kvar mediovariabloj devas esti pasitaj al lanĉitaj programoj:

HOME - hejma dosierujo de uzanto.
LOGNAME — uzanta ensaluto.
PATH estas la vojo, kie vi povas trovi normajn sistemajn ilojn.
SHELL — vojo al la uzata komanda interpretilo.

Precipe, POSIX diras nenion pri de kie venas la valoroj por ĉi tiuj variabloj.

Plej vendisto - Vixie cron 3.0pl1

La komuna prapatro de popularaj cron-variaĵoj estas Vixie cron 3.0pl1, lanĉita en la dissendolisto comp.sources.unix en 1992. Ni konsideros la ĉefajn trajtojn de ĉi tiu versio pli detale.

Vixie cron venas en du programoj (cron kaj crontab). Kiel kutime, la demono respondecas pri legado kaj prizorgado de taskoj de la sistema taskotabelo kaj individuaj uzanttaskaj tabeloj, kaj la crontab ilo respondecas pri redaktado de uzanttabeloj.

Taskotabelo kaj agordaj dosieroj

La superuzanta taskotabelo troviĝas en /etc/crontab. La sintakso de la sistema tabelo respondas al la sintakso de Vixie cron, kun la escepto ke la sesa kolumno en ĝi indikas la nomon de la uzanto sub kies nomo la tasko estas lanĉita:

# Запускается ежеминутно от пользователя vlad
* * * * * vlad /path/to/exec

Regulaj uzanttaskaj tabeloj troviĝas en /var/cron/tabs/username kaj uzas la saman sintakson. Kiam vi rulas la ilon crontab kiel uzanto, ĉi tiuj estas la dosieroj redaktitaj.

La listoj de uzantoj kun aliro al crontab estas administritaj en la dosieroj /var/cron/allow kaj /var/cron/deny, kie vi nur bezonas enigi la uzantnomon en aparta linio.

Etendita sintakso

Kompare kun POSIX crontab, la solvo de Paul Vixey enhavas plurajn tre utilajn modifojn al la sintakso de la taskotabeloj de la utileco.

Nova tabelsintakso fariĝis havebla: ekzemple, vi povas specifi tagojn de la semajno aŭ monatoj laŭ nomo (lun, mar, ktp):

# Запускается ежеминутно по понедельникам и вторникам в январе
* * * Jan Mon,Tue /path/to/exec

Vi povas specifi la paŝon per kiu taskoj estas lanĉitaj:

# Запускается с шагом в две минуты
*/2 * * * Mon,Tue /path/to/exec

Paŝoj kaj intervaloj povas esti miksitaj:

# Запускается с шагом в две минуты в первых десять минут каждого часа
0-10/2 * * * * /path/to/exec

Intuiciaj alternativoj al la kutima sintakso estas subtenataj (reboot, ĉiujare, ĉiujare, ĉiumonate, ĉiusemajne, ĉiutage, noktomezo, ĉiuhore):

# Запускается после перезагрузки системы
@reboot /exec/on/reboot
# Запускается раз в день
@daily /exec/daily
# Запускается раз в час
@hourly /exec/daily

Medio de ekzekuto de taskoj

Vixie cron permesas vin ŝanĝi la medion de rulado de aplikoj.

La mediovariabloj USER, LOGNAME kaj HOME ne estas simple provizitaj de la demono, sed estas prenitaj el dosiero pasvorto. La PATH-variablo estas agordita al "/usr/bin:/bin" kaj la SHELL-variablo estas agordita al "/bin/sh". La valoroj de ĉiuj variabloj krom LOGNAME povas esti ŝanĝitaj en uzanttabeloj.

Kelkaj mediovariabloj (plej precipe SHELL kaj HOME) estas uzataj de cron mem por ruli la taskon. Jen kiel povus aspekti uzi bash anstataŭ norma sh por ruli kutimajn taskojn:

SHELL=/bin/bash
HOME=/tmp/
# exec будет запущен bash-ем в /tmp/
* * * * * /path/to/exec

Finfine, ĉiuj mediovariabloj difinitaj en la tabelo (uzitaj de cron aŭ bezonataj de la procezo) estos transdonitaj al la funkcianta tasko.

Por redakti dosierojn, crontab uzas la redaktilon specifitan en la mediovariablo VISUAL aŭ EDITOR. Se la medio kie crontab estis rulita ne havas ĉi tiujn variablojn difinitaj, tiam "/usr/ucb/vi" estas uzata (ucb verŝajne estas la Universitato de Kalifornio, Berkeley).

cron sur Debian kaj Ubuntu

La programistoj de Debian kaj derivitaj distribuoj publikigis tre modifita versio Vixie cron versio 3.0pl1. Ne estas diferencoj en la sintakso de tabeldosieroj; por uzantoj ĝi estas la sama Vixie cron. Plej granda Nova Trajto: Subteno syslog, SELinux и PAM.

Malpli rimarkindaj, sed percepteblaj ŝanĝoj inkluzivas la lokon de agordaj dosieroj kaj taskotabeloj.

Uzanttabeloj en Debian troviĝas en la dosierujo /var/spool/cron/crontabs, la sistema tabelo ankoraŭ estas tie - en /etc/crontab. Debian-specifaj taskotabeloj estas metitaj en /etc/cron.d, de kie la cron-demono aŭtomate legas ilin. Uzanta alirkontrolo estas regata de la dosieroj /etc/cron.allow kaj /etc/cron.deny.

La defaŭlta ŝelo daŭre estas /bin/sh, kiu en Debiano estas malgranda POSIX-konforma ŝelo paŭzostreko, lanĉita sen legi ajnan agordon (en ne-interaga reĝimo).

Cron mem en la plej novaj versioj de Debian estas lanĉita per systemd, kaj la lanĉa agordo videblas en /lib/systemd/system/cron.service. Estas nenio speciala en la servo-agordo; pli subtila tasko-administrado povas esti farita per medio-variabloj deklaritaj rekte en la crontab de ĉiu uzanto.

amikino sur RedHat, Fedora kaj CentOS

amiko — forko de Vixie cron versio 4.1. Kiel en Debian, la sintakso ne ŝanĝiĝis, sed subteno por PAM kaj SELinux, laborado en areto, spurado de dosieroj per inotify kaj aliaj funkcioj estis aldonita.

La defaŭlta agordo estas en la kutimaj lokoj: la sistema tablo estas en /etc/crontab, pakaĵoj metas siajn tabelojn en /etc/cron.d, uzanttabeloj iras en /var/spool/cron/crontabs.

La demono funkcias sub systemd-kontrolo, la servo-agordo estas /lib/systemd/system/crond.service.

Ĉe Red Hat-similaj distribuoj, /bin/sh estas uzata defaŭlte ĉe ekfunkciigo, kio estas la norma bash. Oni devas rimarki, ke dum rulado de cron-laboroj per /bin/sh, la bash-ŝelo komenciĝas en POSIX-konforma reĝimo kaj ne legas ajnan kroman agordon, funkciante en ne-interaga reĝimo.

kunulo en SLES kaj openSUSE

La germana distribuo SLES kaj ĝia derivaĵo openSUSE uzas la saman akompananton. La demono ĉi tie ankaŭ estas lanĉita sub systemd, la servo-agordo troviĝas en /usr/lib/systemd/system/cron.service. Agordo: /etc/crontab, /etc/cron.d, /var/spool/cron/tabs. /bin/sh estas la sama bash funkcianta en POSIX-konforma ne-interaga reĝimo.

Vixie cron-aparato

Modernaj posteuloj de cron ne ŝanĝiĝis radikale kompare kun Vixie cron, sed ankoraŭ akiris novajn funkciojn, kiuj ne estas postulataj por kompreni la principojn de la programo. Multaj el ĉi tiuj etendaĵoj estas malbone dezajnitaj kaj konfuzas la kodon. La originala cron fontkodo de Paul Vixey estas plezure legi.

Tial, mi decidis analizi la cron-aparaton uzante la ekzemplon de cron-programo komuna al ambaŭ branĉoj de evoluo - Vixie cron 3.0pl1. Mi simpligos la ekzemplojn per forigo de ifdefs kiuj malfaciligas la legadon kaj preterlasante etajn detalojn.

La laboro de la demono povas esti dividita en plurajn stadiojn:

Inicialigo de programo.
Kolekti kaj ĝisdatigi la liston de rulotaj taskoj.
Ĉefa cron buklo kuras.
Komencu taskon.

Ni rigardu ilin en ordo.

Inicialigo

Kiam komencite, post kontrolado de la procezaj argumentoj, cron instalas la SIGCHLD kaj SIGHUP-signaltraktiloj. La unua faras protokolan enskribon pri la fino de la infana procezo, la dua fermas la dosierpriskribilon de la protokolo:

signal(SIGCHLD, sigchld_handler);
signal(SIGHUP, sighup_handler);

La cron-demono ĉiam funkcias sole en la sistemo, nur kiel superuzanto kaj de la ĉefa cron-dosierujo. La sekvaj alvokoj kreas ŝlosildosieron kun la PID de la demona procezo, certigu, ke la uzanto estas ĝusta kaj ŝanĝu la nunan dosierujon al la ĉefa:

acquire_daemonlock(0);
set_cron_uid();
set_cron_cwd();

La defaŭlta vojo estas agordita, kiu estos uzata dum komencado de procezoj:

setenv("PATH", _PATH_DEFPATH, 1);

Tiam la procezo estas "demonigita": ĝi kreas infanan kopion de la procezo per vokado de forko kaj nova sesio en la infana procezo (vokante setsid). La gepatra procezo ne plu bezonas, kaj ĝi eliras:

switch (fork()) {
case -1:
    /* критическая ошибка и завершение работы */
    exit(0);
break;
case 0:
    /* дочерний процесс */
    (void) setsid();
break;
default:
    /* родительский процесс завершает работу */
    _exit(0);
}

Finiĝo de la gepatra procezo liberigas la seruron sur la ŝlosildosiero. Krome, necesas ĝisdatigi la PID en la dosiero al la infano. Post tio, la taskodatumbazo estas plenigita:

/* повторный захват лока */
acquire_daemonlock(0);

/* Заполнение БД  */
database.head = NULL;
database.tail = NULL;
database.mtime = (time_t) 0;
load_database(&database);

Tiam cron moviĝas al la ĉefa laborciklo. Sed antaŭ tio, indas rigardi ŝarĝi la taskoliston.

Kolekti kaj ĝisdatigi la taskoliston

La funkcio load_database respondecas pri ŝarĝo de la listo de taskoj. Ĝi kontrolas la ĉefan sisteman crontab kaj la dosierujon kun uzantdosieroj. Se la dosieroj kaj dosierujo ne ŝanĝiĝis, la taskolisto ne estas relegata. Alie, nova listo de taskoj komencas formiĝi.

Ŝargante sisteman dosieron kun specialaj nomoj de dosieroj kaj tabeloj:

/* если файл системной таблицы изменился, перечитываем */
if (syscron_stat.st_mtime) {
    process_crontab("root", "*system*",
    SYSCRONTAB, &syscron_stat,
    &new_db, old_db);
}

Ŝargante uzanttablojn en buklo:

while (NULL != (dp = readdir(dir))) {
    char    fname[MAXNAMLEN+1],
            tabname[MAXNAMLEN+1];
    /* читать файлы с точкой не надо*/
    if (dp->d_name[0] == '.')
            continue;
    (void) strcpy(fname, dp->d_name);
    sprintf(tabname, CRON_TAB(fname));
    process_crontab(fname, fname, tabname,
                    &statbuf, &new_db, old_db);
}

Post tio la malnova datumbazo estas anstataŭigita per nova.

En la supraj ekzemploj, la alvoko de funkcio process_crontab kontrolas ke uzanto kongrua kun la tabeldosiernomo ekzistas (krom se ĝi estas superuzanto) kaj poste vokas load_user. Ĉi-lasta jam legas la dosieron mem linio post linio:

while ((status = load_env(envstr, file)) >= OK) {
    switch (status) {
    case ERR:
        free_user(u);
        u = NULL;
        goto done;
    case FALSE:
        e = load_entry(file, NULL, pw, envp);
        if (e) {
            e->next = u->crontab;
            u->crontab = e;
        }
        break;
    case TRUE:
        envp = env_set(envp, envstr);
        break;
    }
}

Ĉi tie, aŭ la mediovariablo estas agordita (linioj de la formo VAR=valoro) uzante la funkciojn load_env / env_set, aŭ la taskopriskribo estas legata (* * * * * /path/to/exec) uzante la funkcion load_entry.

La enira ento, kiun liveras load_entry, estas nia tasko, kiu estas metita en la ĝeneralan liston de taskoj. La funkcio mem faras multvortan analizadon de la tempoformato, sed ni pli interesiĝas pri la formado de mediovariabloj kaj taskaj lanĉaj parametroj:

/* пользователь и группа для запуска задачи берутся из passwd*/
e->uid = pw->pw_uid;
e->gid = pw->pw_gid;

/* шелл по умолчанию (/bin/sh), если пользователь не указал другое */
e->envp = env_copy(envp);
if (!env_get("SHELL", e->envp)) {
    sprintf(envstr, "SHELL=%s", _PATH_BSHELL);
    e->envp = env_set(e->envp, envstr);
}
/* домашняя директория */
if (!env_get("HOME", e->envp)) {
    sprintf(envstr, "HOME=%s", pw->pw_dir);
    e->envp = env_set(e->envp, envstr);
}
/* путь для поиска программ */
if (!env_get("PATH", e->envp)) {
    sprintf(envstr, "PATH=%s", _PATH_DEFPATH);
    e->envp = env_set(e->envp, envstr);
}
/* имя пользовтеля всегда из passwd */
sprintf(envstr, "%s=%s", "LOGNAME", pw->pw_name);
e->envp = env_set(e->envp, envstr);

La ĉefa buklo funkcias kun la nuna listo de taskoj.

Ĉefa Buklo

La origina cron de Versio 7 Unikso funkciis tute simple: ĝi relegis la agordon en buklo, lanĉis la taskojn de la nuna minuto kiel superuzanto, kaj dormis ĝis la komenco de la sekva minuto. Ĉi tiu simpla aliro sur pli malnovaj maŝinoj postulis tro multajn rimedojn.

Alternativa versio estis proponita en SysV, en kiu la demono iris dormi aŭ ĝis la plej proksima minuto por kiu la tasko estis difinita, aŭ dum 30 minutoj. Malpli da rimedoj estis konsumitaj por relegado de la agordo kaj kontrolado de taskoj en ĉi tiu reĝimo, sed rapide ĝisdatigi la liston de taskoj fariĝis maloportuna.

Vixie cron revenis por kontroli taskolistojn unufoje ĉiuminute, feliĉe antaŭ la fino de la 80-aj jaroj ekzistis signife pli da rimedoj sur normaj Uniksaj maŝinoj:

/* первичная загрузка задач */
load_database(&database);
/* запустить задачи, поставленные к выполнению после перезагрузки системы */
run_reboot_jobs(&database);
/* сделать TargetTime началом ближайшей минуты */
cron_sync();
while (TRUE) {
    /* выполнить задачи, после чего спать до TargetTime с поправкой на время, потраченное на задачи */
    cron_sleep();

    /* перечитать конфигурацию */
    load_database(&database);

    /* собрать задачи для данной минуты */
    cron_tick(&database);

    /* перевести TargetTime на начало следующей минуты */
    TargetTime += 60;
}

La funkcio cron_sleep estas rekte implikita en plenumado de taskoj, vokante la funkciojn job_runqueue (nombri kaj ruli taskojn) kaj do_command (funkciigi ĉiun individuan taskon). La lasta funkcio estas ekzameninda pli detale.

Kurante taskon

La funkcio do_command estas ekzekutita en bona Unikso-stilo, tio estas, ĝi faras forkon por plenumi la taskon nesinkrone. La gepatra procezo daŭre lanĉas taskojn, la infana procezo preparas la taskoprocezon:

switch (fork()) {
case -1:
    /*не смогли выполнить fork */
    break;
case 0:
    /* дочерний процесс: на всякий случай еще раз пробуем захватить главный лок */
    acquire_daemonlock(1);
    /* переходим к формированию процесса задачи */
    child_process(e, u);
    /* по завершению дочерний процесс заканчивает работу */
    _exit(OK_EXIT);
    break;
default:
    /* родительский процесс продолжает работу */
    break;
}

Estas sufiĉe multe da logiko en child_process: ĝi akceptas normajn produktaĵojn kaj erarfluojn, poste sendas ilin al poŝto (se la MAILTO-medivariablo estas specifita en la taskotabelo), kaj, finfine, atendas ke la ĉefa procezo de la tasko estos specifita. kompleta.

La taskoprocezo estas formita per alia forko:

switch (vfork()) {
case -1:
    /* при ошибки сразу завершается работа */
    exit(ERROR_EXIT);
case 0:
    /* процесс-внук формирует новую сессию, терминал и т.д.
     */
    (void) setsid();

    /*
     * дальше многословная настройка вывода процесса, опустим для краткости
     */

    /* смена директории, пользователя и группы пользователя,
     * то есть процесс больше не суперпользовательский
     */
    setgid(e->gid);
    setuid(e->uid);
    chdir(env_get("HOME", e->envp));

    /* запуск самой команды
     */
    {
        /* переменная окружения SHELL указывает на интерпретатор для запуска */
        char    *shell = env_get("SHELL", e->envp);

        /* процесс запускается без передачи окружения родительского процесса,
         * то есть именно так, как описано в таблице задач пользователя  */
        execle(shell, shell, "-c", e->cmd, (char *)0, e->envp);

        /* ошибка — и процесс на запустился? завершение работы */
        perror("execl");
        _exit(ERROR_EXIT);
    }
    break;
default:
    /* сам процесс продолжает работу: ждет завершения работы и вывода */
    break;
}

Tio estas esence ĉio cron estas. Mi preterlasis kelkajn interesajn detalojn, ekzemple, pri kontado de foraj uzantoj, sed mi skizis la ĉefan aferon.

Antaŭparolo

Cron estas surprize simpla kaj utila programo, farita en la plej bonaj tradicioj de la Unikso-simila mondo. Ŝi faras nenion kroman, sed ŝi faras sian laboron mirinde dum pluraj jardekoj nun. Trapasi la kodon por la versio kiu venas kun Ubuntu daŭris ne pli ol unu horon, kaj mi multe amuziĝis! Mi esperas, ke mi povis dividi ĝin kun vi.

Mi ne scias pri vi, sed mi iom malĝojas konstati, ke moderna programado, kun sia tendenco tro kompliki kaj tro abstrakti, delonge ne favoras al tia simpleco.

Estas multaj modernaj alternativoj al cron: systemd-timers permesas organizi kompleksajn sistemojn kun dependecoj, fcron ebligas al vi pli flekseble reguligi resursan konsumon per taskoj. Sed persone, la plej simpla crontab ĉiam sufiĉis por mi.

Resume, amu Unikson, uzu simplajn programojn kaj ne forgesu legi la manaon por via platformo!

fonto: www.habr.com

Cron en Linukso: historio, uzo kaj aparato