TOC

So konfigurieren Sie Apache mit Ansible unter Ubuntu 14.04

Einführung

  • Apache * ist einer der beliebtesten Webserver, die derzeit im Internet verwendet werden. Es ist einfach, Linux-Distributionen wie Ubuntu und Debian einzurichten und zu konfigurieren, da es in den Paket-Repositorys enthalten ist und eine Standardkonfiguration enthält, die sofort einsatzbereit ist.

  • Ansible * ist ein Automatisierungstool, mit dem Sie Systeme aus der Ferne konfigurieren, Software installieren und komplexe Aufgaben auf einer großen Serverflotte ausführen können, ohne sich jeweils manuell anmelden zu müssen. Im Gegensatz zu anderen Alternativen wird Ansible auf einem einzelnen Host installiert, der sogar Ihr lokaler Computer sein kann, und verwendet SSH, um mit jedem Remote-Host zu kommunizieren. Dies ermöglicht eine unglaublich schnelle Konfiguration neuer Server, da keine erforderlichen Pakete auf jedem neuen Server installiert werden müssen. Es ist unglaublich einfach zu bedienen und zu verstehen, da es playbooks im + yaml + Format mit einer einfachen modulbasierten Syntax verwendet.

Voraussetzungen

In diesem Tutorial installieren wir Ansible auf einem neuen Ubuntu 14.04-Master-Droplet und konfigurieren Apache auf einem zweiten Droplet. Beachten Sie jedoch, dass einer der Vorteile von Ansible darin besteht, dass Sie es auf Ihrem lokalen Computer installieren und andere Hosts verwalten können, ohne manuell in sie ssh zu müssen.

Für dieses Tutorial benötigen Sie:

Schritt 1 - Ansible konfigurieren

In diesem Abschnitt konfigurieren wir Ansible, um Ihren Server verwalten zu können.

Sobald Ansible installiert ist, müssen Sie zunächst festlegen, mit welchen Hosts Ansible kommunizieren soll. Dazu müssen wir eine Ansible-Hosts-Datei erstellen. Die Ansible-Hosts-Datei enthält Hostgruppen, auf die wir beim Ausführen von Ansible-Befehlen verweisen. Standardmäßig befindet sich dies in + / etc / ansible / hosts +. Dies wird jedoch global auf Ihrem System angewendet und erfordert häufig Administratorrechte. Stattdessen müssen wir zur Vereinfachung Ansible anweisen, eine lokale Hosts-Datei zu verwenden.

Ansible sucht immer nach einer "+ ansible.cfg +" - Datei in dem lokalen Verzeichnis, aus dem es ausgeführt wird, und überschreibt, falls gefunden, die globale Konfiguration mit den lokalen Werten. In diesem Sinne müssen wir Ansible lediglich mitteilen, dass wir eine Hosts-Datei im lokalen Verzeichnis und nicht im globalen Verzeichnis verwenden möchten.

Erstellen Sie ein neues Verzeichnis (das wir für den Rest dieses Tutorials verwenden werden).

mkdir ansible-apache

In das neue Verzeichnis verschieben.

cd ~/ansible-apache/

Erstellen Sie eine neue Datei mit dem Namen "+ ansible.cfg +" und öffnen Sie sie zur Bearbeitung.

nano ansible.cfg

In dieser Datei möchten wir die Konfigurationsoption "+ hostfile " mit dem Wert " hosts " in die Gruppe " [Defaults] " einfügen. Kopieren Sie Folgendes in die Datei " ansible.cfg +", speichern und schließen Sie sie.

[defaults]
hostfile = hosts

Als nächstes muss die Datei + hosts + geschrieben werden. Für die hosts-Datei stehen viele Optionen zur Verfügung. Wir können jedoch mit etwas sehr Einfachem beginnen.

Erstellen Sie eine "+ hosts +" - Datei und öffnen Sie sie zur Bearbeitung.

nano hosts

Kopieren Sie folgendes in die Datei + hosts +.

[apache]
ansible_ssh_user=

Dies gibt eine Hostgruppe mit dem Namen "+ Apache +" an, die einen Host enthält. Ersetzen Sie "" durch den Hostnamen oder die IP-Adresse des sekundären Servers und "" durch Ihren SSH-Benutzernamen. Jetzt sollte Ansible in der Lage sein, eine Verbindung zu Ihrem Server herzustellen.

  • Hinweis *: Die Komponente + ansible_ssh_user = + ist optional, wenn Sie Ansible als denselben Benutzer wie den Zielhost ausführen.

