TOC

Implementieren des kontinuierlichen Testens von Ansible-Rollen mit Molecule und Travis CI unter Ubuntu 18.04

Der Autor hat dieMozilla Foundationausgewählt, um eine Spende im Rahmen desWrite for DOnations-Programms zu erhalten.

Einführung

Ansible ist ein agentenloses Konfigurationsmanagement-Tool, das YAML-Vorlagen verwendet, um eine Liste von Aufgaben zu definieren, die auf Hosts ausgeführt werden sollen. In Ansible sindroles eine Sammlung von Variablen, Aufgaben, Dateien, Vorlagen und Modulen, die zusammen verwendet werden, um eine einzelne, komplexe Funktion auszuführen.

Molecule ist ein Tool zum automatisierten Testen von Ansible-Rollen, das speziell zur Unterstützung der Entwicklung konsistent gut geschriebener und gepflegter Rollen entwickelt wurde. Mit den Unit-Tests von Molecule können Entwickler Rollen gleichzeitig in mehreren Umgebungen und unter verschiedenen Parametern testen. Es ist wichtig, dass Entwickler kontinuierlich Tests mit häufig geändertem Code ausführen. Dieser Workflow stellt sicher, dass Rollen weiterhin funktionieren, wenn Sie Codebibliotheken aktualisieren. Wenn Sie Molecule mit einem Tool zur kontinuierlichen Integration wieTravis CI ausführen, können Tests kontinuierlich ausgeführt werden, um sicherzustellen, dass Beiträge zu Ihrem Code keine wesentlichen Änderungen bewirken.

In diesem Tutorial verwenden Sie eine vorgefertigte Basisrolle, mit der ein Apache-Webserver und eine Firewall auf Ubuntu- und CentOS-Servern installiert und konfiguriert werden. Anschließend initialisieren Sie ein Molekülszenario in dieser Rolle, um Tests zu erstellen und sicherzustellen, dass die Rolle in Ihren Zielumgebungen wie vorgesehen ausgeführt wird. Nach der Konfiguration von Molecule verwenden Sie Travis CI, um Ihre neu erstellte Rolle fortlaufend zu testen. Jedes Mal, wenn eine Änderung an Ihrem Code vorgenommen wird, führt Travis CImolecule test aus, um sicherzustellen, dass die Rolle weiterhin ordnungsgemäß ausgeführt wird.

Voraussetzungen

Bevor Sie mit diesem Tutorial beginnen, benötigen Sie:

[[Schritt-1 -—- Forking-the-Base-Role-Repository]] == Schritt 1 - Forking des Base Role Repository

Sie verwenden eine vorgefertigte Rolle namensansible-apache, die Apache installiert und eine Firewall für Debian- und Red Hat-basierte Distributionen konfiguriert. Sie werden diese Rolle als Basis verwenden und dann darauf Molekulartests aufbauen. Mit Forking können Sie eine Kopie eines Repositorys erstellen, um Änderungen daran vorzunehmen, ohne das ursprüngliche Projekt zu manipulieren.

Erstellen Sie zunächst eine Verzweigung der Rolleansible-apache. Gehen Sie zum Repository vonansible-apacheund klicken Sie auf die SchaltflächeFork.

Sobald Sie das Repository gegabelt haben, werden Sie von GitHub zur Seite Ihres Gabels geleitet. Dies ist eine Kopie des Basis-Repositorys, jedoch auf Ihrem eigenen Konto.

Klicken Sie auf die grüne SchaltflächeClone or Download und Sie sehen ein Feld mitClone with HTTPS.

Kopieren Sie die angezeigte URL für Ihr Repository. Sie werden dies im nächsten Schritt verwenden. Die URL sieht ungefähr so ​​aus: 

https://github.com/username/ansible-apache.git

Sie werdenusername durch Ihren GitHub-Benutzernamen ersetzen.

Wenn Sie Ihren Fork eingerichtet haben, klonen Sie ihn auf Ihrem Server und bereiten Ihre Rolle im nächsten Abschnitt vor.

[[Schritt-2 - Vorbereitung Ihrer Rolle]] == Schritt 2 - Vorbereitung Ihrer Rolle

Nachdem Sie Schritt 1 der VoraussetzungHow To Test Ansible Roles with Molecule on Ubuntu 18.04 ausgeführt haben, werden Molecule und Ansible in einer virtuellen Umgebung installiert. Sie werden diese virtuelle Umgebung zum Entwickeln Ihrer neuen Rolle verwenden.

