Ansible get_url: Dateien von URL herunterladen – Anleitung & Beispiele

Einführung

Ansible ist ein leistungsstarkes Open-Source-Automatisierungstool, das die Verwaltung der IT-Infrastruktur vereinfacht. In diesem Tutorial werden wir das Ansible get_url-Modul untersuchen, mit dem Sie Dateien von einer bestimmten URL herunterladen können. Dieses Modul ist für Automatisierungsaufgaben wie Softwareinstallation, Konfigurationsmanagement und Content-Deployment unerlässlich.

In diesem Tutorial erfahren Sie, wie Sie Ansible einrichten, das get_url-Modul mit grundlegenden und erweiterten Optionen verwenden und praktische Beispiele zur Automatisierung von Datei-Downloads implementieren. Am Ende dieses Leitfadens werden Sie ein solides Verständnis dafür haben, wie Sie dieses Modul nutzen können, um Ihre Dateiverwaltungsprozesse zu optimieren.

Installation und Einrichtung von Ansible

Bevor wir das get_url-Modul verwenden können, müssen wir sicherstellen, dass Ansible auf unserem System ordnungsgemäß installiert und konfiguriert ist.

Installation von Ansible

Beginnen wir mit der Installation von Ansible in der LabEx-Umgebung:

sudo apt update
sudo apt install -y ansible

Überprüfen Sie nach dem Ausführen dieser Befehle, ob Ansible korrekt installiert wurde, indem Sie die Version überprüfen:

ansible --version

Sie sollten eine Ausgabe ähnlich dieser sehen, die die Ansible-Version und Konfigurationsdetails anzeigt:

ansible [core 2.12.x]
  config file = /etc/ansible/ansible.cfg
  configured module search path = ['/home/labex/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3/dist-packages/ansible
  executable location = /usr/bin/ansible
  python version = 3.10.x (default, ...) [GCC 11.x]

Erstellen eines Arbeitsverzeichnisses

Als Nächstes erstellen wir ein dediziertes Verzeichnis für unser Ansible-Projekt:

mkdir -p ~/project/ansible-get-url
cd ~/project/ansible-get-url

Einrichten eines einfachen Inventars

Ansible muss wissen, welche Hosts verwaltet werden sollen. Für dieses Tutorial erstellen wir eine einfache Inventardatei, die sich an die lokale Maschine richtet:

echo "localhost ansible_connection=local" > inventory.ini

Diese Inventardatei gibt an, dass wir Ansible gegen den localhost mit einer lokalen Verbindung ausführen möchten.

Erstellen der Ansible-Konfigurationsdatei

Um das Verhalten von Ansible anzupassen, erstellen wir eine einfache Konfigurationsdatei:

cat > ansible.cfg << EOF
[defaults]
inventory = inventory.ini
host_key_checking = False
EOF

Diese Konfigurationsdatei weist Ansible an, unsere Inventardatei zu verwenden und die Host-Key-Überprüfung zu deaktivieren, was die Verbindungen in einer Testumgebung vereinfacht.

Testen der Ansible-Einrichtung

Überprüfen wir, ob unsere Ansible-Konfiguration korrekt funktioniert, indem wir einen einfachen Ping-Befehl ausführen:

ansible localhost -m ping

Sie sollten eine erfolgreiche Antwort wie diese sehen:

localhost | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/bin/python3"
    },
    "changed": false,
    "ping": "pong"
}

Diese Ausgabe bestätigt, dass Ansible korrekt installiert ist und mit dem localhost kommunizieren kann. Jetzt sind wir bereit, das get_url-Modul im nächsten Schritt zu verwenden.

Erstellen eines grundlegenden Playbooks mit dem `get_url`-Modul

Nachdem wir Ansible eingerichtet haben, erstellen wir ein einfaches Playbook, das das get_url-Modul verwendet, um eine Datei von einer URL herunterzuladen.

Verstehen von Ansible Playbooks

Ein Ansible Playbook ist eine YAML-Datei, die eine Reihe von Aufgaben definiert, die auf verwalteten Hosts ausgeführt werden sollen. Playbooks sind als eine Reihe von Plays organisiert, wobei jedes Play Folgendes umfasst:

Eine Reihe von Hosts, die als Ziel dienen sollen
Eine Reihe von Aufgaben, die ausgeführt werden sollen

Erstellen unseres ersten Playbooks

Erstellen wir ein grundlegendes Playbook, das das get_url-Modul verwendet. Erstellen Sie eine Datei namens download-file.yml in Ihrem Projektverzeichnis:

cd ~/project/ansible-get-url

Öffnen Sie den Dateieditor und erstellen Sie die Datei mit folgendem Inhalt:

---
- name: Download a file from URL
  hosts: localhost
  become: no
  tasks:
    - name: Create downloads directory
      file:
        path: ~/project/ansible-get-url/downloads
        state: directory
        mode: "0755"

    - name: Download a sample text file
      get_url:
        url: https://raw.githubusercontent.com/ansible/ansible/devel/README.md
        dest: ~/project/ansible-get-url/downloads/ansible-readme.md
        mode: "0644"

Dieses Playbook führt Folgendes aus:

Erstellt ein downloads-Verzeichnis, um unsere heruntergeladenen Dateien zu speichern
Verwendet das get_url-Modul, um die Ansible README.md-Datei von GitHub herunterzuladen

Verstehen der `get_url`-Modulparameter

Lassen Sie uns die wichtigsten Parameter in der get_url-Aufgabe aufschlüsseln:

url: Gibt die URL an, von der die Datei heruntergeladen werden soll
dest: Definiert den Zielpfad, in dem die Datei gespeichert wird
mode: Legt die Dateiberechtigungen fest (0644 bedeutet Lesen und Schreiben für den Eigentümer, Lesen für Gruppe und Andere)

Ausführen des Playbooks

Nachdem wir unser Playbook erstellt haben, führen wir es mit dem Befehl ansible-playbook aus:

ansible-playbook download-file.yml

Sie sollten eine Ausgabe ähnlich dieser sehen:

PLAY [Download a file from URL] ***********************************************

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

TASK [Create downloads directory] *********************************************
changed: [localhost]

TASK [Download a sample text file] ********************************************
changed: [localhost]

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

Überprüfen der heruntergeladenen Datei

Überprüfen wir, ob die Datei korrekt heruntergeladen wurde:

ls -l ~/project/ansible-get-url/downloads/

Sie sollten die heruntergeladene Datei sehen:

-rw-r--r-- 1 labex labex 3154 Mar 15 12:34 ansible-readme.md

Sie können auch den Inhalt der heruntergeladenen Datei anzeigen:

head -n 10 ~/project/ansible-get-url/downloads/ansible-readme.md

Dies zeigt die ersten 10 Zeilen der Ansible README.md-Datei an und bestätigt, dass sie erfolgreich heruntergeladen wurde.

Herzlichen Glückwunsch! Sie haben erfolgreich Ihr erstes Ansible Playbook erstellt und ausgeführt, indem Sie das get_url-Modul verwendet haben, um eine Datei von einer URL herunterzuladen.

Arbeiten mit erweiterten `get_url`-Optionen

Nachdem wir die Grundlagen behandelt haben, wollen wir einige erweiterte Optionen des get_url-Moduls untersuchen, die in realen Szenarien nützlich sein können.

Erstellen eines erweiterten Playbooks

Erstellen wir ein neues Playbook namens advanced-download.yml, das verschiedene erweiterte Optionen demonstriert:

cd ~/project/ansible-get-url

Öffnen Sie den Dateieditor und erstellen Sie die Datei mit folgendem Inhalt:

---
- name: Advanced get_url Module Options
  hosts: localhost
  become: no
  tasks:
    - name: Create advanced downloads directory
      file:
        path: ~/project/ansible-get-url/advanced-downloads
        state: directory
        mode: "0755"

    - name: Download with checksum validation
      get_url:
        url: https://github.com/stedolan/jq/releases/download/jq-1.6/jq-linux64
        dest: ~/project/ansible-get-url/advanced-downloads/jq
        mode: "0755"
        checksum: sha256:af986793a515d500ab2d35f8d2aecd656e764504b789b66d7e1a0b727a124c44

    - name: Download with timeout and retries
      get_url:
        url: https://raw.githubusercontent.com/ansible/ansible-examples/master/README.md
        dest: ~/project/ansible-get-url/advanced-downloads/examples-readme.md
        timeout: 30
        retries: 3
        delay: 5
        force: yes

    - name: Download only if file doesn't exist
      get_url:
        url: https://raw.githubusercontent.com/ansible/ansible/devel/examples/ansible.cfg
        dest: ~/project/ansible-get-url/advanced-downloads/ansible-example.cfg
        force: no

Verstehen der erweiterten Parameter

Betrachten wir die erweiterten Parameter, die in diesem Playbook verwendet werden:

Checksum-Validierung (Checksum Validation):
- checksum: Gibt die erwartete Prüfsumme (Checksum) der heruntergeladenen Datei an (Format: Algorithmus:Prüfsumme)
- Dies stellt die Integrität der heruntergeladenen Datei sicher und verhindert den Download, wenn die Datei bereits mit der korrekten Prüfsumme existiert
Timeout und Wiederholungen (Timeout and Retries):
- timeout: Maximale Zeit in Sekunden für den Abschluss der HTTP-Anfrage
- retries: Anzahl der Wiederholungen, falls der Download fehlschlägt
- delay: Verzögerung zwischen den Wiederholungen in Sekunden
- force: Ob die Datei heruntergeladen werden soll, auch wenn sie bereits existiert
Bedingter Download (Conditional Download):
- force: no: Die Datei wird nur heruntergeladen, wenn sie am Zielort nicht existiert

Ausführen des erweiterten Playbooks

Lassen Sie uns unser erweitertes Playbook ausführen:

ansible-playbook advanced-download.yml

Sie sollten eine Ausgabe ähnlich dieser sehen:

PLAY [Advanced get_url Module Options] ****************************************

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

TASK [Create advanced downloads directory] ************************************
changed: [localhost]

TASK [Download with checksum validation] **************************************
changed: [localhost]

TASK [Download with timeout and retries] **************************************
changed: [localhost]