Um zu testen, ob Ansible funktioniert und mit Ihrem Host kommunizieren kann, können Sie einen einfachen Befehl + ansible + ausführen. Ansible enthält viele default modules, aber ein guter Anfang ist das ping -Modul. Es prüft, ob es eine Verbindung zu jedem Host herstellen kann, wodurch das Überprüfen der Datei + hosts + auf Richtigkeit vereinfacht wird.

Die grundlegende Verwendung des Befehls "+ ansible " akzeptiert die Hostgruppe und den Modulnamen: " ansible <Gruppe> -m <Modul> ". Geben Sie den folgenden Befehl ein, um den Befehl " ping +" auszuführen.

ansible apache -m ping

Die Ausgabe sollte folgendermaßen aussehen:

111.111.111.111 | success >> {
   "changed": false,
   "ping": "pong"
}

Ein weiteres Ansible-Modul, das zum Testen nützlich ist, ist das Modul command. Es führt benutzerdefinierte Befehle auf dem Host aus und gibt die Ergebnisse zurück. Geben Sie den folgenden Befehl ein, um den Befehl "+ command " mit " echo +" auszuführen, einem Unix-Befehl, der eine Zeichenfolge an das Terminal sendet.

ansible apache -m command -a "/bin/echo hello sammy"

Die Ausgabe sollte folgendermaßen aussehen:

111.111.111.111 | success | rc=0 >>
hello sammy

Dies ist die grundlegende Verwendung von Ansible. Die eigentliche Stärke liegt in der Erstellung von Wiedergabebüchern mit mehreren Ansible-Aufgaben. Wir werden die nächsten behandeln.

Schritt 2 - Erstellen eines Playbooks

In diesem Abschnitt erstellen wir ein einfaches Ansible-Wiedergabebuch, mit dem Sie auf einfache Weise kompliziertere Module ausführen können.

Ein sehr einfaches Ansible-Playbook ist eine einzelne "+ yaml +" - Datei, die die Hostgruppe und eine oder mehrere Aufgaben angibt, die auf den Hosts innerhalb der angegebenen Gruppe ausgeführt werden sollen. Sie sind recht einfach und leicht zu lesen, was einer der Gründe ist, warum Ansible so mächtig ist.

Erstellen wir eine grundlegende Playbook-Version des obigen Befehls "+ hallo sammy +".

Erstellen Sie eine Datei mit dem Namen "+ apache.yml +" und öffnen Sie sie zur Bearbeitung.

nano apache.yml

Kopieren Sie den folgenden Text in die Datei, speichern und schließen Sie sie.

---
- hosts: apache
 tasks:
   - name: run echo command
     command: /bin/echo hello sammy

Die "+ hosts: apache " - Deklaration befindet sich oben, was Ansible mitteilt, dass wir die " apache " - Hosts-Gruppe verwenden. Dies entspricht der Übergabe über den Befehl " ansible ". Als nächstes gibt es eine Liste von Aufgaben. In diesem Beispiel haben wir eine Aufgabe mit dem Namen " run echo command ". Dies ist lediglich eine Beschreibung, mit der der Benutzer verstehen soll, was die Aufgabe tut. Schließlich führt die Zeile " command: / bin / echo hello sammy " das Modul " command " mit den Argumenten " / bin / echo hello sammy +" aus.

Der Befehl "+ ansible-playbook " wird zum Ausführen von Playbooks verwendet. Die einfachste Verwendung ist: " ansible-playbook +". Wir können das soeben erstellte Playbook mit dem folgenden Befehl ausführen.

ansible-playbook apache.yml

Die Ausgabe sollte so aussehen.

PLAY [apache] *****************************************************************

GATHERING FACTS ***************************************************************
ok: [111.111.111.111]

TASK: [run echo command] ******************************************************
changed: [111.111.111.111]

PLAY RECAP ********************************************************************
111.111.111.111            : ok=2    changed=1    unreachable=0    failed=0

Das Wichtigste dabei ist, dass Playbooks nicht die Ausgabe des Moduls zurückgeben. Im Gegensatz zum direkten Befehl, den wir in Schritt 1 verwendet haben, können wir nicht sehen, ob "+ hallo sammy +" tatsächlich gedruckt wurde. Dies bedeutet, dass Playbooks besser für Aufgaben geeignet sind, bei denen Sie die Ausgabe nicht sehen müssen. Ansible teilt Ihnen mit, ob bei der Ausführung eines Moduls ein Fehler aufgetreten ist. Sie müssen sich daher in der Regel nur darauf verlassen, um festzustellen, ob ein Fehler aufgetreten ist.

Schritt 3 - Installieren von Apache

