Ansіble-Tutorial: Meistern Sie das leichtgewichtige Software-Konfigurationsmanagement-Tool

Ihr Leitfaden für das beliebte DevOps-Konfigurationsmanagement-Tool - von Playbooks bis zu Filtern

AgileUPDATED ON März 30, 2022

cover image for blog post on ansible and case study

Dieses Ansible-Tutorial führt Sie Schritt für Schritt durch die Installation und Einrichtung dieses unglaublich nützlichen Open-Source-Tools aus dem Hause RedHat. Außerdem gehen wir auf die wichtigsten Ansible-Funktionen und -Komponenten ein, darunter:

  • Ansible Playbooks
  • Ansible-Tags
  • Ansible-Handler
  • Ansible-Variablen
  • Ansible-Fakten
  • Ansible Bedingungen
  • Ansible-Filter

Am Ende des Tutorials werden Sie Ihr eigenes automatisiertes Konfigurationsmanagement eingerichtet haben und sind in der Lage, dies in verschiedenen Umgebungen zu wiederholen. Doch bevor wir uns mit der Installation, der Einrichtung und den Details der Verwendung von Ansible beschäftigen, werfen wir einen kurzen Blick auf die Rolle, die das Tool für die Bereitstellung, das Konfigurationsmanagement und die Anwendungsbereitstellung als Teil einer DevOps-Architektur spielt, um Infrastruktur als Code zu ermöglichen.

Agile und DevOps-Entwickler, Teamverstärkung und Berater

Nach Ihren individuellen Bedürfnissen!

Die Rolle von Ansible in der automatischen Konfigurationsverwaltung als Teil einer DevOps-Architektur

Ansible, ursprünglich von Michael DeHaan geschrieben und 2015 von RedHat übernommen, spielt eine Schlüsselrolle in der DevOps-Architektur, da es ein automatisiertes Softwarekonfigurationsmanagement ermöglicht. Ansible ist eine wunderbar einfache und leichtgewichtige DevOps-Automatisierungs-Engine, die Produktivitätssteigerungen bei der Automatisierung der Bereitstellung von Cloud-Ressourcen, der Implementierung und der Orchestrierung von Kubernetes-Clustern ermöglicht (lesen Sie auch unser Schritt-für-Schritt-Tutorial zur Implementierung von Ceph in Kubernetes mit Ceph-Ansible).

Der große Pluspunkt von Ansible liegt darin, dass es so einfach zu bedienen ist, und dennoch genug Power hat, um eine komplexe Multi-Tier-Anwendungsumgebung zu automatisieren.

Obwohl Ansible, wie bereits erwähnt, auch für die Bereitstellung und das Deployment von Anwendungen eingesetzt werden kann, um Infrastructure-as-Code zu ermöglichen, liegt der Schwerpunkt dieses Ansible-Tutorials auf seiner Rolle im Konfigurationsmanagement. Das Konfigurationsmanagement unterstützt DevOps-Effizienzgewinne, indem es ansonsten mühsame manuelle Aufgaben automatisiert, die die Produktivität und Agilität beeinträchtigen, da sie Zeit und Ressourcen verbrauchen und das Potenzial für menschliche Fehler bergen.

Ansible von RedHat ist nicht das einzige Tool für das Softwarekonfigurationsmanagement, das DevOps-Teams zur Verfügung steht, aber nach dem Testen mehrerer Tools in verschiedenen Projekten (Terraform von Hashicorp, Puppet und Chef sowie die nativen AWS-Optionen haben alle ihre Stärken und Anwendungsfälle) haben wir uns bei K&C für Ansible als Standardlösung entschieden. Es ist die leichteste Möglichkeit – außerdem ist ein weiterer großer Vorteil von Ansible, dass das Tool keine Client-Server-Implementierung erfordert.

Das Video unten ist ein großartiges Ansible-Tutorial für Anfänger, wenn Sie glauben, dass Sie von allgemeineren Informationen über die Qualitäten und Anwendungsfälle von Ansible profitieren würden.

