Ansible: Up and Running, 3. Auflage

Table of contents

1. Vorwort zur dritten Auflage
   1. In diesem Buch verwendete Konventionen
   2. Code-Beispiele verwenden
   3. O'Reilly Online Learning
   4. Wie du uns kontaktierst
   5. Danksagungen
      1. Von Lorin
      2. Von René
      3. Von Bas
2. 1. Einführung
   1. Ein Hinweis zu den Versionen
   2. Ansible: Wozu ist es gut?
   3. Wie Ansible funktioniert
   4. Was ist so toll an Ansible?
      1. Einfach
      2. Leistungsstark
      3. Sicher
   5. Ist Ansible zu einfach?
   6. Was muss ich wissen?
   7. Was nicht abgedeckt ist
   8. Vorwärts bewegen
3. 2. Installation und Einrichtung
   1. Ansible installieren
      1. Lose Abhängigkeiten
      2. Ansible in Containern ausführen
      3. Ansible Entwicklung
   2. Einrichten eines Servers für Tests
      1. Vagrant zum Einrichten eines Test-Servers verwenden
      2. Ansible über deine Server informieren
      3. Vereinfachung mit der Datei ansible.cfg
      4. Töte deine Lieblinge
   3. Bequeme Vagrant-Konfigurationsoptionen
      1. Portweiterleitung und private IP-Adressen
      2. Aktivieren der Agentenweiterleitung
   4. Der Docker Provisioner
   5. Der Ansible Local Provisioner
   6. Wenn der Provisioner ausgeführt wird
   7. Vagrant Plug-ins
      1. Hostmanager
      2. VBGuest
   8. VirtualBox-Anpassung
   9. Vagrantfile ist Ruby
   10. Produktion einrichten
   11. Fazit
4. 3. Spielbücher: Ein Anfang
   1. Präliminarien
   2. Ein sehr einfaches Spielbuch
      1. Angeben einer NGINX-Konfigurationsdatei
      2. Eine Webseite erstellen
      3. Eine Gruppe erstellen
   3. Das Playbook ausführen
   4. Playbooks sind YAML
      1. Anfang des Dokuments
      2. Ende der Datei
      3. Kommentare
      4. Einrückung und Leerraum
      5. Strings
      6. Booleans
      7. Listen
      8. Wörterbücher
      9. Mehrzeilige Strings
      10. Reines YAML anstelle von String-Argumenten
   5. Anatomie eines Spielbuchs
   6. Spielt
      1. Aufgaben
      2. Module
      3. Anzeigen der Ansible-Modul-Dokumentation
      4. Alles zusammenfügen
   7. Hat sich etwas geändert? Verfolgung des Gastgeberstatus
   8. Immer ausgefallener: TLS-Unterstützung
      1. Ein TLS-Zertifikat generieren
      2. Variablen
      3. Quoting in Ansible Strings
      4. Generierung der NGINX-Konfigurationsvorlage
      5. Schleife
      6. Handler
      7. Ein paar Dinge über Handler zu beachten
      8. Testen
      9. Validierung
      10. Das Spielbuch
      11. Das Playbook ausführen
   9. Fazit
5. 4. Inventarisierung: Beschreibe deine Server
   1. Inventar/Hosts-Dateien
      1. Vorbereitungen: Mehrere Vagrant-Maschinen
   2. Parameter des Verhaltensinventars
      1. Verhaltensparameter-Standardwerte ändern
   3. Gruppen und Gruppen und Gruppen
      1. Beispiel: Bereitstellen einer Django App
      2. Aliase und Ports
      3. Gruppen von Gruppen
      4. Nummerierte Wirte (Haustiere vs. Rinder)
   4. Hosts und Gruppenvariablen: Innerhalb des Inventars
   5. Host- und Gruppenvariablen: In ihren eigenen Dateien
   6. Dynamisches Inventar
      1. Inventarisierungs-Plug-ins
      2. Amazon EC2
      3. Azure Resource Manager
      4. Die Schnittstelle für ein dynamisches Inventarisierungsskript
      5. Ein dynamisches Inventarisierungsskript schreiben
   7. Aufteilung des Inventars in mehrere Dateien
   8. Hinzufügen von Einträgen zur Laufzeit mit add_host und group_by
      1. add_host
      2. group_by
   9. Fazit
6. 5. Variablen und Fakten
   1. Definieren von Variablen in Playbooks
      1. Definieren von Variablen in separaten Dateien
      2. Verzeichnis-Layout
   2. Anzeigen der Werte von Variablen
      1. Variable Interpolation
   3. Variablen registrieren
   4. Fakten
      1. Anzeigen aller Fakten, die mit einem Server verbunden sind
      2. Ansicht einer Teilmenge von Fakten
      3. Jedes Modul kann Fakten oder Informationen zurückgeben
      4. Lokale Fakten
      5. set_fact verwenden, um eine neue Variable zu definieren
   5. Eingebaute Variablen
      1. hostvars
      2. inventory_hostname
      3. Gruppen
   6. Zusätzliche Variablen auf der Kommandozeile
   7. Vorrang
   8. Fazit
