Ansible Cron-Modul

AnsibleAnsibleIntermediate
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

Willkommen im Ansible Cron-Modul-Lab! In diesem Lab werden Sie lernen, wie Sie die Planung von Aufgaben mithilfe des Ansible Cron-Moduls automatisieren können. Das cron-System ist ein zeitbasierter Job-Scheduler in Unix-ähnlichen Betriebssystemen, der es Benutzern ermöglicht, Befehle oder Skripte so zu planen, dass sie automatisch zu bestimmten Zeiten oder in festgelegten Intervallen ausgeführt werden.

Durch dieses Lab werden Sie lernen, wie Sie mit Ansible cron-Jobs erstellen, verwalten und entfernen können. Die Übungen gehen von einfachen zu komplexeren Konfigurationen über, sodass Sie Ihre Fähigkeiten mit dem Ansible Cron-Modul schrittweise aufbauen können. Am Ende dieses Labs haben Sie praktische Erfahrungen in der konsistenten und automatisierten Planung von Aufgaben mit Ansible gesammelt.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL ansible(("Ansible")) -.-> ansible/ModuleOperationsGroup(["Module Operations"]) ansible(("Ansible")) -.-> ansible/PlaybookEssentialsGroup(["Playbook Essentials"]) ansible/ModuleOperationsGroup -.-> ansible/cron("Schedule Tasks") ansible/ModuleOperationsGroup -.-> ansible/shell("Execute Shell Commands") ansible/PlaybookEssentialsGroup -.-> ansible/playbook("Execute Playbook") subgraph Lab Skills ansible/cron -.-> lab-290157{{"Ansible Cron-Modul"}} ansible/shell -.-> lab-290157{{"Ansible Cron-Modul"}} ansible/playbook -.-> lab-290157{{"Ansible Cron-Modul"}} end

Erstellen eines einfachen cron-Jobs

In diesem Schritt werden Sie Ihren ersten cron-Job mithilfe des Ansible Cron-Moduls erstellen. Der cron-Job wird ein einfaches Shell-Skript in regelmäßigen Abständen ausführen.

Grundlagen von cron

Bevor wir beginnen, lernen wir zunächst, was cron ist. Cron ist ein zeitbasierter Job-Scheduler in Unix-ähnlichen Betriebssystemen, der es Benutzern ermöglicht, Befehle oder Skripte so zu planen, dass sie automatisch zu bestimmten Zeiten oder in festgelegten Intervallen ausgeführt werden. Cron-Jobs eignen sich hervorragend für die Automatisierung von Systemwartungsaufgaben, Backups oder anderen wiederkehrenden Aufgaben.

Erstellen des Ansible-Playbooks

Zunächst müssen Sie ein Ansible-Playbook erstellen, das den cron-Job einrichtet. Im WebIDE erstellen Sie eine neue Datei unter dem Pfad /home/labex/project/cron_module_playbook.yaml, indem Sie auf die Schaltfläche "Neue Datei" im Dateiexplorer klicken.

Neue Datei

Geben Sie den folgenden Inhalt in die Datei ein:

- hosts: localhost
  tasks:
    - name: Create a simple cron job
      cron:
        name: my_cron_job
        minute: "*/5"
        job: /home/labex/project/script.sh

Lassen Sie uns jeden Teil dieses Playbooks untersuchen:

  • hosts: localhost - Dies gibt an, dass das Playbook auf dem lokalen Rechner ausgeführt wird.
  • tasks - Dieser Abschnitt enthält die Liste der auszuführenden Aufgaben.
  • cron - Dies ist das Ansible-Modul zur Verwaltung von cron-Jobs.
  • name: my_cron_job - Dies legt einen beschreibenden Namen für den cron-Job fest, der ihn im crontab leichter identifizierbar macht.
  • minute: "*/5" - Dies plant die Ausführung des Jobs alle 5 Minuten. Die Syntax */5 bedeutet "alle Minuten, die durch 5 teilbar sind" (0, 5, 10, 15 usw.).
  • job: /home/labex/project/script.sh - Dies gibt den Befehl oder das Skript an, das vom cron-Job ausgeführt werden soll.

Erstellen des Shell-Skripts

Jetzt müssen Sie das Shell-Skript erstellen, das der cron-Job ausführen wird. Erstellen Sie im WebIDE eine neue Datei unter dem Pfad /home/labex/project/script.sh.

Geben Sie den folgenden Inhalt in die Skriptdatei ein:

#!/bin/bash
echo "This is a simple script." >> /home/labex/project/cron_output.log
date >> /home/labex/project/cron_output.log