Nachdem wir Playbooks eingeführt haben, schreiben wir die Aufgabe zur Installation des Apache-Webservers.

Normalerweise ist die Installation von Apache unter Ubuntu ein einfacher Fall der Installation des Pakets "+ apache2 " über " apt-get ". Dazu verwenden wir das Ansible-Modul http://docs.ansible.com/apt_module.html[apt]. Das ' apt'-Modul enthält eine Reihe von Optionen für spezielle' + apt-get'-Funktionen. Folgende Optionen interessieren uns:

  • * name *: Der Name des zu installierenden Pakets, entweder ein einzelner Paketname oder eine Liste von Paketen.

  • * state *: Akzeptiert entweder "+ latest", "+ abwesend" oder "+ present". "Neueste" stellt sicher, dass die neueste Version installiert ist. "Present" überprüft lediglich, ob sie installiert ist, und entfernt sie, falls sie installiert ist.

  • * update_cache *: Aktualisiert den Cache (über "+ apt-get update +"), falls aktiviert, um sicherzustellen, dass er aktuell ist.

  • Hinweis *: Andere Paketmanager als + apt + have modules also. Jede Modulseite enthält Beispiele, die in der Regel alle Hauptanwendungsfälle abdecken, sodass Sie schnell ein Gefühl für die Verwendung der einzelnen Module bekommen. Es ist selten, anderswo nach Gebrauchsanweisungen suchen zu müssen.

Jetzt aktualisieren wir unser Playbook "+ apache.yml " mit dem Modul " apt " anstelle des Moduls " command ". Öffnen Sie die Datei " apache.yml +" erneut zum Bearbeiten.

nano apache.yml

Löschen Sie den aktuellen Text und kopieren Sie den folgenden Text hinein.

---
- hosts: apache
 sudo: yes
 tasks:
   - name: install apache2
     apt: name=apache2 update_cache=yes state=latest

Die Zeile "+ apt " installiert das Paket " apache2 " (" name = apache2 ") und stellt sicher, dass der Cache aktualisiert wurde (" update_cache = yes "). Obwohl es optional ist, ausdrücklich anzugeben, dass " state = latest +" installiert werden soll, ist dies eine gute Idee.

Sofern Ihr Playbook nicht auf jedem Host als "+ root" ausgeführt wird, ist "+ sudo i" erforderlich, um die richtigen Berechtigungen sicherzustellen. Ansible unterstützt + sudo + als Teil einer einfachen Option im Playbook. Es kann auch über den Befehl "+ ansible-playbook +" und auf Aufgabenebene angewendet werden.

Führen Sie nun das Playbook aus.

ansible-playbook apache.yml --ask-sudo-pass

Das Flag "+ - ask-sudo-pass +" fordert Sie auf, das sudo-Passwort für das sekundäre Droplet einzugeben. Dies ist erforderlich, da für die Installation Root-Berechtigungen erforderlich sind. Die anderen Befehle, die wir bisher ausgeführt haben, haben dies nicht getan.

Die Ausgabe sollte so aussehen.

PLAY [apache] *****************************************************************

GATHERING FACTS ***************************************************************
ok: [111.111.111.111]

TASK: [install apache2] *******************************************************
changed: [111.111.111.111]

PLAY RECAP ********************************************************************
111.111.111.111            : ok=2    changed=1    unreachable=0    failed=0

Wenn Sie den Hostnamen oder die IP-Adresse Ihres sekundären Servers in Ihrem Browser aufrufen, sollten Sie jetzt eine * Apache2 Ubuntu-Standardseite * erhalten, die Sie begrüßt. Dies bedeutet, dass Sie eine funktionierende Apache-Installation auf Ihrem Server haben und noch keine manuelle Verbindung hergestellt haben, um einen Befehl auszuführen.

Ein wichtiges Konzept, das an dieser Stelle zu beachten ist, ist idempotence, das dem Verhalten von Ansible-Modulen zugrunde liegt. Die Idee ist, dass Sie denselben Befehl wiederholt ausführen können, aber wenn beim ersten Durchlauf alles konfiguriert wurde, nehmen alle nachfolgenden Durchläufe keine Änderungen vor. Fast alle Ansible-Module unterstützen dies, einschließlich des Moduls "+ apt +".

Führen Sie zum Beispiel denselben Playbook-Befehl erneut aus.

ansible-playbook apache.yml --ask-sudo-pass

Die Ausgabe sollte so aussehen. Beachten Sie den Abschnitt + changed = 0 +.

PLAY [apache] *****************************************************************

GATHERING FACTS ***************************************************************
ok: [111.111.111.111]