7. 6. Wir stellen Mezzanine vor: Unsere Testanwendung
   1. Warum ist die Einführung in die Produktion so kompliziert?
   2. Postgres: Die Datenbank
   3. Gunicorn: Der Anwendungsserver
   4. NGINX: Der Webserver
   5. Vorgesetzter: Der Prozessmanager
   6. Fazit
8. 7. Bereitstellung von Mezzanine mit Ansible
   1. Auflisten von Aufgaben in einem Playbook
   2. Organisation der bereitgestellten Dateien
   3. Variablen und geheime Variablen
   4. Mehrere Pakete installieren
   5. Hinzufügen der Become-Klausel zu einer Aufgabe
   6. Aktualisieren des apt Cache
   7. Auschecken des Projekts mit Git
   8. Installation von Mezzanine und anderen Paketen in einer virtuellen Umgebung
   9. Komplexe Argumente in Aufgaben: Ein kurzer Exkurs
   10. Konfigurieren der Datenbank
   11. Generierung der Datei local_settings.py aus einer Vorlage
   12. Ausführen von django-manage-Befehlen
   13. Benutzerdefinierte Python-Skripte im Kontext der Anwendung ausführen
       1. Dienstkonfigurationsdateien einstellen
   14. Aktivieren der NGINX-Konfiguration
   15. Installieren von TLS-Zertifikaten
   16. Twitter Cron Job installieren
   17. Das vollständige Spielbuch
   18. Ausführen des Playbooks auf einer Vagrant-Maschine
   19. Fehlersuche
       1. Git-Repository kann nicht ausgecheckt werden
       2. 192.168.33.10.nip.io kann nicht erreicht werden
       3. Schlechte Anfrage (400)
   20. Fazit
9. 8. Debuggen von Ansible Playbooks
   1. Menschliche Fehlermeldungen
   2. SSH-Probleme debuggen
   3. Häufige SSH-Herausforderungen
      1. PasswortAuthentifizierung nein
      2. SSH als ein anderer Benutzer
      3. Host Key Verification fehlgeschlagen
      4. Private Netzwerke
   4. Das Debug-Modul
   5. Playbook Debugger
   6. Das Assert-Modul
   7. Überprüfe dein Spielbuch vor der Ausführung
      1. Syntaxprüfung
      2. Hosts auflisten
      3. Aufgaben auflisten
      4. Modus prüfen
      5. Diff (Dateiänderungen anzeigen)
      6. Tags
      7. Grenzwerte
   8. Fazit
10. 9. Rollen: Skalierung deiner Playbooks
    1. Grundlegende Struktur einer Rolle
    2. Beispiel: Einsatz von Mezzanine mit Rollen
       1. Rollen in deinen Spielbüchern verwenden
       2. Pre- und Post-Aufgaben
       3. Eine Datenbank-Rolle für die Bereitstellung der Datenbank
       4. Eine Mezzanine-Rolle für den Einsatz von Mezzanine
    3. Rollendateien und Verzeichnisse mit ansible-galaxy erstellen
    4. Abhängige Rollen
    5. Ansible Galaxie
       1. Web-Interface
       2. Kommandozeilen-Schnittstelle
       3. Rollenanforderungen in der Praxis
       4. Deine eigene Rolle einbringen
    6. Fazit
11. 10. Komplexe Spielbücher
    1. Umgang mit schlecht benutzten Befehlen
    2. Filter
       1. Der Standard-Filter
       2. Filter für registrierte Variablen
       3. Filter, die auf Dateipfade angewendet werden
       4. Schreibe deinen eigenen Filter
    3. Nachschlagen
       1. Datei
       2. Rohr
       3. env
       4. Passwort
       5. Template
       6. csv-Datei
       7. dig
       8. redis
       9. Dein eigenes Lookup Plug-in schreiben
    4. Kompliziertere Schleifen
       1. Mit Lookup Plug-in
       2. mit_linien
       3. with_fileglob
       4. mit_dikt
       5. Schleifenkonstruktionen als Lookup-Plug-ins
    5. Schleifensteuerungen
       1. Einstellen des Variablennamens
       2. Beschriftung der Ausgabe
    6. Einfuhren und Einschlüsse
       1. Dynamisch Enthält
       2. Die Rolle umfasst
       3. Rollenflusskontrolle
    7. Blöcke
    8. Fehlerbehandlung mit Blöcken
    9. Sensible Daten mit ansible-vault verschlüsseln
       1. Mehrere Tresore mit unterschiedlichen Passwörtern
    10. Fazit