Vorteile des automatisierten Konfigurationsmanagements in DevOps

Ein automatisiertes Konfigurationsmanagement mit Ansible als Teil Ihrer DevOps-Praktiken bringt die folgenden Hauptvorteile:

Effizienzsteigerung

Bessere Kontrolle als direkte Folge der verbesserten Sichtbarkeit und Nachverfolgung.

Kosteneinsparungen

Unnötige Duplizierung von Konfigurationselementen verschlingt Ressourcen. Manuelles Konfigurationsmanagement ist mühsam und repetitiv und erhöht das Risiko menschlicher Fehler, was sich ebenfalls auf die Kosten eines Entwicklungsprojekts auswirkt.

Schnellere Problemlösung

Hebt Probleme hervor, sobald sie auftreten, und ermöglicht so ein schnelles Eingreifen.

Verbesserte System- und Prozesszuverlässigkeit

Durch die rechtzeitige Erkennung und Anpassung von Problemkonfigurationen wird vermieden, dass sich diese negativ auf die Leistung auswirken und die Cloud-Ressourcen ineffizient genutzt werden.

Verbessertes Änderungsmanagement

Reduziert das Risiko von Produktinkompatibilitäten und anderen potenziellen Problemen.

Schnellere Systemwiederherstellung

Wenn es zu einem Prozessausfall kommt, wird die Wiederherstellung durch die Kenntnis des erforderlichen Konfigurationszustands wesentlich schneller und einfacher.

Risiken eines nicht automatisierten Konfigurationsmanagements

Überschreitung des Budgets

Wird die Einrichtung eines automatisierten Konfigurationsmanagements mit Ansible oder einem alternativen Tool vernachlässigt oder falsch durchgeführt, besteht die Gefahr, dass das Budget aus dem Ruder läuft. Ungeplante Zeit und Ressourcen, die für Interventionen aufgewendet werden, wenn Dinge aufgrund von Qualitäts- und Terminproblemen schief laufen, können die Kosten schnell in die Höhe treiben.

Brandbekämpfung“ wird zur Norm

Korrekturmaßnahmen oder Brandbekämpfung können für Teams ohne starke DevOps-Automatisierungsprozesse und -Standards zu einer Standardarbeitsweise werden. Dies ist ein massives Energievakuum, das die Gesamtproduktivität stark beeinträchtigen und die Qualität ernsthaft gefährden kann.

Aber damit sind die Unkenrufe aus dem Weg geräumt! Da Sie hier sind, haben Sie in automatisiertes Softwarekonfigurationsmanagement investiert und sich entweder für Ansible als Tool Ihrer Wahl entschieden oder ziehen es in Betracht. Konzentrieren wir uns also auf die Vorteile, die sich daraus ergeben, und richten Sie sich ein!

Können wir Ihnen bei Ihrem nächsten Softwareentwicklungsprojekt helfen?

Flexible Modelle für Ihre Bedürfnisse!

Ansible-Tutorial: Einrichten, Playbooks, Tags, Handler, Variablen, Fakten, Bedingungen und Filter

Ein großes Plus von Ansible ist, dass die Lernkurve des Tools nicht steil ist und die Installation und Einrichtung relativ einfach ist. Das heißt aber nicht, dass es nicht noch einfacher geht, wenn Sie unserer detaillierten Schritt-für-Schritt-Anleitung folgen. Also, fangen wir an und sehen wir uns an, wie es funktioniert.

Set-Up

Wir richten Ansible auf dem lokalen Rechner ein. Hier verwende ich Fedora release 22.

dnf install ansible

DNF

ist ein neuer Paketmanager, der yum ersetzen soll.

Das Einfachste, was Ansible tun kann, ist, Befehle auf Servern auszuführen. Um dies zu tun, lassen Sie uns in die Befehlszeile schreiben:

ansible all -i inventories/test.ini -u roman -m ping

ein Befehl, der für die Server in der Inventardatei ausgeführt wird

-i ein Pfad zur Inventardatei

-u ein Benutzer, unter dem wir auf die Server zugreifen werden

 

all  ein Befehl, der für die Server in der inventory Datei ausgeführt wird

-i   ein Pfad zur inventory Datei

-u   ein Benutzer, unter dem wir auf die Server zugreifen werden 

-m  module

Sie können auch jeden beliebigen Befehl „arbitrary command“ ausführen:

ansible all -i inventories/test.ini -u roman -a 'date'

Displaying:

62.244.31.234 | success | rc=0 >> 

Wed Jun 29 06:20:19 EDT 2015 

62.244.31.235 | success | rc=0 >>

Wed Jun 29 06:20:19 EDT 2015

-a arbitrary command

The inventory file is a list of servers and groups

cat inventories/test.ini
 
[test1]
62.244.31.234
[test2]
62.244.31.235

ip, domaine     Liste von Servern

test1, test2     Gruppen 

Wenn Sie folgendens ausführen:

ansible test1 -i inventories/test.ini -u roman -a 'date'

Sehen Sie:

62.244.31.234 | success | rc=0 >>

Wed Jun 29 06:31:10 EDT 2015

Der Befehl gilt nur für die Server einer bestimmten Gruppe.

Playbooks

Ein playbook ist eines der wichtigsten Konzepte in Ansible und bezieht sich auf die Dateien, in denen der Ansible-Code geschrieben wird. Playbooks sind YAML-Dateien, in denen wir mithilfe von Skripten angeben, welche Aktionen auf den Servern ausgeführt werden müssen. Zum Beispiel:

- hosts: docker
 
  - name: Installing Docker
    yum: name=docker state=latest
    become: yes
   
  - name: Uninstaling Software
    yum: name=sendmail state=absent
    become: yes

Im obigen Beispiel installieren wir das Docker-Paket für die Gruppe der Docker-Hosts und entfernen die Sendmail-Pakete

name      Eine beliebige Bezeichnung für die task / Aufgabe

yum        yum Modul

become    Wechsel des Benutzers zum Superuser

Wenn das Playbook sehr groß wird und wir eine Aktion ausführen müssen, die sich irgendwo am Ende der Datei befindet, dann müssen wir eine ganze Weile warten.

Das Video-Tutorial hier ist eine gute Erklärung von Ansible-Playbooks und warum das Tool besonders gut mit Docker funktioniert.

Tags

Um die Wartezeit zu verkürzen, bietet Ansible Tags an. Tags sind ein Attribut, das einer Ansible-Struktur (Playbacks, Rollen, Aufgaben) zugewiesen werden kann. Sobald Tags oder Skip-Tags konfiguriert wurden, führen sie eine Teilmenge von Aufgaben aus oder überspringen sie, wenn Sie ein Playbook ausführen. Das bedeutet, dass das Playbook nur das ausführt, was Sie möchten. Zum Beispiel:

    copy: src={{ files_path }}/docker/docker-storage dest=/etc/sysconfig/docker-storage
    become: yes
    tags: copy_config

Folgendes in die Command line schreiben:

ansible-playbook --check inventories/docker.yml -i inventory.ini -t copy_config

PLAY [docker] *****************************************************************

GATHERING FACTS ***************************************************************

ok: [docker_ci]

TASK: [Copying docker-storage config] *****************************************

ok: [docker_ci]

PLAY RECAP ********************************************************************

docker_ci : ok=2 changed=0 unreachable=0 failed=0

ansible-playbook --check docker.yml -i inventory.ini -t copy_config --skip-tags

-check     Prüfen, aber keine Änderungen vornehmen

-t            Tag

-skip-tags  Führt alle Aufgaben aus, außer denen, die angegeben sind