TASK: [install apache2] *******************************************************
: [111.111.111.111]

PLAY RECAP ********************************************************************
111.111.111.111            : ok=2        unreachable=0    failed=0

Dies sagt Ihnen, dass das "+ apache2 +" - Paket bereits installiert wurde, sodass nichts geändert wurde. Wenn Sie mit komplizierten Playbooks auf mehreren Hosts arbeiten, ist es sehr hilfreich, die unterschiedlichen Hosts zu identifizieren. Wenn Sie zum Beispiel feststellen, dass ein Host * immer * eine bestimmte Konfiguration benötigt, die aktualisiert werden muss, befindet sich wahrscheinlich ein Benutzer oder ein Prozess auf diesem Host, der dies ändert. Ohne Idempotenz kann dies nie bemerkt werden.

Schritt 4 - Konfigurieren von Apache-Modulen

Nach der Installation von Apache müssen wir ein Modul aktivieren, das von Apache verwendet werden kann.

Stellen wir sicher, dass das + mod_rewrite + - Modul für Apache aktiviert ist. Per SSH kann dies einfach mit + a2enmod + und einem Neustart von Apache erfolgen. Mit Ansible können wir dies jedoch auch sehr einfach tun, indem wir das Modul apache2_module und einen Task-Handler zum Neustarten von + apache2 + verwenden.

Das + apache2_module + Modul bietet zwei Möglichkeiten:

  • * name * - Der Name des zu aktivierenden Moduls, z. B. "+ rewrite +".

  • * state * - Entweder + present + oder + abwesend +, abhängig davon, ob das Modul aktiviert oder deaktiviert werden muss.

Öffne + apache.yml + zum Bearbeiten.

nano apache.yml

Aktualisieren Sie die Datei, um diese Aufgabe einzuschließen. Die Datei sollte nun so aussehen:

---
- hosts: apache
 sudo: yes
 tasks:
   - name: install apache2
     apt: name=apache2 update_cache=yes state=latest

Wir müssen jedoch + apache2 + neu starten, nachdem das Modul aktiviert wurde. Eine Möglichkeit besteht darin, eine Aufgabe hinzuzufügen, um "+ apache2 +" neu zu starten. Wir möchten jedoch nicht, dass diese Aufgabe jedes Mal ausgeführt wird, wenn wir unser Playbook anwenden. Um dies zu umgehen, müssen wir einen task-Handler verwenden. Die Funktionsweise von Handlern besteht darin, dass eine Aufgabe angewiesen werden kann, einen Handler zu benachrichtigen, wenn er sich geändert hat, und der Handler nur ausgeführt wird, wenn die Aufgabe geändert wurde.

Dazu müssen wir die Option "+ notify " in die Task " apache2_module " einfügen und können dann das Modul "http://docs.ansible.com/service_module.html[service]" verwenden, um " apache2 +" neu zu starten in einem Handler.

Das ergibt ein Playbook, das so aussieht:

---
- hosts: apache
 sudo: yes
 tasks:
   - name: install apache2
     apt: name=apache2 update_cache=yes state=latest

   - name: enabled mod_rewrite
     apache2_module: name=rewrite state=present

Führen Sie nun das Playbook erneut aus.

ansible-playbook apache.yml --ask-sudo-pass

Die Ausgabe sollte folgendermaßen aussehen:

PLAY [apache] *****************************************************************

GATHERING FACTS ***************************************************************
ok: [111.111.111.111]

TASK: [install apache2] *******************************************************
ok: [111.111.111.111]







PLAY RECAP ********************************************************************
111.111.111.111            : ok=4        unreachable=0    failed=0

Es sieht soweit gut aus. Führen Sie den Befehl jetzt erneut aus. Es sollten keine Änderungen vorgenommen werden, und die Neustartaufgabe wird nicht aufgelistet.

Schritt 5 - Konfigurieren der Apache-Optionen

Nachdem wir eine funktionierende Apache-Installation haben und die erforderlichen Module aktiviert sind, müssen wir Apache konfigurieren.

Standardmäßig überwacht Apache Port 80 auf allen HTTP-Datenverkehr. Nehmen wir für das Tutorial an, dass Apache stattdessen Port 8081 überwachen soll. Mit der Standard-Apache-Konfiguration unter Ubuntu 14.04 x64 müssen zwei Dateien aktualisiert werden:

/etc/apache2/ports.conf
   Listen 80

/etc/apache2/sites-available/000-default.conf
   <VirtualHost *:80>