TASK [Download only if file doesn't exist] ************************************
changed: [localhost]

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

Überprüfen der erweiterten Downloads

Überprüfen wir die Dateien, die wir mit den erweiterten Optionen heruntergeladen haben:

ls -l ~/project/ansible-get-url/advanced-downloads/

Sie sollten alle heruntergeladenen Dateien sehen:

-rwxr-xr-x 1 labex labex 3773448 Mar 15 12:45 jq
-rw-r--r-- 1 labex labex     426 Mar 15 12:45 examples-readme.md
-rw-r--r-- 1 labex labex    1690 Mar 15 12:45 ansible-example.cfg

Testen wir, ob die heruntergeladene jq-Binärdatei funktioniert:

~/project/ansible-get-url/advanced-downloads/jq --version

Sie sollten eine Ausgabe sehen, die die jq-Version anzeigt (z. B. jq-1.6), was bestätigt, dass die ausführbare Datei ordnungsgemäß mit der korrekten Prüfsumme heruntergeladen wurde.

Sie haben nun erfolgreich verschiedene erweiterte Optionen des get_url-Moduls verwendet, um Dateien mit unterschiedlichen Anforderungen und Einschränkungen herunterzuladen.

Implementierung einer praktischen Webanwendungsbereitstellung

Wenden wir das Gelernte in einem praxisnäheren Szenario an: Bereitstellung einer einfachen Webanwendung mit dem get_url-Modul von Ansible.

Einrichten des Webanwendungsprojekts

Erstellen wir zunächst eine Verzeichnisstruktur für unsere Webanwendung:

mkdir -p ~/project/ansible-get-url/webapp/public
cd ~/project/ansible-get-url

Erstellen des Webanwendungs-Deployment-Playbooks

Nun erstellen wir ein Playbook namens deploy-webapp.yml, das die für unsere Webanwendung benötigten Dateien herunterlädt:

---
- name: Deploy Web Application Files
  hosts: localhost
  become: no
  vars:
    webapp_dir: ~/project/ansible-get-url/webapp
    assets_base_url: https://raw.githubusercontent.com/ansible/ansible-documentation/devel/docs/docsite/rst/_static
  tasks:
    - name: Ensure webapp directories exist
      file:
        path: "{{ item }}"
        state: directory
        mode: "0755"
      loop:
        - "{{ webapp_dir }}"
        - "{{ webapp_dir }}/public"
        - "{{ webapp_dir }}/public/css"
        - "{{ webapp_dir }}/public/images"

    - name: Create index.html
      copy:
        dest: "{{ webapp_dir }}/public/index.html"
        content: |
          <!DOCTYPE html>
          <html>
          <head>
            <title>Ansible Demo App</title>
            <link rel="stylesheet" href="css/style.css">
          </head>
          <body>
            <div class="container">
              <h1>Welcome to Ansible Demo</h1>
              <p>This site was deployed using Ansible's get_url module!</p>
              <img src="images/ansible-logo.png" alt="Ansible Logo">
            </div>
          </body>
          </html>

    - name: Download CSS file
      get_url:
        url: "{{ assets_base_url }}/css/ansible.css"
        dest: "{{ webapp_dir }}/public/css/style.css"
        mode: "0644"
        timeout: 30
        retries: 3

    - name: Download Ansible logo
      get_url:
        url: "{{ assets_base_url }}/images/ansible_logo.svg"
        dest: "{{ webapp_dir }}/public/images/ansible-logo.png"
        mode: "0644"
        timeout: 30
        retries: 3

    - name: Install Python HTTP server
      apt:
        name: python3-http.server
        state: present
      become: yes

    - name: Display information about running the web server
      debug:
        msg: |
          Web application has been deployed!
          To start the web server, run:
          cd {{ webapp_dir }}/public && python3 -m http.server 8080
          Then access it at: http://localhost:8080

Dieses Playbook:

Erstellt die notwendige Verzeichnisstruktur für unsere Webanwendung
Erstellt eine index.html-Datei mit grundlegendem HTML-Inhalt
Lädt eine CSS-Datei und ein Ansible-Logo-Bild mit dem get_url-Modul herunter
Installiert einen Python HTTP-Server
Zeigt Informationen zur Ausführung des Webservers an

Ausführen des Webanwendungs-Deployment-Playbooks

Lassen Sie uns das Playbook ausführen:

ansible-playbook deploy-webapp.yml

Sie sollten eine Ausgabe sehen, die anzeigt, dass die Webanwendung erfolgreich bereitgestellt wurde.

Starten des Webservers

Starten wir nun den Webserver, um unsere bereitgestellte Anwendung zu testen:

cd ~/project/ansible-get-url/webapp/public
python3 -m http.server 8080 &

Der Webserver läuft jetzt im Hintergrund auf Port 8080. Wenn Sie sich in einer regulären Umgebung mit Browserzugriff befinden, könnten Sie auf die Webanwendung unter http://localhost:8080 zugreifen.

Überprüfen der bereitgestellten Dateien

Überprüfen wir, ob alle erforderlichen Dateien korrekt bereitgestellt wurden:

ls -la ~/project/ansible-get-url/webapp/public/

Sie sollten die index.html-Datei und die von uns erstellten Verzeichnisse sehen.

ls -la ~/project/ansible-get-url/webapp/public/css/

Dies sollte die heruntergeladene CSS-Datei anzeigen.

ls -la ~/project/ansible-get-url/webapp/public/images/

Dies sollte das heruntergeladene Ansible-Logo-Bild anzeigen.

Anzeigen des HTML-Inhalts

Überprüfen wir den Inhalt der index.html-Datei:

cat ~/project/ansible-get-url/webapp/public/index.html

Sie sollten den HTML-Inhalt sehen, den wir im Playbook erstellt haben.

Stoppen des Webservers

Wenn Sie mit dem Testen fertig sind, können Sie den Webserver stoppen, indem Sie seine Prozess-ID ermitteln und ihn beenden:

pkill -f "python3 -m http.server 8080"

Herzlichen Glückwunsch! Sie haben erfolgreich eine einfache Webanwendung bereitgestellt, indem Sie das get_url-Modul von Ansible verwendet haben, um die erforderlichen Dateien herunterzuladen.

Zusammenfassung

In diesem Tutorial haben Sie praktische Erfahrungen mit dem get_url-Modul von Ansible gesammelt, um Dateien von bestimmten URLs herunterzuladen. Sie haben gelernt:

Wie man Ansible für die lokale Entwicklung installiert und konfiguriert
Wie man grundlegende Playbooks mit dem get_url-Modul erstellt, um Dateien herunterzuladen
Wie man erweiterte Optionen wie Prüfsummenvalidierung (Checksum Validation), Timeouts, Wiederholungen (Retries) und bedingte Downloads verwendet
Wie man ein praktisches Webanwendungs-Deployment-Szenario mit dem get_url-Modul implementiert

Diese Fähigkeiten sind grundlegend für die Automatisierung von Dateiverwaltungsaufgaben in verschiedenen IT-Operationen, einschließlich Software-Deployment, Content-Management und Systemkonfiguration. Das get_url-Modul ist ein vielseitiges Werkzeug, das in komplexere Ansible-Workflows integriert werden kann, um Ihre Infrastrukturverwaltungsprozesse zu optimieren.

Wenn Sie Ihre Ansible-Reise fortsetzen, sollten Sie die verwandten Module wie uri, unarchive und synchronize erkunden, die das get_url-Modul für eine umfassendere Automatisierung der Dateiverwaltung ergänzen.

Dateien von einer bestimmten URL mit dem Ansible get_url Modul herunterladen