Aktivieren Sie zunächst die von Ihnen erstellte virtuelle Umgebung, während Sie die folgenden Voraussetzungen erfüllen: 

source my_env/bin/activate

Führen Sie den folgenden Befehl aus, um das Repository mithilfe der soeben in Schritt 1 kopierten URL zu klonen: 

git clone https://github.com/username/ansible-apache.git

Ihre Ausgabe sieht ungefähr so ​​aus: 

OutputCloning into 'ansible-apache'...
remote: Enumerating objects: 16, done.
remote: Total 16 (delta 0), reused 0 (delta 0), pack-reused 16
Unpacking objects: 100% (16/16), done.

In das neu erstellte Verzeichnis verschieben: 

cd ansible-apache

Die von Ihnen heruntergeladene Basisrolle führt die folgenden Aufgaben aus:

  • Includes variables: Die Rolle beginnt mit der Einbeziehung aller erforderlichenvariables entsprechend der Verteilung des Hosts. Ansible verwendet Variablen, um die Unterschiede zwischen verschiedenen Systemen zu behandeln. Da Sie Ubuntu 18.04 und CentOS 7 als Hosts verwenden, erkennt die Rolle, dass die Betriebssystemfamilien Debian bzw. Red Hat sind, und enthält Variablen vonvars/Debian.yml undvars/RedHat.yml.

  • Includes distribution-relevant tasks: Diese Aufgaben umfassentasks/install-Debian.yml undtasks/install-RedHat.yml. Abhängig von der angegebenen Distribution werden die relevanten Pakete installiert. Für Ubuntu sind diese Paketeapache2 undufw. Für CentOS sind diese Paketehttpd undfirewalld.

  • Ensures latest index.html is present: Diese Aufgabe kopiert eine Vorlagetemplates/index.html.j2, die Apache als Homepage des Webservers verwendet.

  • Starts relevant services and enables them on boot: Startet und aktiviert die erforderlichen Dienste, die im Rahmen der ersten Aufgabe installiert wurden. Für CentOS sind diese Dienstehttpd undfirewalld, und für Ubuntu sind sieapache2 undufw.

  • Configures firewall to allow traffic: Dies schließt entwedertasks/configure-Debian-firewall.yml odertasks/configure-RedHat-firewall.yml ein. Ansible konfiguriert entweder Firewalld oder UFW als Firewall und listet denhttp-Dienst auf.

Nachdem Sie verstanden haben, wie diese Rolle funktioniert, konfigurieren Sie Molecule, um sie zu testen. Sie werden Testfälle für diese Aufgaben schreiben, die die vorgenommenen Änderungen abdecken.

[[Schritt 3 - Schreiben Ihrer Tests]] == Schritt 3 - Schreiben Ihrer Tests

Um zu überprüfen, ob Ihre Basisrolle die beabsichtigten Aufgaben erfüllt, starten Sie ein Molekülszenario, geben Ihre Zielumgebungen an und erstellen drei benutzerdefinierte Testdateien.

Beginnen Sie mit der Initialisierung eines Molekülszenarios für diese Rolle mit dem folgenden Befehl: 

molecule init scenario -r ansible-apache

Sie werden die folgende Ausgabe sehen: 

Output--> Initializing new scenario default...
Initialized scenario in /home/sammy/ansible-apache/molecule/default successfully.

Sie fügen CentOS und Ubuntu als Zielumgebungen hinzu, indem Sie sie als Plattformen in Ihre Molecule-Konfigurationsdatei aufnehmen. Bearbeiten Sie dazu die Dateimolecule.ymlmit einem Texteditor: 

nano molecule/default/molecule.yml

Fügen Sie der Molekülkonfiguration den folgenden hervorgehobenen Inhalt hinzu:

~/ansible-apache/molecule/default/molecule.yml

---
dependency:
  name: galaxy
driver:
  name: docker
lint:
  name: yamllint
platforms:
  - name: centos7
    image: milcom/centos7-systemd
    privileged: true
  - name: ubuntu18
    image: solita/ubuntu-systemd
    command: /sbin/init
    privileged: true
    volumes:
      - /lib/modules:/lib/modules:ro
provisioner:
  name: ansible
  lint:
    name: ansible-lint