Dazu können wir das Modul lineinfile verwenden. Dieses Modul ist unglaublich leistungsfähig und ermöglicht es Ihnen durch die Verwendung der vielen verschiedenen Konfigurationsoptionen, alle Arten von Änderungen an einer vorhandenen Datei auf dem Host vorzunehmen. In diesem Beispiel werden die folgenden Optionen verwendet:

  • * dest * - Die Datei, die als Teil des Befehls aktualisiert werden soll.

  • * regexp * - Regulärer Ausdruck, der verwendet wird, um mit einer vorhandenen zu ersetzenden Zeile übereinzustimmen.

  • * line * - Die in die Datei einzufügende Zeile, die entweder die Zeile "+ regexp +" ersetzt oder als neue Zeile am Ende.

  • * state * - Entweder + present + oder + abwesend +.

  • Hinweis *: Das Modul "+ lineinfile " hängt die Zeile am Ende der Datei an, wenn sie nicht mit einer vorhandenen Zeile mit " regexp " übereinstimmt. Mit den Optionen " Einfügen vor " und " Einfügen nach +" können Zeilen angegeben werden, die bei Bedarf vor oder nach anstatt am Ende eingefügt werden sollen.

Um den Port von "+ 80 " auf " 8081 " zu aktualisieren, müssen Sie nach den vorhandenen Zeilen suchen, die den Port " 80 " definieren, und diese ändern, um den Port " 8081 +" zu definieren.

Öffnen Sie die Datei "+ apache.yml +" zum Bearbeiten.

nano apache.yml

Ändern Sie die zusätzlichen Zeilen so, dass die Datei wie folgt aussieht:

---
- hosts: apache
 sudo: yes
 tasks:
   - name: install apache2
     apt: name=apache2 update_cache=yes state=latest

   - name: enabled mod_rewrite
     apache2_module: name=rewrite state=present
     notify:
       - restart apache2











 handlers:
   - name: restart apache2
     service: name=apache2 state=restarted

Es ist wichtig zu beachten, dass wir im Rahmen dieses Prozesses auch + apache2 + neu starten müssen und dass wir denselben Handler wiederverwenden können, der Handler wird jedoch trotz mehrfach geänderter Tasks nur einmal ausgelöst.

Führen Sie nun das Playbook aus.

ansible-playbook apache.yml --ask-sudo-pass

Sobald Ansible fertig ist, sollten Sie in der Lage sein, Ihren Host in Ihrem Browser zu besuchen, und dieser antwortet auf Port "+ 8081 " und nicht auf Port " 80 ". In den meisten Webbrowsern kann dies einfach erreicht werden, indem am Ende der URL ": port " angefügt wird: " http: //111.111.111.111: / +".

Das + lineinfile + Modul ist sehr leistungsfähig und macht das Mangeln bestehender Konfigurationen sehr einfach. Der einzige Haken ist, dass Sie wissen müssen, was Sie von den Dateien erwarten, die Sie damit ändern, aber es werden eine Vielzahl von Optionen unterstützt, die die einfachsten Anwendungsfälle unterstützen.

Schritt 6 - Konfigurieren virtueller Hosts

Ansible bietet eine Reihe von Modulen, mit denen eine lokale (in Ansible) Vorlagendatei auf die Hosts kopiert werden kann. Die beiden am häufigsten verwendeten Module für diesen Zweck sind das Modul copy und das Modul template. Das + copy + Modul kopiert eine Datei wie sie ist und nimmt keine Änderungen daran vor, während das leistungsstärkere + template + Modul über eine Vorlage kopiert und eine variable Ersetzung auf Bereiche anwendet, die Sie mit doppelten geschweiften Klammern angeben (d. H. + {{variable}} +).

In diesem Abschnitt verwenden wir das Modul template, um einen neuen virtuellen Host auf Ihrem Server zu konfigurieren. Es wird eine Menge Änderungen geben, daher werden wir sie Stück für Stück erklären und die gesamte aktualisierte Datei "+ apache.yml +" am Ende dieses Schritts einfügen.

Erstellen Sie eine virtuelle Host-Konfiguration

Der erste Schritt besteht darin, eine neue virtuelle Hostkonfiguration zu erstellen. Wir erstellen die Konfigurationsdatei für den virtuellen Host auf dem Master-Droplet und laden sie mit Ansible auf das sekundäre Droplet hoch.

Hier ist ein Beispiel für eine grundlegende virtuelle Hostkonfiguration, die wir als Ausgangspunkt für unsere eigene Konfiguration verwenden können. Beachten Sie, dass sowohl die Portnummer als auch der unten abgebildete Domainname in der Konfiguration fest codiert sind.