Dieses einfache Skript fügt bei jeder Ausführung eine Nachricht und das aktuelle Datum in eine Protokolldatei ein.

Macht das Skript ausführbar

Bevor Sie das Playbook ausführen, müssen Sie das Skript ausführbar machen. Öffnen Sie ein Terminal im WebIDE und führen Sie den folgenden Befehl aus:

chmod +x /home/labex/project/script.sh

Ausführen des Ansible-Playbooks

Jetzt führen Sie das Ansible-Playbook aus, um den cron-Job zu erstellen. Führen Sie im Terminal den folgenden Befehl aus:

cd /home/labex/project
ansible-playbook cron_module_playbook.yaml

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Create a simple cron job] ************************************************
changed: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Die Zeile changed: [localhost] zeigt an, dass der cron-Job erfolgreich erstellt wurde.

Überprüfen des cron-Jobs

Um zu überprüfen, ob der cron-Job erstellt wurde, überprüfen Sie die crontab auf dem System mit dem folgenden Befehl:

crontab -l

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

#Ansible: my_cron_job
*/5 * * * * /home/labex/project/script.sh

Die Zeile #Ansible: my_cron_job ist ein Kommentar, der von Ansible hinzugefügt wurde, um den cron-Job zu identifizieren. Der Teil */5 * * * * repräsentiert die Planung (alle 5 Minuten), und /home/labex/project/script.sh ist der auszuführende Befehl.

Herzlichen Glückwunsch! Sie haben erfolgreich einen cron-Job mithilfe des Ansible Cron-Moduls erstellt. Der Job wird das Skript alle 5 Minuten ausführen.

Planen einer Aufgabe zu einer benutzerdefinierten Zeit

In diesem Schritt lernen Sie, wie Sie einen cron-Job so planen können, dass er zu einer bestimmten Zeit anstatt in regelmäßigen Intervallen ausgeführt wird. Dies ist nützlich für Aufgaben, die zu bestimmten Tageszeiten ausgeführt werden müssen, wie z. B. Backups, Datenverarbeitung oder das Generieren von Berichten.

Grundlagen des cron-Zeitformats

Das cron-Zeitformat besteht aus fünf Feldern, die Folgendes repräsentieren:

  1. Minute (0 - 59)
  2. Stunde (0 - 23)
  3. Tag des Monats (1 - 31)
  4. Monat (1 - 12)
  5. Wochentag (0 - 7, wobei sowohl 0 als auch 7 Sonntag repräsentieren)

Wenn Sie für jedes Feld einen Wert angeben, wird der cron-Job ausgeführt, wenn alle Bedingungen erfüllt sind. Beispielsweise bedeutet 0 9 * * *, dass der Job "täglich um 9:00 Uhr morgens" ausgeführt wird (Minute 0 der Stunde 9, an jedem Tag des Monats, in jedem Monat, an jedem Wochentag).

Anpassen des Ansible-Playbooks

Jetzt passen wir das vorhandene Playbook an, um einen neuen cron-Job zu erstellen, der zu einer bestimmten Zeit ausgeführt wird. Öffnen Sie die Datei /home/labex/project/cron_module_playbook.yaml im WebIDE und ersetzen Sie ihren Inhalt durch Folgendes:

- hosts: localhost
  tasks:
    - name: Schedule a task with custom time
      cron:
        name: custom_cron_job
        minute: "0"
        hour: "9"
        job: /home/labex/project/script.sh

Die Änderungen in diesem Playbook umfassen:

  • name: custom_cron_job - Wir erstellen einen neuen cron-Job mit einem anderen Namen.
  • minute: "0" - Dies legt fest, dass der Job zur vollen Stunde (Minute 0) ausgeführt wird.
  • hour: "9" - Dies legt fest, dass der Job um 9:00 Uhr morgens ausgeführt wird.

Die übrigen Felder (Tag des Monats, Monat, Wochentag) werden nicht angegeben, was bedeutet, dass sie standardmäßig auf * (beliebiger Wert) gesetzt sind. Dieser Job wird also täglich um 9:00 Uhr morgens ausgeführt.

Ausführen des angepassten Playbooks

Jetzt führen Sie das angepasste Ansible-Playbook aus, um den neuen cron-Job zu erstellen. Führen Sie im Terminal den folgenden Befehl aus:

cd /home/labex/project
ansible-playbook cron_module_playbook.yaml

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Schedule a task with custom time] ****************************************
changed: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Überprüfen des neuen cron-Jobs

Um zu überprüfen, ob der neue cron-Job erstellt wurde, überprüfen Sie die crontab auf dem System:

crontab -l