scenario:
  name: default
verifier:
  name: testinfra
  lint:
    name: flake8

Hier geben Sie zwei Zielplattformen an, die im privilegierten Modus gestartet werden, da Sie mit systemd-Diensten arbeiten:

  • centos7 ist die erste Plattform und verwendet das Bild vonmilcom/centos7-systemd.

  • ubuntu18 ist die zweite Plattform und verwendet das Bild vonsolita/ubuntu-systemd. Neben der Verwendung des privilegierten Modus und dem Mounten der erforderlichen Kernelmodule führen Sie beim Start/sbin/init aus, um sicherzustellen, dass iptables aktiv ist.

Speichern und schließen Sie die Datei.

Weitere Informationen zum Ausführen privilegierter Container finden Sie unterofficial Molecule documentation.

Anstatt die Standard-Molecule-Testdatei zu verwenden, erstellen Sie drei benutzerdefinierte Testdateien, eine für jede Zielplattform und eine Datei zum Schreiben von Tests, die für alle Plattformen gleich sind. Löschen Sie zunächst die Standardtestdateitest_default.py des Szenarios mit dem folgenden Befehl: 

rm molecule/default/tests/test_default.py

Sie können nun mit dem Erstellen der drei benutzerdefinierten Testdateientest_common.py,test_Debian.py undtest_RedHat.py für jede Ihrer Zielplattformen fortfahren.

Die erste Testdateitest_common.py enthält die allgemeinen Tests, die jeder Host ausführen wird. Erstellen und bearbeiten Sie die allgemeine Testdateitest_common.py: 

nano molecule/default/tests/test_common.py

Fügen Sie der Datei den folgenden Code hinzu:

~/ansible-apache/molecule/default/tests/test_common.py

import os
import pytest

import testinfra.utils.ansible_runner

testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
    os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('all')


@pytest.mark.parametrize('file, content', [
  ("/var/www/html/index.html", "Managed by Ansible")
])
def test_files(host, file, content):
    file = host.file(file)

    assert file.exists
    assert file.contains(content)

In Ihrertest_common.py-Datei haben Sie die erforderlichen Bibliotheken importiert. Sie haben auch einen Test namenstest_files() geschrieben, der die einzige gemeinsame Aufgabe zwischen Distributionen enthält, die Ihre Rolle ausführt: das Kopieren Ihrer Vorlage als Webserver-Homepage.

Die nächste Testdatei,test_Debian.py, enthält Tests, die für Debian-Distributionen spezifisch sind. Diese Testdatei richtet sich speziell an Ihre Ubuntu-Plattform.

Erstellen und bearbeiten Sie die Ubuntu-Testdatei, indem Sie den folgenden Befehl ausführen: 

nano molecule/default/tests/test_Debian.py

Sie können jetzt die erforderlichen Bibliotheken importieren und die Plattformubuntu18als Zielhost definieren. Fügen Sie dem Anfang dieser Datei den folgenden Code hinzu:

~/ansible-apache/molecule/default/tests/test_Debian.py

import os
import pytest

import testinfra.utils.ansible_runner

testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
    os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('ubuntu18')

Anschließend fügen Sie in derselben Datei den Test vontest_pkg()hinzu.

Fügen Sie der Datei den folgenden Code hinzu, der den Test vontest_pkg()definiert:

~/ansible-apache/molecule/default/tests/test_Debian.py

...
@pytest.mark.parametrize('pkg', [
    'apache2',
    'ufw'
])
def test_pkg(host, pkg):
    package = host.package(pkg)

    assert package.is_installed

Dieser Test prüft, ob die Paketeapache2 undufw auf dem Host installiert sind.

[.note] #Note: Wenn Sie einer Molecule-Testdatei mehrere Tests hinzufügen, stellen Sie sicher, dass zwischen jedem Test zwei Leerzeilen stehen. Andernfalls wird ein Syntaxfehler von Molecule.
# angezeigt.

Fügen Sie zum Definieren des nächsten Teststest_svc() den folgenden Code unter dem Testtest_pkg() in Ihre Datei ein:

~/ansible-apache/molecule/default/tests/test_Debian.py

...
@pytest.mark.parametrize('svc', [
    'apache2',
    'ufw'
])
def test_svc(host, svc):
    service = host.service(svc)

    assert service.is_running
    assert service.is_enabled