<VirtualHost *:>
   ServerAdmin webmaster@
   ServerName
   ServerAlias www.
   DocumentRoot /var/www/
   ErrorLog ${APACHE_LOG_DIR}/error.log
   CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Erstellen Sie eine neue Datei mit dem Namen "+ virtualhost.conf +".

nano virtualhost.conf

Fügen Sie Folgendes in die Datei "+ virtualhost.conf +" ein. Da wir Vorlagen verwenden, ist es eine gute Idee, die oben genannten hartcodierten Werte in Variablen zu ändern, damit sie in Zukunft leicht geändert werden können.

<VirtualHost *:>
   ServerAdmin webmaster@
   ServerName
   ServerAlias www.
   DocumentRoot /var/www/
   ErrorLog ${APACHE_LOG_DIR}/error.log
   CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Verwenden Sie Vorlagenvariablen

Als nächstes müssen wir unser Playbook aktualisieren, um die Vorlage zu veröffentlichen und die Variablen zu verwenden.

Der erste Schritt besteht darin, einen Abschnitt für Variablen in das Playbook einzufügen. Es heißt "+ vars " und wird auf der gleichen Ebene wie " hosts", "+ sudo", "+ tasks" und "+ handlers" verwendet. Wir müssen beide Variablen eingeben, die in der obigen Vorlage verwendet werden, und wir werden dabei den Port wieder auf "+ 80 +" ändern.

---
- hosts: apache
 sudo: yes



 tasks:
   - name: install apache2
...

Variablen können in Tasks und Vorlagen verwendet werden, so dass wir unsere vorhandenen "+ lineinfile " - Module aktualisieren können, um das angegebene " http_port " anstelle des zuvor angegebenen fest codierten " 8081 " zu verwenden. Die Variable muss in die Zeile eingefügt werden und die Option " regexp +" muss aktualisiert werden, damit kein bestimmter Port gesucht wird. Die Änderungen sehen folgendermaßen aus:

lineinfile: dest=/etc/apache2/ports.conf regexp="" line="Listen " state=present
lineinfile: dest=/etc/apache2/sites-available/000-default.conf regexp="" line="<VirtualHost *:>"

Vorlagenmodul hinzufügen

Der nächste Schritt ist das Hinzufügen des Vorlagenmoduls, um die Konfigurationsdatei auf den Host zu übertragen. Wir werden diese Optionen verwenden, um dies zu erreichen:

  • * dest * - Der Zieldateipfad zum Speichern der aktualisierten Vorlage auf dem Host (den Hosts), d. h. + / etc / apache2 / sites-available / {{domain}}. conf +.

  • * src * - Die Quellvorlagendatei, d. h. + virtualhost.conf +.

Das Anwenden dieser auf Ihr Playbook führt zu einer Aufgabe, die folgendermaßen aussieht:

- name: create virtual host file
 template: src=virtualhost.conf dest=/etc/apache2/sites-available/{{ domain }}.conf

Aktivieren Sie den virtuellen Host

Fast fertig! Jetzt müssen wir den virtuellen Host in Apache aktivieren. Dies kann auf zwei Arten geschehen: durch Ausführen des Befehls "+ sudo a2ensite example.com " oder durch manuelles Verknüpfen der Konfigurationsdatei mit " / etc / apache2 / sites-enabled / ". Die erstere Option ist sicherer, da Apache den Prozess steuern kann. Dafür kommt das ` command +` Modul wieder zum Einsatz.

Die Verwendung ist recht einfach, wie wir oben festgestellt haben:

- name: a2ensite {{ domain }}
 command: a2ensite {{ domain }}
 notify:
 - restart apache2

Zusätzliche Arbeit verhindern

Schließlich muss das "+ command " - Modul wissen, wann es ausgeführt werden soll und wann nicht, damit das Modul nicht unnötig ausgeführt wird, wenn das Playbook mehrmals ausgeführt wird. In unserem Fall muss es nur ausgeführt werden, wenn die Datei " .conf" noch nicht auf dem Host erstellt wurde.

Dies geschieht mit der Option + create +, mit der Sie dem Modul mitteilen können, welche Datei während der Modulausführung erstellt wird. Wenn die Datei vorhanden ist, wird das Modul nicht ausgeführt. Da Apache einen Symlink erstellt, wenn Websites aktiviert sind, können Sie das Problem beheben, indem Sie darauf achten.

Die Änderungen sehen folgendermaßen aus:

- name: a2ensite {{ domain }}
 command: a2ensite {{ domain }}


 notify:
 - restart apache2

Es ist wichtig, die Verwendung des Abschnitts "+ args +" in der Aufgabe zu beachten. Dies ist eine optionale Methode, um die Moduloptionen aufzulisten. In diesem Fall wird jede Verwechslung zwischen einer Moduloption und dem eigentlichen Befehl vermieden.