12. 11. Hosts, Läufe und Handler anpassen
    1. Muster für die Angabe von Hosts
    2. Einschränkung der Ausführung von Hosts
    3. Eine Aufgabe auf der Kontrollmaschine ausführen
    4. Manuelles Sammeln von Fakten
    5. Abrufen einer IP-Adresse vom Host
    6. Immer nur auf einem Host laufen
    7. Gleichzeitige Ausführung auf mehreren Hosts
    8. Nur einmal laufen
    9. Einschränkung der laufenden Aufgaben
       1. Schritt
       2. start-at-task
       3. Laufende Tags
       4. Überspringen von Tags
    10. Laufende Strategien
        1. Linear
        2. Frei
    11. Fortgeschrittene Handler
        1. Betreuer in Vor- und Nachbereitungsaufgaben
        2. Flush Handler
        3. Meta-Befehle
        4. Handler Benachrichtigung der Handler
        5. Handler hören zu
        6. Der SSL-Fall für die Zuhörfunktion
    12. Fazit
13. 12. Windows Hosts verwalten
    1. Verbindung zu Windows
    2. PowerShell
    3. Windows-Module
    4. Unsere Java-Entwicklungsmaschine
    5. Hinzufügen eines lokalen Benutzers
    6. Windows-Funktionen
    7. Software mit Chocolatey installieren
    8. Konfiguration von Java
    9. Windows aktualisieren
    10. Fazit
14. 13. Ansible und Container
    1. Kubernetes
    2. Lebenszyklus von Docker-Anwendungen
    3. Registrierungen
    4. Ansible und Docker
    5. Mit dem Docker Daemon verbinden
    6. Beispielanwendung: Ghost
    7. Einen Docker Container auf unserem lokalen Rechner ausführen
    8. Ein Image aus einer Dockerdatei erstellen
    9. Unser Image in die Docker Registry einspeisen
    10. Orchestrierung mehrerer Container auf unserem lokalen Rechner
    11. Lokale Bilder abfragen
    12. Einsatz der Docker-Anwendung
        1. Bereitstellung von MySQL
        2. Einsetzen der Ghost-Datenbank
        3. Frontend
        4. Frontend: Ghost
        5. Frontend: NGINX
        6. Reinigen von Containern
    13. Fazit
15. 14. Qualitätssicherung mit Molecule
    1. Installation und Einrichtung
    2. Konfigurieren von Molekültreibern
    3. Eine Ansible-Rolle erstellen
    4. Szenarien
       1. Gewünschter Zustand
       2. Szenarien in Molecule konfigurieren
       3. Virtuelle Maschinen verwalten
       4. Verwaltung von Containern
    5. Molekül-Befehle
    6. Linting
       1. YAMLlint
       2. ansible-lint
       3. ansible-later
    7. Überprüfer
       1. Ansible
       2. Goss
       3. TestInfra
    8. Fazit
16. 15. Sammlungen
    1. Installieren von Sammlungen
    2. Auflistung Sammlungen
    3. Sammlungen in einem Playbook verwenden
    4. Entwicklung einer Sammlung
    5. Fazit
17. 16. Bilder erstellen
    1. Bilder mit Packer erstellen
       1. Vagrant VirtualBox VM
       2. Kombination von Packer und Vagrant
       3. Wolkenbilder
       4. Google Cloud Plattform
       5. Azurblau
       6. Amazon EC2
       7. Das Spielbuch
    2. Docker Image: GCC 11
    3. Fazit
18. 17. Cloud-Infrastruktur
    1. Terminologie
       1. Instanz
       2. Amazon Machine Image
       3. Tags
    2. Berechtigungsnachweise angeben
       1. Umgebungsvariablen
       2. Konfigurationsdateien
    3. Voraussetzung: Boto3 Python Bibliothek
    4. Dynamisches Inventar
       1. Inventar-Caching
       2. Andere Konfigurationsoptionen
    5. Definieren von dynamischen Gruppen mit Tags
       1. Anwendung von Tags auf bestehende Ressourcen
       2. Schönere Gruppennamen
    6. Virtuelle Private Clouds
    7. Konfigurieren der ansible.cfg für die Verwendung mit ec2
    8. Starten neuer Instanzen
    9. EC2 Schlüsselpaare
       1. Einen neuen Schlüssel erstellen
       2. Hochladen deines öffentlichen Schlüssels
    10. Sicherheitsgruppen
        1. Erlaubte IP-Adressen
        2. Ports der Sicherheitsgruppe
    11. Die neueste AMI erhalten
    12. Eine neue Instanz erstellen und zu einer Gruppe hinzufügen
    13. Warten, bis der Server hochgefahren ist
    14. Alles zusammenfügen
    15. Festlegen einer Virtual Private Cloud
        1. Dynamische Bestandsaufnahme und VPC
    16. Fazit