test_svc() prüft, ob die Diensteapache2 undufwausgeführt und aktiviert werden.

Schließlich fügen Sie Ihren letzten Testtest_ufw_rules() zur Dateitest_Debian.py hinzu.

Fügen Sie diesen Code unter dem Testtest_svc() in Ihrer Datei hinzu, umtest_ufw_rules() zu definieren:

~/ansible-apache/molecule/default/tests/test_Debian.py

...
@pytest.mark.parametrize('rule', [
    '-A ufw-user-input -p tcp -m tcp --dport 80 -j ACCEPT'
])
def test_ufw_rules(host, rule):
    cmd = host.run('iptables -t filter -S')

    assert rule in cmd.stdout

test_ufw_rules() überprüft, ob Ihre Firewall-Konfiguration Datenverkehr auf dem vom Apache-Dienst verwendeten Port zulässt.

Wenn jeder dieser Tests hinzugefügt wird, sieht die Datei vontest_Debian.pyfolgendermaßen aus:

~/ansible-apache/molecule/default/tests/test_Debian.py

import os
import pytest

import testinfra.utils.ansible_runner

testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
    os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('ubuntu18')


@pytest.mark.parametrize('pkg', [
    'apache2',
    'ufw'
])
def test_pkg(host, pkg):
    package = host.package(pkg)

    assert package.is_installed


@pytest.mark.parametrize('svc', [
    'apache2',
    'ufw'
])
def test_svc(host, svc):
    service = host.service(svc)

    assert service.is_running
    assert service.is_enabled


@pytest.mark.parametrize('rule', [
    '-A ufw-user-input -p tcp -m tcp --dport 80 -j ACCEPT'
])
def test_ufw_rules(host, rule):
    cmd = host.run('iptables -t filter -S')

    assert rule in cmd.stdout

Die Dateitest_Debian.py enthält jetzt die drei Tests:test_pkg(),test_svc() undtest_ufw_rules().

Speichern und beenden Sietest_Debian.py.

Als Nächstes erstellen Sie die Testdateitest_RedHat.py, die Tests enthält, die für Red Hat-Distributionen spezifisch sind und auf Ihre CentOS-Plattform abzielen.

Erstellen und bearbeiten Sie die CentOS-Testdateitest_RedHat.py, indem Sie den folgenden Befehl ausführen: 

nano molecule/default/tests/test_RedHat.py

Ähnlich wie bei der Ubuntu-Testdatei schreiben Sie jetzt drei Tests, die in die Dateitest_RedHat.pyaufgenommen werden sollen. Bevor Sie den Testcode hinzufügen, können Sie die erforderlichen Bibliotheken importieren und diecentos7-Plattform als Zielhost definieren, indem Sie den folgenden Code am Anfang Ihrer Datei hinzufügen:

~/ansible-apache/molecule/default/tests/test_RedHat.py

import os
import pytest

import testinfra.utils.ansible_runner

testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
    os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('centos7')

Fügen Sie dann den Testtest_pkg() hinzu, mit dem überprüft wird, ob die Paketehttpd undfirewalld auf dem Host installiert sind.

Fügen Sie nach dem Code für Ihre Bibliotheksimporte dentest_pkg()-Test zu Ihrer Datei hinzu. (Denken Sie auch hier daran, vor jedem neuen Test zwei Leerzeilen einzufügen.)

~/ansible-apache/molecule/default/tests/test_RedHat.py

...
@pytest.mark.parametrize('pkg', [
    'httpd',
    'firewalld'
])
def test_pkg(host, pkg):
    package = host.package(pkg)

      assert package.is_installed

Jetzt können Sie den Testtest_svc()hinzufügen, um sicherzustellen, dass die Dienstehttpd undfirewalldausgeführt und aktiviert werden.

Fügen Sie den Code vontest_svc()nach dem Test vontest_pkg()zu Ihrer Datei hinzu:

~/ansible-apache/molecule/default/tests/test_RedHat.py

...
@pytest.mark.parametrize('svc', [
    'httpd',
    'firewalld'
])
  def test_svc(host, svc):
    service = host.service(svc)

    assert service.is_running
    assert service.is_enabled

Der letzte Test intest_RedHat.py Datei isttest_firewalld(), wodurch überprüft wird, ob Firewalld über die Whitelist des Diensteshttpverfügt.