Tags kann auch wie folgt angegeben werden:

 - name: Copying docker-storage config
    copy: src={{ files_path }}/docker/docker-storage dest=/etc/sysconfig/docker-storage
    become: yes
    tags: [docker, config]

Das nachstehende Video-Tutorial ist eine nützliche Ressource, die Ihnen zeigt, wie Sie mithilfe von Tags nur bestimmte Aufgaben in einem Playbook ausführen können:

Handlers

Manchmal müssen Sie den Dienst neu starten, nachdem Sie einige Änderungen vorgenommen haben. Hierfür gibt es in Ansible HandlerHandler werden ganz am Ende des Playbooks ausgeführt, da ein Playbook viele Aufgaben enthalten kann, die den Dienst neu starten.

- name: Copying nginx config
  template: src={{ templates_path }}/nginx/nginx.conf.j2 dest=/etc/nginx/nginx.conf
  become: yes
  notify:
      - nginx restart
  tags: copy_nginx_config
 
 handlers:
    - name: nginx restart
      service: name=nginx state=restarted
      become: yes

notify gibt den Namen des Handlers an

Das folgende Video-Tutorial konzentriert sich speziell auf die Verwendung von Ansible-Handlern:

Variables

Ansible hat Variablen. Variablen werden in Ansible verwendet, um Unterschiede zwischen Systemen zu verwalten. Das Tool ermöglicht es Ihnen, Aufgaben und Playbooks auf mehreren Systemen mit einem einzigen Befehl auszuführen, und die Erstellung von Variablen ermöglicht die Darstellung von Variationen zwischen dem, was auf verschiedenen Systemen ausgeführt wird. Sie werden mit der standardmäßigen YAML-Syntax, einschließlich Listen und Wörterbüchern, erstellt.

To omit the same values, let’s ​​define the variables:

- hosts: docker
  vars:
    files_path: /path/to/file
 
  - name: Copying docker-storage config
    copy: src={{ files_path }}/docker/docker-storage dest=/etc/sysconfig/docker-storage
    become: yes

{{}} Variables are defined in such brackets

Weitere Informationen über die Verwendung von Variablen in Ansible-Playbooks finden Sie hier:

Facts

Ansible-Facts/Fakten sind Variablen, die von entfernten Systemen abgerufen werden und Informationen über die Server sowie IP-Adressen, installierte Betriebssysteme, Ethernet-Geräte, Mac-Adressen, zeit- und datumsbezogene Daten und Hardware-Informationen enthalten. Um die Fakten über eine bestimmte Maschine zu sehen, schreiben wir:

ansible test1 -i inventories/test.ini -m setup