19. 18. Callback Plug-ins
    1. Stdout Plug-ins
       1. ARA
       2. debuggen
       3. Standard
       4. Dichtes
       5. json
       6. minimal
       7. null
       8. oneline
    2. Benachrichtigung und Aggregat-Plug-ins
       1. Python Anforderungen
       2. Vorarbeiter
       3. Jabber
       4. junit
       5. log_plays
       6. logentries
       7. logstash
       8. Mail
       9. Profil_Rollen
       10. Profil_Aufgaben
       11. sagen
       12. Slack
       13. splunk
       14. Timer
    3. Fazit
20. 19. Benutzerdefinierte Module
    1. Beispiel: Prüfen, ob du einen entfernten Server erreichen kannst
       1. Das Skriptmodul verwenden, anstatt ein eigenes zu schreiben
       2. can_reach als Modul
    2. Solltest du ein Modul entwickeln?
    3. Wohin mit deinen benutzerdefinierten Modulen?
    4. Wie Ansible Module aufruft
       1. Erstelle ein eigenständiges Python-Skript mit den Argumenten (nur Python)
       2. Kopiere das Modul auf den Host
       3. Erstellen einer Argumentationsdatei auf dem Host (nur Nicht-Python)
       4. Aufrufen des Moduls
    5. Erwartete Ergebnisse
       1. Ausgabevariablen, die Ansible erwartet
    6. Module in Python implementieren
       1. Parsing Argumente
       2. Zugriff auf Parameter
       3. Importieren der AnsibleModule Helper-Klasse
       4. Argument Optionen
       5. AnsibleModule Initialisierungsparameter
       6. Rückgabe Erfolg oder Misserfolg
       7. Aufrufen externer Befehle
       8. Prüfmodus (Trockenlauf)
    7. Dein Modul dokumentieren
    8. Dein Modul debuggen
    9. Das Modul in der Bash implementieren
    10. Einen alternativen Speicherort für die Bash festlegen
    11. Fazit
21. 20. Ansible noch schneller machen
    1. SSH Multiplexing und ControlPersist
       1. Manuelles Aktivieren von SSH-Multiplexing
       2. SSH-Multiplexing-Optionen in Ansible
    2. Mehr SSH-Tuning
       1. Algorithmus-Empfehlungen
    3. Pipelining
       1. Pipelining aktivieren
       2. Hosts für Pipelining konfigurieren
    4. Mitogen für Ansible
    5. Fakten-Caching
       1. JSON-Datei Fakten-Caching Backend
       2. Redis Fakten-Caching Backend
       3. Memcached Fakten-Caching Backend
    6. Parallelität
    7. Gleichzeitige Aufgaben mit Async
    8. Fazit
22. 21. Vernetzung und Sicherheit
    1. Netzwerkmanagement
       1. Unterstützte Anbieter
       2. Ansible Connection für Netzwerkautomatisierung
       3. Privilegierter Modus
       4. Netzwerk-Inventarisierung
       5. Anwendungsfälle der Netzwerkautomatisierung
    2. Sicherheit
       1. Mit der Compliance übereinstimmen?
       2. Gesichert, aber nicht sicher
       3. Schatten-IT
       4. Sonnenschein IT
       5. Null Vertrauen
    3. Fazit
23. 22. CI/CD und Ansible
    1. Kontinuierliche Integration
       1. Elemente in einem CI-System
       2. Jenkins und Ansible
       3. CI für Ansible-Rollen ausführen
    2. Inszenierung
    3. Ansible Plug-in
    4. Ansible Tower Plug-in
    5. Fazit
24. 23. Ansible Automatisierungsplattform
    1. Abonnement-Modelle
       1. Ansible Automation Platform Testversion
    2. Was die Ansible Automation Platform löst
       1. Zugriffskontrolle
       2. Projekte
       3. Inventarverwaltung
       4. Aufträge nach Auftragsvorlagen ausführen
    3. RESTful API
    4. AWX.AWX
       1. Installation
       2. Eine Organisation erstellen
       3. Eine Bestandsaufnahme erstellen
       4. Ein Playbook mit einer Auftragsvorlage ausführen
    5. Verwendung von Containern für Ansible
       1. Erstellen von Ausführungsumgebungen
    6. Fazit
25. 24. Bewährte Methoden
    1. Einfachheit, Modularität und Kompatibilität
    2. Inhalt organisieren
    3. Vorräte von Projekten entkoppeln
    4. Rollen und Kollektionen entkoppeln
    5. Spielbücher
    6. Code Stil
    7. Alle Dinge markieren und testen
    8. Gewünschter Zustand
    9. Kontinuierlich liefern
    10. Sicherheit
    11. Einsatz
    12. Leistungsindikatoren
    13. Benchmark-Beweise
    14. Letzte Worte
26. Bibliographie
27. Index
28. Über die Autoren