Fügen Sie dentest_firewalld()-Test nach demtest_svc()-Code zu Ihrer Datei hinzu:

~/ansible-apache/molecule/default/tests/test_RedHat.py

...
@pytest.mark.parametrize('file, content', [
    ("/etc/firewalld/zones/public.xml", "")
])
def test_firewalld(host, file, content):
    file = host.file(file)

    assert file.exists
    assert file.contains(content)

Nach dem Importieren der Bibliotheken und dem Hinzufügen der drei Tests sieht die Dateitest_RedHat.pyfolgendermaßen aus:

~/ansible-apache/molecule/default/tests/test_RedHat.py

import os
import pytest

import testinfra.utils.ansible_runner

testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
    os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('centos7')


@pytest.mark.parametrize('pkg', [
    'httpd',
    'firewalld'
])
def test_pkg(host, pkg):
    package = host.package(pkg)

    assert package.is_installed


@pytest.mark.parametrize('svc', [
    'httpd',
    'firewalld'
])
def test_svc(host, svc):
    service = host.service(svc)

    assert service.is_running
    assert service.is_enabled


@pytest.mark.parametrize('file, content', [
    ("/etc/firewalld/zones/public.xml", "")
])
def test_firewalld(host, file, content):
    file = host.file(file)

    assert file.exists
    assert file.contains(content)

Nachdem Sie die Schreibtests in allen drei Dateientest_common.py,test_Debian.py undtest_RedHat.py abgeschlossen haben, ist Ihre Rolle zum Testen bereit. Im nächsten Schritt verwenden Sie Molecule, um diese Tests für Ihre neu konfigurierte Rolle auszuführen.

[[Schritt 4 - Testen gegen Ihre Rolle]] == Schritt 4 - Testen gegen Ihre Rolle

Sie führen nun Ihre neu erstellten Tests mit Molecule für die Basiserolleansible-apache aus. Verwenden Sie den folgenden Befehl, um Ihre Tests auszuführen: 

molecule test

Sobald Molecule alle Tests ausgeführt hat, wird die folgende Ausgabe angezeigt: 

Output...
--> Scenario: 'default'
--> Action: 'verify'
--> Executing Testinfra tests found in /home/sammy/ansible-apache/molecule/default/tests/...
    ============================= test session starts ==============================
    platform linux -- Python 3.6.7, pytest-4.1.1, py-1.7.0, pluggy-0.8.1
    rootdir: /home/sammy/ansible-apache/molecule/default, inifile:
    plugins: testinfra-1.16.0
collected 12 items

    tests/test_common.py ..                                                  [ 16%]
    tests/test_RedHat.py .....                                               [ 58%]
    tests/test_Debian.py .....                                               [100%]

    ========================== 12 passed in 80.70 seconds ==========================
Verifier completed successfully.

In Ihrer Ausgabe wirdVerifier completed successfully angezeigt. Dies bedeutet, dass der Prüfer alle Ihre Tests ausgeführt und erfolgreich zurückgegeben hat.

Nachdem Sie die Entwicklung Ihrer Rolle erfolgreich abgeschlossen haben, können Sie Ihre Änderungen in Git übernehmen und Travis CI für fortlaufende Tests einrichten.

[[Schritt 5 - Verwenden von Git, um Ihre aktualisierte Rolle zu teilen]] == Schritt 5 - Verwenden von Git, um Ihre aktualisierte Rolle zu teilen

In diesem Tutorial haben Sie bisher eine Rolle namensansible-apache geklont und Tests hinzugefügt, um sicherzustellen, dass sie gegen Ubuntu- und CentOS-Hosts funktioniert. Um Ihre aktualisierte Rolle für die Öffentlichkeit freizugeben, müssen Sie diese Änderungen festschreiben und auf Ihren Zweig übertragen.

Führen Sie den folgenden Befehl aus, um die Dateien hinzuzufügen und die vorgenommenen Änderungen zu übernehmen: 

git add .

Dieser Befehl fügt alle Dateien, die Sie im aktuellen Verzeichnis geändert haben, zum Staging-Bereich hinzu.

Sie müssen auch Ihren Namen und Ihre E-Mail-Adresse ingit config festlegen, um eine erfolgreiche Festschreibung durchzuführen. Sie können dazu die folgenden Befehle verwenden: 

git config user.email "[email protected]"
git config user.name "John Doe"

Übernehmen Sie die geänderten Dateien in Ihr Repository: 