Sie sollten jetzt zwei cron-Jobs in der Ausgabe sehen:

#Ansible: my_cron_job
*/5 * * * * /home/labex/project/script.sh
#Ansible: custom_cron_job
0 9 * * * /home/labex/project/script.sh

Der erste Job ist der, den Sie in Schritt 1 erstellt haben und der alle 5 Minuten ausgeführt wird. Der zweite Job ist der neue, den Sie gerade erstellt haben und der täglich um 9:00 Uhr morgens ausgeführt wird.

Zusätzliche Beispiele für die cron-Planung

Hier sind einige zusätzliche Beispiele für die cron-Planung, um Ihnen das Verständnis des Zeitformats zu erleichtern:

  • 0 * * * * - Jede Stunde um die volle Stunde ausführen
  • 0 0 * * * - Täglich um Mitternacht ausführen
  • 0 0 1 * * - Am ersten Tag jedes Monats um Mitternacht ausführen
  • 0 0 * * 0 - Jeden Sonntag um Mitternacht ausführen
  • 0 12 * * 1-5 - An Wochentagen (Montag bis Freitag) um Mittag ausführen

Das Verständnis dieser Muster hilft Ihnen, Ihre Aufgaben effektiver mithilfe des Ansible Cron-Moduls zu planen.

Herzlichen Glückwunsch! Sie haben erfolgreich einen cron-Job mithilfe des Ansible Cron-Moduls zu einer bestimmten Zeit geplant.

Sicherstellen, dass ein cron-Job als bestimmter Benutzer ausgeführt wird

In diesem Schritt lernen Sie, wie Sie angeben können, als welcher Benutzer ein cron-Job ausgeführt werden soll. Dies ist ein wichtiger Aspekt der Systemadministration und Sicherheit, da es Ihnen ermöglicht, die Berechtigungen und die Umgebung zu kontrollieren, unter der geplante Aufgaben ausgeführt werden.

Grundlagen des Benutzerkontexts für cron-Jobs

In Unix-ähnlichen Systemen erben cron-Jobs die Berechtigungen und die Umgebung des Benutzers, der sie besitzt. Dies bedeutet:

  1. Der Job kann nur auf Dateien und Ressourcen zugreifen, auf die der Benutzer Zugriffsberechtigung hat.
  2. Der Job wird mit den Umgebungsvariablen und Einstellungen des Benutzers ausgeführt.
  3. Alle vom Job erstellten Dateien werden dem Benutzer gehören.

Standardmäßig wird, wenn Sie das Ansible Cron-Modul verwenden, ohne einen Benutzer anzugeben, der cron-Job für den Benutzer erstellt, der das Ansible-Playbook ausführt. Sie können jedoch explizit einen anderen Benutzer mit dem Parameter user festlegen.

Anpassen des Ansible-Playbooks

Lassen Sie uns unser Playbook anpassen, um anzugeben, dass der cron-Job als Benutzer labex ausgeführt werden soll. Öffnen Sie die Datei /home/labex/project/cron_module_playbook.yaml im WebIDE und ersetzen Sie ihren Inhalt durch Folgendes:

- hosts: localhost
  tasks:
    - name: Schedule a task with custom time for specific user
      cron:
        name: custom_cron_job
        minute: "0"
        hour: "9"
        job: /home/labex/project/script.sh
        user: labex

Die wichtigste Ergänzung hier ist:

  • user: labex - Dieser Parameter gibt an, dass der cron-Job für den Benutzer labex erstellt werden soll.

Auch wenn wir in dieser Umgebung bereits als Benutzer labex ausgeführt werden, ist es eine gute Praxis, ihn explizit festzulegen, um die Klarheit und Portabilität Ihrer Playbooks in andere Umgebungen zu gewährleisten.

Ausführen des angepassten Playbooks

Jetzt führen Sie das angepasste Ansible-Playbook aus, um den cron-Job zu aktualisieren. Führen Sie im Terminal den folgenden Befehl aus:

cd /home/labex/project
ansible-playbook cron_module_playbook.yaml

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Schedule a task with custom time for specific user] **********************
ok: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Beachten Sie, dass die Ausgabe ok anstelle von changed anzeigt. Dies liegt daran, dass der cron-Job bereits existiert und die einzige Änderung der Benutzerparameter ist, der in diesem Fall bereits korrekt ist (da wir von Anfang an als Benutzer labex ausgeführt werden).

Überprüfen des cron-Jobs

Um zu überprüfen, ob der cron-Job weiterhin ordnungsgemäß konfiguriert ist, überprüfen Sie die crontab:

crontab -l

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