Finales + apache.yml + Playbook

Wenden wir nun diese Änderungen an. Öffne + apache.yml +.

nano apache.yml

Mit all den oben genannten Änderungen können Sie Ihr Playbook "+ apache.yml +" so ändern, dass es so aussieht.

---
- hosts: apache
 sudo: yes
 vars:
   http_port: 80
   domain: example.com
 tasks:
   - name: install apache2
     apt: name=apache2 update_cache=yes state=latest

   - name: enabled mod_rewrite
     apache2_module: name=rewrite state=present
     notify:
       - restart apache2

   - name: apache2 listen on port {{ http_port }}
     lineinfile: dest=/etc/apache2/ports.conf regexp="^Listen " line="Listen {{ http_port }}" state=present
     notify:
       - restart apache2

   - name: apache2 virtualhost on port {{ http_port }}
     lineinfile: dest=/etc/apache2/sites-available/000-default.conf regexp="^<VirtualHost \*:" line="<VirtualHost *:{{ http_port }}>"
     notify:
       - restart apache2

   - name: create virtual host file
     template: src=virtualhost.conf dest=/etc/apache2/sites-available/{{ domain }}.conf

   - name: a2ensite {{ domain }}
     command: a2ensite {{ domain }}
     args:
       creates: /etc/apache2/sites-enabled/{{ domain }}.conf
     notify:
       - restart apache2

 handlers:
   - name: restart apache2
     service: name=apache2 state=restarted

Speichern und schließen Sie die Datei und führen Sie das Playbook aus.

ansible-playbook apache.yml --ask-sudo-pass

Wenn Sie jetzt den Hostnamen oder die IP-Adresse Ihres sekundären Droplets in Ihrem Browser aufrufen, wird dies wieder an Port + 80 + und nicht an Port + 8081 + angezeigt. Besuchen Sie als nächstes die Domain (d. H. + example.com +) haben wir für den neuen virtuellen Host angegeben. Da wir noch keine Dateien hinzugefügt haben, sollte die Apache-Fehlerseite "+ 404 +" und nicht die Apache-Begrüßungsseite angezeigt werden. In diesem Fall funktioniert Ihr virtueller Host ordnungsgemäß und Sie haben noch kein SSH in Ihr sekundäres Droplet eingegeben, um einen einzelnen Befehl auszuführen.

Schritt 7 - Verwenden eines Git-Repository für Ihre Website

In diesem Abschnitt verwenden wir Ansible, um ein Git-Repository zu klonen und den Inhalt Ihrer Website einzurichten.

Jede Website benötigt Inhalte, und obwohl es normal ist, ein Git-Repository mit SSH zu versehen und manuell zu klonen, um eine neue Website einzurichten, stellt uns Ansible die Tools zur Verfügung, die wir für die automatische Einrichtung benötigen. In diesem Beispiel wird das Modul git ausgeführt, was erforderlich ist.

Das + git + Modul hat viele Optionen, die für dieses Tutorial relevant sind:

  • * dest * - Der Pfad auf dem Host, auf den das Repository ausgecheckt wird.

  • * repo * - Die Repository-URL, die geklont wird. Dies muss für den Host zugänglich sein.

  • * update * - Wenn diese Option auf "+ no +" gesetzt ist, kann Ansible das Repository nicht aktualisieren, wenn es bereits vorhanden ist.

  • * accept_hostkey * - Weist SSH an, unbekannte Host-Schlüssel zu akzeptieren, wenn eine Verbindung über SSH hergestellt wird. Dies ist sehr nützlich, da Sie sich nicht mehr über SSH anmelden müssen, um den ersten Anmeldeversuch zu akzeptieren. Sie können jedoch die Hostsignatur nicht mehr manuell überprüfen. Abhängig von Ihrem Repository benötigen Sie möglicherweise diese Option.

Für die Zwecke des Tutorials gibt es ein einfaches Git-Repository mit einer einzelnen Seite "+ index.html ", die auf Ihren Host geklont werden kann. Wenn Sie bereits ein anderes öffentliches Repository haben, das ähnliches enthält, können Sie es jederzeit ersetzen. In diesem Sinne sieht die Aufgabe " git +" folgendermaßen aus:

- name: clone basic html template
 git: repo= dest= update=no

