💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken
Ansible ist ein leistungsstarkes IT-Automatisierungswerkzeug, das die Infrastrukturverwaltung vereinfacht. In diesem praktischen Lab lernen Sie, wie Sie Ansible verwenden, um Dateien mit spezifischem Inhalt auf Zielsystemen zu erstellen. Am Ende dieses Labs werden Sie die Grundlagen der Ansible-Dateiverwaltung verstehen und in der Lage sein, die automatisierte Dateierstellung in Ihrer eigenen Infrastruktur zu implementieren.
Bevor wir mit Ansible Dateien erstellen können, müssen wir es auf unserem System installieren und konfigurieren. Richten wir unsere Umgebung ein:
Zuerst aktualisieren wir die Paketlisten und installieren Ansible auf unserem Ubuntu 22.04 System:
sudo apt update
sudo apt install -y ansibleNachdem Sie diese Befehle ausgeführt haben, sollten Sie eine Ausgabe sehen, die anzeigt, dass Ansible erfolgreich installiert wurde. Überprüfen wir die Installation:
ansible --versionSie sollten eine ähnliche Ausgabe wie diese sehen:
ansible [core 2.12.0]
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
ansible collection location = /home/labex/.ansible/collections:/usr/share/ansible/collections
executable location = /usr/bin/ansible
python version = 3.10.x (default, ...) [GCC 11.2.0]
jinja version = 3.0.3
libyaml = TrueAnsible verwendet eine Inventardatei, um die Hosts zu definieren, die es verwalten soll. Für dieses Lab erstellen wir ein lokales Inventar, das unsere eigene Maschine enthält:
mkdir -p ~/project/ansible-files
cd ~/project/ansible-files~/project/ansible-filesinventory[local]
localhost ansible_connection=localDiese Inventardatei weist Ansible an, Befehle auf der lokalen Maschine auszuführen, ohne SSH zu verwenden.
ansible.cfg-Datei im selben Verzeichnis:
~/project/ansible-filesansible.cfg[defaults]
inventory = ./inventory
host_key_checking = Falsecd ~/project/ansible-files
ansible local -m pingSie sollten eine ähnliche Ausgabe wie diese sehen:
localhost | SUCCESS => {
"changed": false,
"ping": "pong"
}Dies bestätigt, dass Ansible korrekt installiert und konfiguriert ist, um Befehle auf Ihrer lokalen Maschine auszuführen.
Nachdem wir Ansible eingerichtet haben, lernen wir nun, wie man Dateien mit Inhalt erstellt. Ansible bietet mehrere Module für die Dateiverwaltung, und wir konzentrieren uns in diesem Schritt auf das copy-Modul.
Ansible Playbooks sind YAML-Dateien, die eine Reihe von Aufgaben beschreiben, die auf Ziel-Hosts ausgeführt werden sollen. Jede Aufgabe verwendet ein spezifisches Ansible-Modul, um eine Aktion auszuführen.
Erstellen wir unser erstes Playbook, um eine Datei mit Inhalt zu erstellen:
~/project/ansible-files:
create_file.yml---
- name: Create a file with content
hosts: local
tasks:
- name: Create a simple text file
copy:
dest: "~/project/hello.txt"
content: |
Hello from Ansible!
This file was created using the Ansible copy module.
Current date: {{ ansible_date_time.date }}Lassen Sie uns verstehen, was dieses Playbook tut:
hosts: local gibt an, dass dieses Playbook auf den Hosts in der Gruppe local aus unserem Inventar ausgeführt wird.tasks enthält eine Liste der auszuführenden Aufgaben.copy-Modul wird verwendet, um eine Datei mit Inhalt zu erstellen.dest gibt den Zielpfad für die Datei an.content enthält den Textinhalt, der in die Datei geschrieben wird.{{ ansible_date_time.date }} ist eine Variable, die beim Ausführen des Playbooks durch das aktuelle Datum ersetzt wird.cd ~/project/ansible-files
ansible-playbook create_file.ymlSie sollten eine ähnliche Ausgabe wie diese sehen:
PLAY [Create a file with content] ***********************************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create a simple text file] ***********************************************
changed: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=2 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0cat ~/project/hello.txtSie sollten eine ähnliche Ausgabe wie diese sehen:
Hello from Ansible!
This file was created using the Ansible copy module.
Current date: 2023-08-15Das Datum spiegelt das aktuelle Datum wider, an dem Sie das Playbook ausführen.
Idempotenz ist eine Schlüsselfunktion von Ansible – das mehrmalige Ausführen desselben Playbooks sollte dasselbe Ergebnis liefern. Führen wir das Playbook erneut aus, um die Idempotenz in Aktion zu sehen:
ansible-playbook create_file.ymlDieses Mal sollten Sie sehen, dass die Anzahl der "changed" 0 ist:
PLAY [Create a file with content] ***********************************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create a simple text file] ***********************************************
ok: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=2 changed=0 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0Dies zeigt, dass Ansible erkennt, dass die Datei bereits mit dem korrekten Inhalt existiert, und sie daher nicht erneut modifiziert.
In diesem Schritt werden wir untersuchen, wie man Variablen und Vorlagen verwendet, um mit Ansible dynamischere Dateien zu erstellen.
Variablen machen Ihre Playbooks flexibler und wiederverwendbarer. Erstellen wir ein Playbook, das Variablen verwendet, um eine Konfigurationsdatei zu erstellen:
~/project/ansible-files:
variables_demo.yml---
- name: Create files using variables
hosts: local
vars:
app_name: "MyApplication"
app_version: "1.0.0"
port_number: 8080
log_level: "INFO"
tasks:
- name: Create config file with variables
copy:
dest: "~/project/app_config.ini"
content: |
## Configuration for {{ app_name }}
## Generated by Ansible
[application]
name = {{ app_name }}
version = {{ app_version }}
[server]
port = {{ port_number }}
log_level = {{ log_level }}In diesem Playbook:
vars definiert Variablen, die im gesamten Playbook verwendet werden können.{{ variable_name }} verwiesen.copy-Modul wird verwendet, um eine Datei mit Inhalt zu erstellen, der diese Variablen enthält.cd ~/project/ansible-files
ansible-playbook variables_demo.ymlSie sollten eine ähnliche Ausgabe wie diese sehen:
PLAY [Create files using variables] ********************************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create config file with variables] ***************************************
changed: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=2 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0cat ~/project/app_config.iniSie sollten eine ähnliche Ausgabe wie diese sehen:
## Configuration for MyApplication
## Generated by Ansible
[application]
name = MyApplication
version = 1.0.0
[server]
port = 8080
log_level = INFOFür komplexere Dateiinhalte unterstützt Ansible Jinja2-Vorlagen. Erstellen wir eine Vorlagendatei und verwenden sie in einem Playbook:
mkdir -p ~/project/ansible-files/templates~/project/ansible-files/templatesweb_config.j2## Web Server Configuration
## Generated by Ansible on {{ ansible_date_time.date }}
server {
listen {{ web_port }};
server_name {{ server_name }};
location / {
root {{ doc_root }};
index index.html;
}
{% if enable_ssl %}
## SSL Configuration
ssl_certificate {{ ssl_cert }};
ssl_certificate_key {{ ssl_key }};
{% endif %}
}~/project/ansible-filestemplate_demo.yml---
- name: Create files using templates
hosts: local
vars:
web_port: 80
server_name: "example.com"
doc_root: "/var/www/html"
enable_ssl: true
ssl_cert: "/etc/ssl/certs/example.com.crt"
ssl_key: "/etc/ssl/private/example.com.key"
tasks:
- name: Create web server config from template
template:
src: templates/web_config.j2
dest: ~/project/web_server.confIn diesem Playbook:
template-Modul wird anstelle von copy verwendet.src verweist auf unsere Vorlagendatei.dest gibt an, wo die Ausgabedatei erstellt werden soll.vars definierten Variablen werden in der Vorlage verwendet.cd ~/project/ansible-files
ansible-playbook template_demo.ymlSie sollten eine ähnliche Ausgabe wie diese sehen:
PLAY [Create files using templates] ********************************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create web server config from template] **********************************
changed: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=2 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0cat ~/project/web_server.confSie sollten eine ähnliche Ausgabe wie diese sehen:
## Web Server Configuration
## Generated by Ansible on 2023-08-15
server {
listen 80;
server_name example.com;
location / {
root /var/www/html;
index index.html;
}
## SSL Configuration
ssl_certificate /etc/ssl/certs/example.com.crt;
ssl_certificate_key /etc/ssl/private/example.com.key;
}Beachten Sie, wie die Jinja2-Vorlage mit unseren Variablen gerendert wurde und der bedingte Abschnitt für SSL enthalten war, da enable_ssl auf true gesetzt war.
In diesem letzten Schritt werden wir einige fortgeschrittene Dateiverwaltungstechniken mit Ansible untersuchen, einschließlich Dateiberechtigungen, bedingter Dateierstellung und der Verwendung mehrerer dateibezogener Module.
Beim Erstellen von Dateien müssen Sie häufig bestimmte Berechtigungen und Eigentumsverhältnisse festlegen. Erstellen wir ein Playbook, das dies demonstriert:
~/project/ansible-filesfile_permissions.yml---
- name: Manage file permissions and ownership
hosts: local
tasks:
- name: Create a script file with execute permissions
copy:
dest: ~/project/script.sh
content: |
#!/bin/bash
echo "This script was created by Ansible"
echo "Current user: $(whoami)"
echo "Current directory: $(pwd)"
mode: "0755"
- name: Create a read-only configuration file
copy:
dest: ~/project/readonly.conf
content: |
## This is a read-only configuration file
setting1 = value1
setting2 = value2
mode: "0444"In diesem Playbook:
mode wird verwendet, um Dateiberechtigungen festzulegen.0755 bedeutet Lesen, Schreiben und Ausführen für den Eigentümer sowie Lesen und Ausführen für Gruppe und Andere.0444 bedeutet schreibgeschützt für alle.cd ~/project/ansible-files
ansible-playbook file_permissions.ymlSie sollten eine ähnliche Ausgabe wie diese sehen:
PLAY [Manage file permissions and ownership] **********************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create a script file with execute permissions] **************************
changed: [localhost]
TASK [Create a read-only configuration file] **********************************
changed: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=3 changed=2 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0ls -l ~/project/script.sh ~/project/readonly.confSie sollten eine ähnliche Ausgabe wie diese sehen:
-rwxr-xr-x 1 labex labex 118 Aug 15 12:34 /home/labex/project/script.sh
-r--r--r-- 1 labex labex 73 Aug 15 12:34 /home/labex/project/readonly.conf~/project/script.shSie sollten eine ähnliche Ausgabe wie diese sehen:
This script was created by Ansible
Current user: labex
Current directory: /home/labex/project/ansible-filesManchmal müssen Sie Dateien nur erstellen, wenn bestimmte Bedingungen erfüllt sind. Erstellen wir ein Playbook, das die bedingte Dateierstellung demonstriert:
~/project/ansible-filesconditional_file.yml---
- name: Conditional file creation
hosts: local
vars:
environment: "development"
create_debug_file: true
create_backup: false
tasks:
- name: Create environment-specific configuration
copy:
dest: "~/project/{{ environment }}_config.yml"
content: |
## Configuration for {{ environment }} environment
debug: {{ 'enabled' if environment == 'development' else 'disabled' }}
log_level: {{ 'DEBUG' if environment == 'development' else 'INFO' }}
- name: Create debug log file
copy:
dest: ~/project/debug.log
content: |
## Debug log file
## Created: {{ ansible_date_time.iso8601 }}
mode: "0644"
when: create_debug_file
- name: Create backup directory
file:
path: ~/project/backup
state: directory
mode: "0755"
when: create_backupIn diesem Playbook:
when wird für die bedingte Ausführung von Aufgaben verwendet.file-Modul wird verwendet, um ein Verzeichnis zu erstellen.cd ~/project/ansible-files
ansible-playbook conditional_file.ymlSie sollten eine ähnliche Ausgabe wie diese sehen:
PLAY [Conditional file creation] **********************************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create environment-specific configuration] ******************************
changed: [localhost]
TASK [Create debug log file] **************************************************
changed: [localhost]
TASK [Create backup directory] ************************************************
skipped: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=3 changed=2 unreachable=0 failed=0 skipped=1 rescued=0 ignored=0Beachten Sie, dass die Aufgabe "Create backup directory" übersprungen wurde, da create_backup auf false gesetzt war.
cat ~/project/development_config.yml
cat ~/project/debug.log
ls -la ~/project/ | grep backupSie sollten den Inhalt der beiden erstellten Dateien sehen und bestätigen, dass kein Sicherungsverzeichnis erstellt wurde.
Ansible bietet mehrere Module für die Dateiverwaltung. Erstellen wir ein Playbook, das die Verwendung mehrerer dateibezogener Module demonstriert:
~/project/ansible-filesfile_modules.yml---
- name: Demonstrate file-related modules
hosts: local
tasks:
- name: Create a directory
file:
path: ~/project/ansible_demo
state: directory
mode: "0755"
- name: Create a file using the copy module
copy:
dest: ~/project/ansible_demo/copied.txt
content: "This file was created using the copy module.\n"
- name: Create a symbolic link
file:
src: ~/project/ansible_demo/copied.txt
dest: ~/project/ansible_demo/link_to_copied.txt
state: link
- name: Create a file with blockinfile module
blockinfile:
path: ~/project/ansible_demo/block.txt
create: true
block: |
This is a block of text
that will be inserted
as a single unit.
marker: "## {mark} ANSIBLE MANAGED BLOCK"In diesem Playbook:
file-Modul wird mit state: directory verwendet, um ein Verzeichnis zu erstellen.file-Modul wird mit state: link verwendet, um einen symbolischen Link zu erstellen.blockinfile-Modul wird verwendet, um eine Datei mit einem Textblock zu erstellen, der von Markierungskommentaren umgeben ist.cd ~/project/ansible-files
ansible-playbook file_modules.ymlSie sollten eine ähnliche Ausgabe wie diese sehen:
PLAY [Demonstrate file-related modules] ***************************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create a directory] *****************************************************
changed: [localhost]
TASK [Create a file using the copy module] ************************************
changed: [localhost]
TASK [Create a symbolic link] *************************************************
changed: [localhost]
TASK [Create a file with blockinfile module] **********************************
changed: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=5 changed=4 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0ls -la ~/project/ansible_demo/
cat ~/project/ansible_demo/copied.txt
cat ~/project/ansible_demo/link_to_copied.txt
cat ~/project/ansible_demo/block.txtSie sollten Folgendes sehen:
ansible_democopied.txt mit dem angegebenen Inhaltlink_to_copied.txt, der auf copied.txt verweistblock.txt mit einem Textblock, der von Markierungskommentaren umgeben istDie Ausgabe des letzten Befehls sollte in etwa so aussehen:
## BEGIN ANSIBLE MANAGED BLOCK
This is a block of text
that will be inserted
as a single unit.
## END ANSIBLE MANAGED BLOCKDies demonstriert die Vielseitigkeit der Dateiverwaltungsfunktionen von Ansible.
Herzlichen Glückwunsch zum Abschluss dieses Ansible-Dateiverwaltungs-Labs. Sie haben mehrere wichtige Konzepte und Techniken gelernt:
copy-ModulsDiese Fähigkeiten bilden eine solide Grundlage für die Automatisierung von Dateiverwaltungsaufgaben in Ihrer Infrastruktur. Mit Ansible können Sie konsistenten Dateiinhalt über mehrere Server hinweg sicherstellen, Änderungen kontrolliert anwenden und eine prüfbare Aufzeichnung Ihrer Konfiguration führen.
Um Ihre Ansible-Lernreise fortzusetzen, sollten Sie sich mit fortgeschritteneren Themen wie Rollen, Playbook-Organisation und der Integration von Ansible mit anderen DevOps-Tools befassen.