git commit -m "Configured Molecule"

Sie sehen die folgende Ausgabe: 

Output[master b2d5a5c] Configured Molecule
 8 files changed, 155 insertions(+), 1 deletion(-)
 create mode 100644 molecule/default/Dockerfile.j2
 create mode 100644 molecule/default/INSTALL.rst
 create mode 100644 molecule/default/molecule.yml
 create mode 100644 molecule/default/playbook.yml
 create mode 100644 molecule/default/tests/test_Debian.py
 create mode 100644 molecule/default/tests/test_RedHat.py
 create mode 100644 molecule/default/tests/test_common.py

Dies bedeutet, dass Sie Ihre Änderungen erfolgreich übernommen haben. Übertragen Sie diese Änderungen nun mit dem folgenden Befehl auf Ihre Gabel: 

git push -u origin master

Sie werden aufgefordert, Ihre GitHub-Anmeldeinformationen einzugeben. Nachdem Sie diese Anmeldeinformationen eingegeben haben, wird Ihr Code in Ihr Repository übertragen und Sie sehen die folgende Ausgabe: 

OutputCounting objects: 13, done.
Compressing objects: 100% (12/12), done.
Writing objects: 100% (13/13), 2.32 KiB | 2.32 MiB/s, done.
Total 13 (delta 3), reused 0 (delta 0)
remote: Resolving deltas: 100% (3/3), completed with 2 local objects.
To https://github.com/username/ansible-apache.git
   009d5d6..e4e6959  master -> master
Branch 'master' set up to track remote branch 'master' from 'origin'.

Wenn Sie beigithub.com/username/ansible-apache zum Repository Ihres Forks wechseln, wird ein neues Commit mit dem NamenConfigured Molecule angezeigt, das die Änderungen widerspiegelt, die Sie in den Dateien vorgenommen haben.

Jetzt können Sie Travis CI in Ihr neues Repository integrieren, sodass alle an Ihrer Rolle vorgenommenen Änderungen automatisch Molekültests auslösen. Dadurch wird sichergestellt, dass Ihre Rolle immer mit Ubuntu- und CentOS-Hosts funktioniert.

[[Schritt-6 - Integration von Travis-CI]] == Schritt 6 - Integration von Travis CI

In diesem Schritt integrieren Sie Travis CI in Ihren Workflow. Einmal aktiviert, lösen alle Änderungen, die Sie an Ihrer Gabel vornehmen, einen Travis CI-Build aus. Damit soll sichergestellt werden, dass Travis CI immermolecule test ausführt, wenn Mitwirkende Änderungen vornehmen. Wenn wichtige Änderungen vorgenommen werden, wird Travis den Build-Status als solchen deklarieren.

Fahren Sie mitTravis CI fort, um Ihr Repository zu aktivieren. Navigieren Sie zu Ihrer Profilseite, auf der Sie auf die SchaltflächeActivate für GitHub klicken können.

Weitere Anleitungenhere zum Aktivieren von Repositorys in Travis CI finden Sie.

Damit Travis CI funktioniert, müssen Sie eine Konfigurationsdatei mit Anweisungen dafür erstellen. Kehren Sie zum Erstellen der Travis-Konfigurationsdatei zu Ihrem Server zurück und führen Sie den folgenden Befehl aus: 

nano .travis.yml

Um die in diesem Lernprogramm erstellte Umgebung zu duplizieren, geben Sie Parameter in der Travis-Konfigurationsdatei an. Fügen Sie Ihrer Datei den folgenden Inhalt hinzu:

~/ansible-apache/.travis.yml

---
language: python
python:
  - "2.7"
  - "3.6"
services:
  - docker
install:
  - pip install molecule docker
script:
  - molecule --version
  - ansible --version
  - molecule test