62.244.31.234 | success >> {

«ansible_facts»: {

«ansible_all_ipv4_addresses»: [

«62.244.31.234»

],

«ansible_all_ipv6_addresses»: [],

«ansible_architecture»: «x86_64»,

«ansible_bios_date»: «NA»,

«ansible_bios_version»: «NA»,

«ansible_cmdline»: {

«quiet»: true

},

«ansible_date_time»: {

«date»: «2015-08-25»,

«day»: «25»,

«epoch»: «1440503957»,

«hour»: «07»,

«iso8601»: «2015-08-25T11:59:17Z»,

«iso8601_micro»: «2015-08-25T11:59:17.235193Z»,

«minute»: «59»,

«month»: «08»,

«second»: «17»,

«time»: «07:59:17»,

«tz»: «EDT»,

«tz_offset»: «-0400»,

«weekday»: «Вторник»,

«year»: «2015»

}

……………..

Facts werden jedes Mal gesammelt, wenn Ansible ausgeführt wird. Wenn Sie gather_facts:no im playbook angeben, werden die Fakten nicht gesammelt:

---
- hosts: docker
  gather_facts: no
 
  tasks:
  - name: Adding epel repo
    copy: src={{ files_path }}/repo/epel.repo dest={{ repos }}/epel.repo
    become: yes
    when: ansible_distribution == "CentOS" and ansible_distribution_major_version == "7"
    tags: epel_repo

Wir sollten die cycles (Zyklen) im Auge behalten, da man oft viele Pakete installieren muss, was das Playbook mit mehreren ähnlichen Aufgaben überfordert. Hierfür bietet Ansible den Schlüssel with_items:

- name: Installing basic packages
    yum: name={{ item }} state=latest
    with_items:
        - mc
        - nano
        - atop
        - htop
        - iptraf-ng

Es gibt noch eine weitere Möglichkeit der Verwendung, indem mehrere Parameter angewendet werden:

tasks:
  - name: Adding users
    user: name={{ item.name }} state=present group={{ item.group }}
    with_items: 
      - { name: testuser1, group: test }
      - { name: testuser2, group: test }
    become: yes

In diesem Video-Tutorial werden sowohl die Ansible-facts als auch die variables ausführlich behandelt:

Conditions / Bedingungen

Ansible-Playbooks können mehrere Sätze von Variablen enthalten, die für unterschiedliche Aufgaben zuständig sind. Bei einer Mischung von Variablen, die jeweils verschiedene Einheiten wie Software, Server, Netzwerkgeräte usw. repräsentieren, kommen bedingte Anweisungen ins Spiel.

Ansible verwendet die „when“-Bedingung, um das Ergebnis einer Variablen zu bestimmen, anstelle der „if-else“-Anweisungen in Standardprogrammiersprachen. Die grundlegende Verwendung der when-Bedingung steuert, ob eine Aufgabe oder Rolle ausgeführt oder übersprungen wird. Dies wird am häufigsten verwendet, um das Spielverhalten auf der Grundlage von Fakten aus dem Zielsystem zu ändern.

Wenn die Bedingung erfüllt ist, führt der Task die When-Bedingung aus:

tasks:
  - name: "shutdown Debian flavored systems"
    command: /sbin/shutdown -t now
    when: ansible_os_family == "Debian"
 
tasks:
  - name: "shutdown CentOS 6 and 7 systems"
    command: /sbin/shutdown -t now
    when: ansible_distribution == "CentOS" and
          (ansible_distribution_major_version == "6" or ansible_distribution_major_version == "7")

Das folgende Video-Tutorial ist eine hervorragende zusätzliche Anleitung zur Verwendung einer einfachen When-Klausel als Ansible-Bedingung:

Filters / Filter

Ansible verfügt auch über filters, die die Manipulation von Daten ermöglichen. Mit Filtern können Sie z. B. JSON-Daten in YAML-Daten umwandeln, URLs aufteilen, um Hostnamen zu extrahieren, ganze Zahlen addieren oder multiplizieren oder sogar den SHA1-Hash eines Strings ermitteln. Das ansible-base Repo bietet Filter als Plug-ins an und Sie können sogar Ihre eigenen Plug-in-Filter erstellen.

---
- hosts: localhost
  vars:
    numbers: [ 4, 9, 6, 8, 2, 9 ]
    path: /etc/passwd
 
  tasks:
  - debug: msg={{numbers | min }}
  - debug: msg={{numbers | max }}
  - debug: msg={{numbers | unique }}
 
  - debug: msg={{ ['a', 'b', 'c' ] | random }}
 
  - debug: msg={{ path | basename }}
  - debug: msg={{ path | dirname }}
 
  - debug: msg={{ "~/Documents" | expanduser }}

GATHERING FACTS ***************************************************************

ok: [localhost]

TASK: [debug msg={{numbers | min }}] ******************************************

ok: [localhost] => {

«msg»: «2»

}

TASK: [debug msg={{numbers | max }}] ******************************************

ok: [localhost] => {

«msg»: «9»

}

TASK: [debug msg={{numbers | unique }}] ***************************************

ok: [localhost] => {

«msg»: «[4,»

}

TASK: [debug msg=b] ***********************************************************

ok: [localhost] => {

«msg»: «a»

}

TASK: [debug msg={{ path | basename }}] ***************************************

ok: [localhost] => {

«msg»: «passwd»

}

TASK: [debug msg={{ path | dirname }}] ****************************************

ok: [localhost] => {

«msg»: «/etc»

}

TASK: [debug msg=/home/roman/Documents] ***************************************

ok: [localhost] => {

«msg»: «/home/roman/Documents»

}

min           Displays the minimum value

max          Displays the maximum value

unique        Displays the unique value

random       Displays a random value

basename     Displays the file name

dirname      Displays the directory name

expanduser   Discloses tildes

Registration of the results:

tasks:
  - shell: ls /home
    register: home_dirs
 
  - debug: var=home_dirs

TASK: [debug var=home_dirs] ***************************************************

ok: [localhost] => {

«var»: {

«home_dirs»: {

«changed»: true,

«cmd»: «ls /home»,

«delta»: «0:00:00.004283»,

«end»: «2015-08-25 16:35:28.429512»,

«invocation»: {

«module_args»: «ls /home»,

«module_name»: «shell»

},

«rc»: 0,

«start»: «2015-08-25 16:35:28.425229»,

«stderr»: «»,

«stdout»: «lost+foundnromanntestntestuser1ntestuser2»,

«stdout_lines»: [

«lost+found»,

«roman»,

«test»,

«testuser1»,

«testuser2»

],

«warnings»: [] }

}

}

 

Jetzt übernehmen wir den Wert aus stdout_lines

 tasks:
  - shell: ls /home
    register: home_dirs
 
  - debug: var=home_dirs 
 
  - name: Adding home dirs to cron
    cron: name="Backup" minute="0" hour="6,3" job="backup_dir /home/{{ item }}"
    with_items: home_dirs.stdout_lines

Weitere Anwendungsfälle und Details finden Sie in der Ansible-Dokumentation über die Verwendung von Filtern zur Datenmanipulation.

Wenn Ihr Playbook zu groß wird, können Sie Teile in andere Dateien entfernen:

Wenn Ihr playbook zu groß wird, können Sie Teile in andere Dateien entfernen:

---
- hosts: docker
  vars_files:
  - ../vars/basic_vars.yml
 
  tasks:
  - include: includes/basic.yml
 
  handlers:
  - include: includes/handlers.yml
 
- include: includes/httpd_servers.yml

The inclusions are an ordinary YAML file:

cat includes/basic.yml

— name: Uninstaling Software

yum: name={{ item }} state=absent

with_items:

— sendmail

— exim

— httpd

become: yes

K&C: Ihre flexible DevOps-Outsourcing- und Beratungsressource

K&C bietet DevOps-Teams Outsourcing- und Beratungsdienstleistungen an. Als IT-Outsourcer mit Sitz in München und mehr als 20 Jahren Erfahrung sowie Nearshored-Tech-Talentzentren in Krakau, Kiew, Minsk und Sofia haben wir mit einigen der größten europäischen Marken, KMUs und spannenden Start-ups zusammengearbeitet.

Seit mehr als zwei Jahrzehnten unterstützen wir den digitalen Erfolg unserer Partner, indem wir uns an die einfache Verpflichtung halten, unsere exzellente Technologie mit exzellentem Kommunikations- und Liefermanagement zu verbinden. Unsere Aufgabe ist es, dafür zu sorgen, dass Sie eine Sorge weniger haben: hervorragende IT-Produkte und -Dienstleistungen, damit Sie sich auf das konzentrieren können, was Sie am besten können. Das technologische Know-how, das Sie brauchen, wenn Sie es brauchen. Skalieren Sie Ihre IT-Ressourcen ohne Overheadkosten nach oben und unten.

K&C - Wir schaffen innovative Tech-Lösungen seit über 20 Jahren.

Kontaktieren Sie uns, um Ihre individuellen Bedürfnisse oder Ihr nächstes Projekt zu diskutieren.