#Ansible: my_cron_job
*/5 * * * * /home/labex/project/script.sh
#Ansible: custom_cron_job
0 9 * * * /home/labex/project/script.sh

Anzeigen der cron-Jobs für einen bestimmten Benutzer

Wenn Sie die cron-Jobs für einen bestimmten Benutzer anzeigen möchten, können Sie die Option -u mit dem Befehl crontab verwenden:

sudo crontab -u labex -l

Dieser Befehl zeigt alle für den Benutzer labex geplanten cron-Jobs an. In einer Produktionsumgebung können Sie möglicherweise verschiedene cron-Jobs als verschiedene Benutzer ausführen, je nach den erforderlichen Zugriffsebenen und Berechtigungen für jede Aufgabe.

Sicherheitsüberlegungen

Beachten Sie bei der Planung von cron-Jobs für verschiedene Benutzer die folgenden Sicherheitsverfahren:

  1. Verwenden Sie das Prinzip des geringsten Privilegs - weisen Sie cron-Jobs nur Benutzern zu, die die Berechtigungen haben, die sie für ihre Aufgaben benötigen.
  2. Vermeiden Sie es, Aufgaben als Benutzer root zu planen, es sei denn, es ist unbedingt erforderlich.
  3. Stellen Sie sicher, dass von cron-Jobs ausgeführte Skripte die entsprechenden Berechtigungen und Fehlerbehandlungen haben.
  4. Erwägen Sie die Verwendung von Konfigurationsverwaltungstools wie Ansible, um konsistente cron-Job-Einstellungen in Ihrer Infrastruktur aufrechtzuerhalten.

Herzlichen Glückwunsch! Sie haben erfolgreich einen cron-Job mithilfe des Ansible Cron-Moduls so konfiguriert, dass er als bestimmter Benutzer ausgeführt wird. Diese Fähigkeit wird Ihnen helfen, Systemaufgaben sicherer und effektiver zu verwalten.

Entfernen eines cron-Jobs

In diesem Schritt lernen Sie, wie Sie unerwünschte cron-Jobs mithilfe des Ansible Cron-Moduls entfernen können. Das Verwalten des gesamten Lebenszyklus von cron-Jobs ist eine wichtige Fähigkeit für Systemadministratoren und DevOps-Engineer.

Gründe für das Entfernen von cron-Jobs

Es gibt mehrere Gründe, warum Sie möglicherweise cron-Jobs entfernen müssen:

  1. Die geplante Aufgabe wird nicht mehr benötigt.
  2. Sie möchten einen bestehenden Job durch eine neue Konfiguration ersetzen.
  3. Sie müssen das System aufräumen, um die Wartbarkeit zu verbessern.
  4. Die Aufgabe muss vorübergehend deaktiviert werden.

Ansible erleichtert es Ihnen, cron-Jobs auf systematische und wiederholbare Weise in Ihrer gesamten Infrastruktur zu entfernen.

Grundlagen des state-Parameters

Das Ansible Cron-Modul verwendet den Parameter state, um zu steuern, ob ein cron-Job vorhanden oder nicht vorhanden sein soll:

  • state: present - Dies ist die Standardeinstellung. Sie stellt sicher, dass der cron-Job mit der angegebenen Konfiguration existiert.
  • state: absent - Dies stellt sicher, dass der cron-Job nicht existiert und entfernt ihn, falls er zuvor erstellt wurde.

Anpassen des Ansible-Playbooks

Lassen Sie uns unser Playbook anpassen, um den ersten von uns erstellten cron-Job (mit dem Namen my_cron_job) zu entfernen. Öffnen Sie die Datei /home/labex/project/cron_module_playbook.yaml im WebIDE und ersetzen Sie ihren Inhalt durch Folgendes:

- hosts: localhost
  tasks:
    - name: Remove the cron job
      cron:
        name: my_cron_job
        state: absent

Die wichtigsten Elemente dieses Playbooks sind:

  • name: my_cron_job - Dies identifiziert den zu entfernenden cron-Job anhand seines Namens.
  • state: absent - Dies teilt Ansible mit, sicherzustellen, dass der cron-Job nicht existiert.

Beachten Sie, dass wir nur den Namen des cron-Jobs angeben müssen, um ihn für die Entfernung zu identifizieren. Die anderen Parameter (wie Minute, Stunde, Job usw.) sind nicht erforderlich.

Ausführen des angepassten Playbooks

Jetzt führen Sie das angepasste Ansible-Playbook aus, um den cron-Job zu entfernen. Führen Sie im Terminal den folgenden Befehl aus:

cd /home/labex/project
ansible-playbook cron_module_playbook.yaml

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Remove the cron job] *****************************************************
changed: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Die Zeile changed: [localhost] gibt an, dass der cron-Job erfolgreich entfernt wurde.

Überprüfen der Entfernung des cron-Jobs

Um zu überprüfen, ob der cron-Job entfernt wurde, überprüfen Sie die crontab auf dem System:

crontab -l

Sie sollten jetzt nur den zweiten cron-Job in der Ausgabe sehen:

#Ansible: custom_cron_job
0 9 * * * /home/labex/project/script.sh

Der Eintrag my_cron_job wurde entfernt, wie in unserem Playbook angefordert.

Idempotenz in Ansible

Eines der wichtigsten Merkmale von Ansible ist die Idempotenz - die Eigenschaft, dass das mehrmalige Anwenden der gleichen Operation dasselbe Ergebnis liefert wie das einmalige Anwenden. Dies ist besonders nützlich für Aufgaben wie das Entfernen von cron-Jobs.

Lassen Sie uns das Playbook erneut ausführen, um dies zu demonstrieren:

ansible-playbook cron_module_playbook.yaml

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Remove the cron job] *****************************************************
ok: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Beachten Sie, dass beim zweiten Mal die Ausgabe für die Entfernungstask ok anstelle von changed anzeigt. Dies liegt daran, dass der cron-Job bereits entfernt wurde, sodass keine Änderungen erforderlich waren.

Verwalten mehrerer cron-Jobs

In realen Szenarien müssen Sie möglicherweise mehrere cron-Jobs in einem einzigen Playbook verwalten. Sie können mehrere cron-Tasks einschließen, jeder mit seiner eigenen Konfiguration:

- hosts: localhost
  tasks:
    - name: Remove first cron job
      cron:
        name: job1
        state: absent

    - name: Create second cron job
      cron:
        name: job2
        minute: "0"
        hour: "12"
        job: /path/to/script.sh

    - name: Update third cron job
      cron:
        name: job3
        minute: "*/10"
        job: /path/to/another/script.sh

Dieser Ansatz ermöglicht es Ihnen, den gesamten Lebenszyklus aller Ihrer cron-Jobs in einem einzigen, versionskontrollierten Playbook zu verwalten.

Herzlichen Glückwunsch! Sie haben erfolgreich gelernt, wie Sie cron-Jobs mithilfe des Ansible Cron-Moduls entfernen können. Damit ist die grundlegende Lebenszyklusverwaltung von cron-Jobs abgeschlossen: Erstellung, Modifikation und Entfernung.

Zusammenfassung

Herzlichen Glückwunsch, dass Sie das Lab zum Ansible Cron-Modul abgeschlossen haben! Im Laufe dieses Labs haben Sie praktische Erfahrungen in mehreren wichtigen Aspekten der Verwaltung von geplanten Aufgaben mit Ansible gesammelt:

  1. Das Erstellen einfacher cron-Jobs, die in regelmäßigen Abständen ausgeführt werden
  2. Das Planen von Aufgaben, die zu bestimmten Zeiten mithilfe benutzerdefinierter cron-Zeitausdrücke ausgeführt werden
  3. Das Sicherstellen, dass cron-Jobs als bestimmte Benutzer ausgeführt werden, um die richtige Sicherheit und Berechtigungsverwaltung zu gewährleisten
  4. Das Entfernen von cron-Jobs, die nicht mehr benötigt werden

Diese Fähigkeiten sind für die Automatisierung von Systemadministrationsaufgaben, Wartungsvorgängen und wiederkehrenden Prozessen in jeder Linux-Umgebung unerlässlich. Indem Sie Ansible zur Verwaltung Ihrer cron-Jobs verwenden, profitieren Sie von:

  • Konsistenter Konfiguration über mehrere Systeme hinweg
  • Versionskontrolle Ihrer Jobpläne
  • Idempotenten Operationen, die wiederholt angewendet werden können
  • Automatisierter Bereitstellung und Verwaltung von geplanten Aufgaben

Wenn Sie weiterhin mit Ansible arbeiten, sollten Sie die erweiterten Funktionen des Cron-Moduls erkunden, wie beispielsweise:

  • Das Festlegen von Umgebungsvariablen für cron-Jobs
  • Die Verwendung spezieller Zeitangaben wie @daily oder @reboot
  • Die Kombination der cron-Verwaltung mit anderen Ansible-Modulen für umfassende Automatisierungslösungen

Die Fähigkeit, geplante Aufgaben effektiv zu verwalten, ist eine wertvolle Fähigkeit, die Ihnen in der Systemadministration, im DevOps und in anderen IT-Rollen gut dienen wird.