Die Parameter, die Sie in dieser Datei angegeben haben, sind:

  • language: Wenn Sie Python als Sprache angeben, verwendet die CI-Umgebung für jede Python-Version, die Sie unter dem Schlüsselpythonangeben, separatevirtualenv-Instanzen.

  • python: Hier geben Sie an, dass Travis sowohl Python 2.7 als auch Python 3.6 verwendet, um Ihre Tests auszuführen.

  • services: Sie benötigen Docker, um Tests in Molecule auszuführen. Sie geben an, dass Travis sicherstellen soll, dass Docker in Ihrer CI-Umgebung vorhanden ist.

  • install: Hier geben Sie vorbereitende Installationsschritte an, die Travis CI in Ihrenvirtualenv ausführen wird.

    • pip install molecule docker, um zu überprüfen, ob Ansible und Molecule zusammen mit der Python-Bibliothek für die Docker-Remote-API vorhanden sind.

  • script: Hiermit werden die Schritte angegeben, die Travis CI ausführen muss. In Ihrer Datei geben Sie drei Schritte an:

    • molecule --version druckt die Molecule-Version, wenn Molecule erfolgreich installiert wurde.

    • ansible --version druckt die Ansible-Version, wenn Ansible erfolgreich installiert wurde.

    • molecule test führt schließlich Ihre Molekültests aus.

Der Grund, warum Siemolecule --version undansible --version angeben, besteht darin, Fehler abzufangen, falls der Build aufgrund einer Fehlkonfiguration vonansible odermoleculeaufgrund der Versionierung fehlschlägt.

Speichern und beenden Sie.travis.yml, sobald Sie den Inhalt zur Travis CI-Konfigurationsdatei hinzugefügt haben.

Jetzt führt Travis CI jedes Mal, wenn Sie Änderungen an Ihrem Repository vornehmen, automatisch einen Build basierend auf der obigen Konfigurationsdatei aus. Wenn einer der Befehle im Blockscriptfehlschlägt, meldet Travis CI den Build-Status als solchen.

Um das Anzeigen des Build-Status zu vereinfachen, können Sie denREADMEIhrer Rolle ein Abzeichen hinzufügen, das den Build-Status angibt. Öffnen Sie die DateiREADME.mdmit einem Texteditor: 

nano README.md

Fügen Sie denREADME.md die folgende Zeile hinzu, um den Build-Status anzuzeigen:

~/ansible-apache/README.md

[![Build Status](https://travis-ci.org/username/ansible-apache.svg?branch=master)](https://travis-ci.org/username/ansible-apache)

Ersetzen Sieusername durch Ihren GitHub-Benutzernamen. Übernehmen und übertragen Sie die Änderungen wie zuvor in Ihr Repository.

Führen Sie zunächst den folgenden Befehl aus, um.travis.yml undREADME.md zum Staging-Bereich hinzuzufügen: 

git add .travis.yml README.md

Übernehmen Sie nun die Änderungen in Ihr Repository, indem Sie Folgendes ausführen: 

git commit -m "Configured Travis"

Zum Schluss übertragen Sie diese Änderungen mit dem folgenden Befehl an Ihre Gabel: 

git push -u origin master

Wenn Sie zu Ihrem GitHub-Repository navigieren, werden Sie feststellen, dass zunächstbuild: unknown gemeldet werden.

build-status-unknown

Innerhalb weniger Minuten startet Travis einen Build, den Sie auf der Travis CI-Website überwachen können. Sobald der Build erfolgreich abgeschlossen wurde, meldet GitHub den Status auch in Ihrem Repository. Verwenden Sie dazu das in Ihrer README-Datei abgelegte Abzeichen:

build-status-passing

Sie können auf die vollständigen Details der Builds zugreifen, indem Sie die Travis CI-Website aufrufen:

travis-build-status

Nachdem Sie Travis CI erfolgreich für Ihre neue Rolle eingerichtet haben, können Sie kontinuierlich Änderungen an Ihren Ansible-Rollen testen und integrieren.

Fazit

In diesem Lernprogramm haben Sie eine Rolle aufgeteilt, mit der ein Apache-Webserver von GitHub installiert und konfiguriert wird, und Integrationen für Molecule hinzugefügt, indem Sie Tests geschrieben und diese Tests für Docker-Container konfiguriert haben, auf denen Ubuntu und CentOS ausgeführt werden. Indem Sie Ihre neu erstellte Rolle an GitHub übertragen, haben Sie anderen Benutzern den Zugriff auf Ihre Rolle ermöglicht. Wenn sich Ihre Rolle durch Mitwirkende ändert, führt Travis CI automatisch Molecule aus, um Ihre Rolle zu testen.

Sobald Sie mit dem Erstellen von Rollen und dem Testen mit Molecule vertraut sind, können Sie diese inAnsible Galaxy integrieren, sodass Rollen nach erfolgreichem Build automatisch verschoben werden.

Related