Wenn Sie das Playbook jetzt ausführen, wird wahrscheinlich eine Fehlermeldung angezeigt. Wir müssen zuerst das Paket + git + installieren, damit Ansible es zum Klonen des Repositorys verwenden kann. Die Aufgabe "+ apt " muss aktualisiert werden, um sowohl das Paket " apache2 " als auch das Paket " git " zu installieren. Das Überprüfen der http://docs.ansible.com/apt_module.html[apt] -Dokumentation zeigt uns, dass die Option " name +" nur ein einzelnes Paket akzeptiert, sodass dies keine Hilfe darstellt. Stattdessen müssen wir eine list of items verwenden.

Ansible bietet die Möglichkeit, eine Liste der Elemente anzugeben, die durchlaufen werden sollen, und die Aufgabe auf jedes Element anzuwenden. Sie werden mit der Option "+ with_items " als Teil der Aufgabe angegeben, und unsere " apt +" - Aufgabe wird folgendermaßen aktualisiert:

- name: install packages
 apt: name= update_cache=yes state=latest

Die Liste der Elemente verwendet die Variable "+ Element +" und führt die Aufgabe für jedes Element in der Liste aus.

Öffne + apache.yml + erneut.

nano apache.yml

Aktualisieren Sie das Playbook so, dass es den folgenden Kriterien entspricht:

---
- hosts: apache
 sudo: yes

 vars:
   http_port: 80
   domain: example.com

 tasks:







   - name: enabled mod_rewrite
     apache2_module: name=rewrite state=present
     notify:
       - restart apache2

   - name: apache2 listen on port {{ http_port }}
     lineinfile: dest=/etc/apache2/ports.conf regexp="^Listen " line="Listen {{ http_port }}" state=present
     notify:
       - restart apache2

   - name: apache2 virtualhost on port {{ http_port }}
     lineinfile: dest=/etc/apache2/sites-available/000-default.conf regexp="^<VirtualHost \*:" line="<VirtualHost *:{{ http_port }}>"
     notify:
       - restart apache2

   - name: create virtual host file
     template: src=virtualhost.conf dest=/etc/apache2/sites-available/{{ domain }}.conf

   - name: a2ensite {{ domain }}
     command: a2ensite {{ domain }}
     args:
       creates: /etc/apache2/sites-enabled/{{ domain }}.conf
     notify:
       - restart apache2




 handlers:
   - name: restart apache2
     service: name=apache2 state=restarted

Speichern Sie die Datei und führen Sie das Playbook aus.

ansible-playbook apache.yml --ask-sudo-pass

Es sollte "+ git +" installieren und das Repository erfolgreich klonen. Wenn Sie den virtuellen Host aus Schritt 6 besuchen, sollte jetzt etwas anderes als ein 404-Fehler angezeigt werden. Vergessen Sie nicht zu überprüfen, dass der nicht virtuelle Host immer noch die Standardseite zurückgibt.

Zusammenfassend ist Git nun installiert und eine einfache HTML-Seite wurde über Git auf Ihren neuen virtuellen Host geklont. Es sind noch keine manuellen SSH-Befehle erforderlich. Wenn Sie nur nach einer einfachen HTML-Website suchen und diese in einem öffentlichen Git-Repository gespeichert ist, sind Sie fertig!

Fazit

Wir haben gerade ein Ansible Playbook erstellt, um den gesamten Prozess der Konfiguration Ihres Hosts für die Ausführung des Apache-Webservers mit virtuellen Hosts und einem Git-Repository zu automatisieren. All dies wurde erreicht, ohne dass Sie sich direkt beim Server anmelden müssen. Das Beste daran ist, dass Sie Ihr neues Playbook auf den meisten Ubuntu-Servern ausführen können, um dasselbe Ergebnis zu erzielen.

  • Hinweis *: Wenn auf Ihrem Host Apache bereits eingerichtet und geändert wurde, müssen Sie höchstwahrscheinlich alle Änderungen vornehmen, um den erforderlichen Status wiederherzustellen. Positiv zu vermerken ist, dass Ansible diese Änderungen nur dann korrigiert, wenn sie vorhanden sind. Daher ist es sicher, sie im Haupt-Playbook zu haben!

Ansible ist unglaublich leistungsfähig und hat auch eine sehr einfache Lernkurve. Sie können mit den grundlegenden Konzepten beginnen, die in diesem Tutorial behandelt werden, und entweder auf diesem Niveau bleiben oder viel mehr lernen, um zu den wirklich komplizierten Teilen zu gelangen. In beiden Fällen können Sie Ihre Server konfigurieren und verwalten, ohne sich für die meisten, wenn nicht sogar für alle Aufgaben manuell anmelden zu müssen.

Sie können in der Ansible Module List nachsehen, wozu Ansible sonst noch in der Lage ist.

Related