TOC

Verwendung der DigitalOcean API v2 mit Ansible 2.0 unter Ubuntu 16.04

[.Warnung]##

Status: Veraltet

Dieser Artikel ist veraltet und wird nicht mehr gepflegt.

Grund

Dieser Artikel basiert auf einem Projekt,dopy, das nicht mehr verwaltet wird.

Siehe stattdessen

Dieser Artikel kann immer noch als Referenz nützlich sein, funktioniert jedoch möglicherweise nicht oder folgt nicht den bewährten Methoden. Wir empfehlen dringend, einen aktuellen Artikel zu verwenden, der für das von Ihnen verwendete Betriebssystem geschrieben wurde.

Einführung

Ansible 2.0 bietet Unterstützung fürversion 2 of the DigitalOcean API. Dies bedeutet, dass Sie Ansible verwenden können, um nicht nur Ihre Webanwendungen bereitzustellen, sondern auch Ihre Droplets automatisch bereitzustellen und zu verwalten.

Während DigitalOcean eine einfache Weboberfläche zum Einrichten von SSH-Schlüsseln und zum Erstellen von Droplets bietet, müssen Sie diesen manuellen Vorgang jedes Mal durchführen, wenn Sie einen neuen Server bereitstellen möchten. Wenn Ihre Anwendung um eine größere Anzahl von Servern erweitert wird und bei Bedarf vergrößert oder verkleinert werden muss, müssen Sie die Anwendungsbereitstellungsskripts für jeden Server nicht manuell erstellen und konfigurieren.

Die Verwendung eines Bereitstellungstools wie Ansible bietet den Vorteil, dass Sie diesen Prozess vollständig automatisieren können. Das Starten ist so einfach wie das Ausführen eines einzelnen Befehls. Dieses Tutorial zeigt anhand eines Beispiels, wie Ansible die DigitalOcean API v2 unterstützt.

In diesem Lernprogramm wird insbesondere das Einrichten eines neuen SSH-Schlüssels auf einem DO-Konto und das Bereitstellen von zwei verschiedenen Droplets behandelt, damit diese für die Bereitstellung Ihrer Webanwendungen verwendet werden können. Nachdem Sie diesem Lernprogramm gefolgt sind, können Sie diese Aufgaben ändern und in Ihre vorhandenen Anwendungsbereitstellungsskripts integrieren.

Voraussetzungen

Dieses Tutorial baut auf Ansible-Grundkenntnissen auf. Wenn Sie Ansible noch nicht kennen, können Sie zuerstthis section of the Ansible installation tutorial lesen.

Um diesem Tutorial zu folgen, benötigen Sie:

[[Schritt-1 - Konfigurieren von Ansible]] == Schritt 1 - Konfigurieren von Ansible

In diesem Schritt konfigurieren wir Ansible für die Kommunikation mit der DigitalOcean-API.

In der Regel verwendet Ansible lediglich SSH, um eine Verbindung zu verschiedenen Servern herzustellen und Befehle auszuführen. Dies bedeutet, dass die Konfiguration, die für den Start mit Ansible erforderlich ist, in der Regel für alle Module Standard ist. Da die Kommunikation mit der DigitalOcean-API jedoch nicht einfach ein SSH-Shell-Befehl ist, müssen wir einige zusätzliche Einstellungen vornehmen. Mit dem Python-Moduldopy (DigitalOcean API Python Wrapper) kann Ansible mit der API kommunizieren.

Umdopy zu installieren, installieren Sie zuerst den Python-Paketmanagerpip. 

sudo apt-get install python-pip

Installieren Sie danndopy mitpip. 

sudo pip install dopy

Als Nächstes erstellen wir ein neues Verzeichnis, in dem die Dinge sauber bleiben sollen, und richten eine grundlegende Ansible-Konfigurationsdatei ein.

Standardmäßig verwendet Ansible eine Hosts-Datei mit/etc/ansible/hosts, die alle von ihm verwalteten Server enthält. Während diese Datei für einige Anwendungsfälle in Ordnung ist, ist sie global. Dies ist eine globale Konfiguration, die in einigen Anwendungsfällen in Ordnung ist. In diesem Lernprogramm wird jedoch eine lokale Hosts-Datei verwendet. Auf diese Weise brechen wir möglicherweise vorhandene Konfigurationen nicht versehentlich auf, während Sie die DO-API-Unterstützung von Ansible kennenlernen und testen.

Erstellen Sie ein neues Verzeichnis und verschieben Sie es in ein neues Verzeichnis, das wir für den Rest dieses Tutorials verwenden werden. 

mkdir ~/ansible-do-api
cd ~/ansible-do-api/

Wenn Sie Ansible ausführen, sucht es in dem Verzeichnis, in dem es ausgeführt wird, nach eineransible.cfg-Datei. Wenn es eine findet, werden diese Konfigurationseinstellungen angewendet. Dies bedeutet, dass wir Optionen wie die Optionhostfile für jeden einzelnen Anwendungsfall leicht überschreiben können.

Erstellen Sie eine neue Datei mit dem Namenansible.cfg und öffnen Sie sie zur Bearbeitung mitnano oder Ihrem bevorzugten Texteditor. 

nano ansible.cfg

Fügen Sie Folgendes inansible.cfg ein, speichern und schließen Sie die Datei.

Aktualisierte ansible.cfg 

[defaults]
hostfile = hosts

Durch Festlegen der Optionhostfile in der Gruppe[defaults] wird Ansible angewiesen, eine bestimmte Hosts-Datei anstelle der globalen zu verwenden. Diesesansible.cfg weist Ansible an, im selben Verzeichnis nach einer Hostdatei mit dem Namenhosts zu suchen.

Als Nächstes erstellen wir diehosts-Datei. 

nano hosts

Da wir uns in diesem Lernprogramm nur mit der DigitalOcean-API befassen, können wir Ansible anweisen, auflocalhost zu arbeiten. Dies vereinfacht die Arbeit und macht eine Verbindung zu einem Remote-Host überflüssig. Dies kann erreicht werden, indem Ansible angewiesen wird,localhost zu verwenden, undansible_connection alslocal angegeben wird. Fügen Sie den folgenden Code inhosts ein, speichern und schließen Sie die Datei.

Aktualisierte Hosts-Datei 

[digitalocean]
localhost ansible_connection=local

Schließlich verwenden wir das in den Voraussetzungen erstellte API-Token, damit Ansible mit der DigitalOcean-API kommunizieren kann. Es gibt drei Möglichkeiten, wie wir Ansible über das API-Token informieren können:

  1. Stellen Sie es mit dem Parameterapi_tokendirekt für jede DigitalOcean-Aufgabe bereit.

  2. Definieren Sie es als Variable in der Playbook- oder Hosts-Datei und verwenden Sie diese Variable für den Parameterapi_token.

  3. Exportieren Sie es als Umgebungsvariable, entweder alsDO_API_TOKEN oder alsDO_API_KEY.

Option 1 ist der direkteste Ansatz und klingt möglicherweise ansprechend, wenn Sie keine Variablen erstellen möchten. Dies bedeutet jedoch, dass das API-Token in jede Aufgabe kopiert werden muss, für die es verwendet wird. Dies bedeutet vor allem, dass Sie bei Änderungen alle Instanzen finden und alle ersetzen müssen.

Mit Option 2 können wir das API-Token wie mit Option 1 direkt in unserem Playbook festlegen. Im Gegensatz zu Option 1 definieren wir sie nur an einer einzigen Stelle, indem wir eine Variable verwenden, die bequemer und einfacher zu aktualisieren ist. Für dieses Lernprogramm wird Option 2 verwendet, da dies der einfachste Ansatz ist.

Es ist jedoch nichts wert, dass Option 3 die beste Methode ist, um Ihr API-Token zu schützen, da es für Sie sehr viel schwieriger ist, das API-Token versehentlich in ein Repository zu übertragen (das möglicherweise mit anderen geteilt wird). Es ermöglicht die Konfiguration des Tokens auf Systemebene und die Arbeit mit verschiedenen Wiedergabebüchern, ohne dass der Token in jedem enthalten sein muss.

Erstellen Sie ein einfaches Playbook mit dem Namendigitalocean.yml. 

nano digitalocean.yml

Fügen Sie den folgenden Code in die Datei ein und stellen Sie sicher, dass Sie ihn in Ihrem API-Token ersetzen.

Aktualisierte digitalocean.yml 

---
- hosts: digitalocean

  vars:
    do_token: your_API_token

  tasks:

Sie können diese Datei in Ihrem Editor geöffnet lassen, da wir im nächsten Schritt weiter daran arbeiten.

[[Schritt-2 -—- Einrichten eines SSH-Schlüssels]] == Schritt 2 - Einrichten eines SSH-Schlüssels

In diesem Schritt erstellen wir einen neuen SSH-Schlüssel auf Ihrem Server und fügen ihn mit Ansible Ihrem DigitalOcean-Konto hinzu.

Als erstes müssen wir sicherstellen, dass der Benutzer über ein SSH-Schlüsselpaar verfügt, das wir an DigitalOcean senden können, damit es standardmäßig auf Ihren neuen Droplets installiert werden kann. Obwohl dies einfach über die Befehlszeile möglich ist, können wir dies genauso einfach mit dem Modulusersin Ansible tun. Die Verwendung von Ansible bietet auch den Vorteil, dass sichergestellt ist, dass der Schlüssel vorhanden ist, bevor er verwendet wird, wodurch Probleme vermieden werden können, wenn das Playbook auf verschiedenen Hosts ausgeführt wird.

Fügen Sie in Ihrem Playbook die unten stehende Aufgabeuserhinzu, mit der wir sicherstellen können, dass ein SSH-Schlüssel vorhanden ist, und speichern und schließen Sie die Datei.

Aktualisierte digitalocean.yml 

---
- hosts: digitalocean

  vars:
    do_token: your_API_token

  tasks:

  - name: ensure ssh key exists
    user: >
      name={{ ansible_user_id }}
      generate_ssh_key=yes
      ssh_key_file=.ssh/id_rsa

[.note] #Sie können den Namen des Schlüssels ändern, wenn Sie etwas anderes als~/.ssh/id_rsa.
# verwenden möchten.

Führen Sie Ihr Playbook aus. 

ansible-playbook digitalocean.yml

Die Ausgabe sollte folgendermaßen aussehen:

Ausgabe 

PLAY ***************************************************************************

TASK [setup] *******************************************************************
ok: [localhost]

TASK [ensure ssh key exists] ***************************************************
changed: [localhost]

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

Wenn dies abgeschlossen ist, können Sie manuell überprüfen, ob der Schlüssel vorhanden ist, indem Sie Folgendes ausführen: 

ls -la ~/.ssh/id_rsa*

Es werden alle Dateien aufgelistet, die mitid_rsa* übereinstimmen. Sie solltenid_rsa undid_rsa.pub aufgelistet sehen, um anzuzeigen, dass Ihr SSH-Schlüssel vorhanden ist.

Als Nächstes drücken wir den Schlüssel in Ihr DigitalOcean-Konto. Öffnen Sie Ihr Playbook, um es erneut zu bearbeiten. 

nano digitalocean.yml

Wir verwenden das Ansible-Moduldigital_ocean, um Ihren SSH-Schlüssel hochzuladen. Wir registrieren auch die Ausgabe der Aufgabe als Variablemy_ssh_key, da wir sie für einen späteren Schritt benötigen.

Fügen Sie die Aufgabe am Ende der Datei hinzu, speichern und schließen Sie die Datei.

Aktualisierte digitalocean.yml 

---
. . .
  - name: ensure ssh key exists
    user: >
      name={{ ansible_user_id }}
      generate_ssh_key=yes
      ssh_key_file=.ssh/id_rsa

  - name: ensure key exists at DigitalOcean
    digital_ocean: >
      state=present
      command=ssh
      name=my_ssh_key
      ssh_pub_key={{ lookup('file', '~/.ssh/id_rsa.pub') }}
      api_token={{ do_token }}
    register: my_ssh_key

[.note] #Wenn Sie Ihren Schlüssel anders alsid_rsa benannt haben, stellen Sie sicher, dass der Name in der Zeilessh_pub_keyin dieser Aufgabe aktualisiert wird.
#

Wir verwenden hier eine Reihe verschiedener Optionen aus demdigital_ocean-Modul:

  • state - Dies kann vorhanden, aktiv, nicht vorhanden oder gelöscht sein. In diesem Fall möchten wirpresent, da der SSH-Schlüssel im Konto vorhanden sein soll.

  • command - Dies ist entweder das Tröpfchen oder ssh. Wir möchtenssh, mit denen wir den Status von SSH-Schlüsseln innerhalb des Kontos verwalten können.

  • name - Dies ist der Name, unter dem der SSH-Schlüssel gespeichert werden soll. Dieser Name muss eindeutig sein und wird verwendet, um Ihren Schlüssel über die API und die Weboberfläche zu identifizieren.

  • ssh_pub_key - Dies ist Ihr öffentlicher SSH-Schlüssel. Dies ist der Schlüssel, dessen Existenz wir mithilfe des Benutzermoduls sichergestellt haben.

  • api_token - Dies ist Ihr DigitalOcean-API-Token, auf das wir als Variable zugreifen können (do_token, definiert im Abschnittvars).

Führen Sie nun Ihr Playbook aus. 

ansible-playbook digitalocean.yml

Die Ausgabe sollte folgendermaßen aussehen:

Ausgabe 

. . .

TASK [ensure key exists at digital ocean] **************************************
changed: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=3    changed=1    unreachable=0    failed=0

Wenn dies abgeschlossen ist, können Sie manuell überprüfen, ob Ihr SSH-Schlüssel in Ihrem DigitalOcean-Konto vorhanden ist, indem Sie in der Systemsteuerung aufSettings (im Gangmenü) und dann aufSecurity (inUserklicken ) s Kategorie in der linken Seitenleiste). Ihr neuer Schlüssel sollte unterSSH Keys aufgeführt sein.

[[Schritt 3 - Erstellen eines neuen Tropfens]] == Schritt 3 - Erstellen eines neuen Tropfens

In diesem Schritt erstellen wir ein neues Droplet.

Wir haben in Schritt 2 kurz auf das Moduldigital_ocean eingegangen. In diesem Schritt werden wir verschiedene Optionen für dieses Modul verwenden:

  • command - Wir haben diese Option im vorherigen Schritt mit`+ssh+ verwendet. Dieses Mal verwenden wir es mitdroplet, um Droplets über dieses Modul zu verwalten.

  • state - Wir haben dies auch im vorherigen Schritt verwendet. hier repräsentiert es den Zustand des Tropfens, den wirpresent sein wollen.

  • image_id - Dies ist das Bild, das für das neue Tröpfchen verwendet werden soll, wieubuntu-16-04-x64.

  • name - Dies ist der Hostname, der beim Erstellen des Droplets verwendet werden soll.

  • region_id - Dies ist die Region, in der das Droplet erstellt werden soll, z. B.NYC3.

  • size_id - Dies ist die Größe des Tröpfchens, das wir erstellen möchten, wie512mb.

  • sshkeyids - Dies ist die SSH-Schlüssel-ID (oder die IDs), die beim Erstellen auf dem Server festgelegt werden sollen.

Es gibt viel mehr Optionen als nur die, die wir in diesem Lernprogramm behandeln (die alle auf der Ansible-Dokumentationsseite zu finden sind). Mithilfe dieser Optionen können wir jedoch Ihre neue Aufgabe schreiben.

Öffne dein Playbook zum Bearbeiten. 

nano digitalocean.yml

Aktualisieren Sie Ihr Playbook mit der neuen Aufgabe, die unten rot hervorgehoben ist, und speichern und schließen Sie die Datei. Sie können Optionen wie Größe, Region und Bild an Ihre Anwendung anpassen. Mit den folgenden Optionen wird ein 512 MB Ubuntu 16.04-Server mit dem Namendroplet-one unter Verwendung des im vorherigen Schritt erstellten SSH-Schlüssels erstellt.

Aktualisierte digitalocean.yml 

. . .
      api_token={{ do_token }}
    register: my_ssh_key

  - name: ensure droplet one exists
    digital_ocean: >
      state=present
      command=droplet
      name=droplet-one
      size_id=512mb
      region_id=sgp1
      image_id=ubuntu-16-04-x64
      ssh_key_ids={{ my_ssh_key.ssh_key.id }}
      api_token={{ do_token }}
    register: droplet_one

  - debug: msg="IP is {{ droplet_one.droplet.ip_address }}"

Beachten Sie, dass wir{{ my_ssh_key.ssh_key.id }} verwenden, um die ID des zuvor eingerichteten SSH-Schlüssels abzurufen und an Ihr neues Droplet zu übergeben. Dies funktioniert, wenn der SSH-Schlüssel neu erstellt wurde oder bereits vorhanden ist.

Führen Sie nun Ihr Playbook aus. Die Ausführung dauert etwas länger als zuvor, da ein Droplet erstellt wird. 

ansible-playbook digitalocean.yml

Die Ausgabe sollte folgendermaßen aussehen: 

. . .

TASK [ensure key exists at DigitalOcean] **************************************
ok: [localhost]

TASK [ensure droplet one exists] ******************************************************
changed: [localhost]

TASK [debug] *******************************************************************
ok: [localhost] => {
"msg": "IP is 111.111.111.111"
}

PLAY RECAP *********************************************************************
localhost                  : ok=5    changed=1    unreachable=0    failed=0

Ansible hat uns in der Rückmeldung die IP-Adresse des neuen Droplets mitgeteilt. Um zu überprüfen, ob es ausgeführt wird, können Sie sich direkt mit SSH anmelden. 

ssh [email protected]

Dies sollte Sie mit Ihrem neuen Server verbinden (mithilfe des SSH-Schlüssels, den wir in Schritt 2 auf Ihrem Ansible-Server erstellt haben). Sie können dann zu Ihrem Ansible-Server zurückkehren, indem SieCTRL+D drücken.

[[Schritt 4 - Sicherstellen, dass ein Tröpfchen vorhanden ist]] == Schritt 4 - Sicherstellen, dass ein Tröpfchen vorhanden ist

In diesem Schritt werden wir das Konzept der Idempotenz und den Umgang mit der Bereitstellung von Droplets mit Ansible erläutern.

Ansible will mit dem Konzept der Idempotenz operieren. Dies bedeutet, dass Sie dieselben Aufgaben mehrmals ausführen können. Änderungen sollten nur dann vorgenommen werden, wenn sie benötigt werden. Dies ist normalerweise das erste Mal, dass sie ausgeführt werden. Diese Idee lässt sich gut auf die Bereitstellung von Servern, die Installation von Paketen und andere Serveradministrationen übertragen.

Wenn Sie Ihr Playbook erneut ausführen (tun Sie es noch nicht!), Wird es in der aktuellen Konfiguration ein zweites Droplet bereitstellen, das auchdroplet-one genannt wird. Führen Sie es erneut aus, und es wird ein drittes Tröpfchen erzeugt. Dies liegt an der Tatsache, dass DigitalOcean mehrere Tröpfchen mit demselben Namen zulässt. Um dies zu vermeiden, können wir den Parameterunique_name verwenden.

Der Parameterunique_name teilt Ansible und DigitalOcean mit, dass Sie eindeutige Hostnamen für Ihre Server wünschen. Das heißt, wenn Sie Ihr Playbook erneut ausführen, wird die Idempotenz gewahrt und das bereits bereitgestellte Droplet berücksichtigt, sodass kein zweiter Server mit demselben Namen erstellt wird.

Öffne dein Playbook zum Bearbeiten: 

nano digitalocean.yml

Fügen Sie den Parameterunique_name hinzu:

Aktualisierte digitalocean.yml 

. . .
  - name: ensure droplet one exists
    digital_ocean: >
      state=present
      command=droplet
      name=droplet-one
      unique_name=yes
      size_id=512mb
. . .

Speichere und starte dein Playbook: 

ansible-playbook digitalocean.yml

Die Ausgabe sollte zu keinen geänderten Aufgaben führen, aber Sie werden feststellen, dass die Debug-Ausgabe mit der IP-Adresse weiterhin angezeigt wird. Wenn Sie Ihr DigitalOcean-Konto überprüfen, werden Sie feststellen, dass nur ein einzigesdroplet-one Droplet bereitgestellt wurde.

[[Schritt-5 - Erstellen eines zweiten Tropfens]] == Schritt 5 - Erstellen eines zweiten Tropfens

In diesem Schritt replizieren wir unsere vorhandene Konfiguration, um ein separates Droplet bereitzustellen.

Um ein separates Droplet bereitzustellen, müssen wir lediglich die Ansible-Aufgabe aus unserem ersten Droplet replizieren. Um unser Playbook ein wenig robuster zu machen, werden wir es in eine Droplet-Liste zur Bereitstellung umwandeln, die es uns ermöglicht, unsere Flotte bei Bedarf einfach zu skalieren.

Zuerst müssen wir unsere Liste der Tröpfchen definieren.

Öffne dein Playbook zum Bearbeiten: 

nano digitalocean.yml

Fügen Sie im Abschnittvars eine Liste der zu bereitstellenden Droplet-Namen hinzu.

Aktualisierte digitalocean.yml 

---
- hosts: digitalocean

  vars:
    do_token: 
    droplets:
    - droplet-one
    - droplet-two

  tasks:
. . .

Als Nächstes müssen wir unsere Aufgabe aktualisieren, um die Liste der Tröpfchen zu durchlaufen, zu prüfen, ob sie vorhanden sind, und die Ergebnisse dann in einer Variablen zu speichern. Anschließend müssen wir auch die Aufgaben vondebugändern, um die in der Variablen gespeicherten Informationen für jedes Element auszugeben.

Aktualisieren Sie dazu die Aufgabe vonensure droplet one existsin Ihrem Playbook wie folgt:

Aktualisierte digitalocean.yml 

. . .
  - name: ensure droplets exist
    digital_ocean: >
      state=present
      command=droplet
      name={{ item }}
      unique_name=yes
      size_id=512mb
      region_id=sgp1
      image_id=ubuntu-16-04-x64
      ssh_key_ids={{ my_ssh_key.ssh_key.id }}
      api_token={{ do_token }}
    with_items: droplets
    register: droplet_details

  - debug: msg="IP is {{ item.droplet.ip_address }}"
    with_items: droplet_details.results

Speichere und starte dein Playbook. 

ansible-playbook digitalocean.yml

Die Ergebnisse sollten folgendermaßen aussehen:

Ausgabe 

. . .
TASK [ensure droplets exists] **************************************************
ok: [localhost] => (item=droplet-one)
changed: [localhost] => (item=droplet-two)

TASK [debug] *******************************************************************

. . .

"msg": "IP is 111.111.111.111"

. . .

"msg": "IP is 222.222.222.222"
}

PLAY RECAP *********************************************************************
localhost                  : ok=5    changed=1    unreachable=0    failed=0

Möglicherweise stellen Sie fest, dass die Ausgabe vondebugviel mehr Informationen enthält als beim ersten Mal. Dies liegt daran, dass das Moduldebugzusätzliche Informationen zur Hilfe beim Debuggen druckt. Dies ist ein kleiner Nachteil der Verwendung registrierter Variablen mit diesem Modul.

Abgesehen davon werden Sie feststellen, dass unser zweites Droplet bereitgestellt wurde, während unser erstes bereits ausgeführt wurde. Sie haben jetzt zwei DigitalOcean Droplets mit nur Ansible bereitgestellt!

Das Löschen Ihrer Droplets ist genauso einfach. Der Zustandsparameter in der Task teilt Ansible mit, in welchem ​​Zustand sich das Droplet befinden soll. Wenn Sie es aufpresent setzen, wird sichergestellt, dass das Droplet vorhanden ist. Es wird erstellt, wenn es noch nicht vorhanden ist. Wenn Sie es aufabsent setzen, wird sichergestellt, dass das Droplet mit dem angegebenen Namennot vorhanden ist, und es werden alle Droplets gelöscht, die dem angegebenen Namen entsprechen (solangeunique_name festgelegt ist).

Wenn Sie die beiden Beispiel-Droplets löschen möchten, die Sie in diesem Lernprogramm erstellt haben, ändern Sie einfach den Status in der Erstellungsaufgabe inabsent und führen Sie Ihr Playbook erneut aus.

Aktualisierte digitalocean.yml 

. . .
  - name: ensure droplets exist
    digital_ocean: >
      state=absent
      command=droplet
. . .

Möglicherweise möchten Sie auch die Debug-Zeile entfernen, bevor Sie Ihr Playbook erneut ausführen. Wenn Sie dies nicht tun, werden Ihre Droplets weiterhin gelöscht, es wird jedoch ein Fehler im Debug-Befehl angezeigt (da keine IP-Adressen zurückgegeben werden müssen). 

ansible-playbook digitalocean.yml

Nun werden Ihre beiden Beispieltröpfchen gelöscht.

Fazit

Ansible ist ein unglaublich leistungsfähiges und sehr flexibles Bereitstellungstool. Sie haben gesehen, wie einfach es ist, Droplets mithilfe der DigitalOcean-API bereitzustellen (und zu entfernen), wobei nur Ansible-Standardkonzepte und die integrierten Module verwendet werden.

Der Statusparameter, der aufpresent gesetzt wurde, teilt Ansible mit, in welchem ​​Status sich das Droplet befinden soll. Wenn Sie es aufpresent setzen, wird sichergestellt, dass das Droplet vorhanden ist. Es wird erstellt, wenn es noch nicht vorhanden ist. Wenn Sie es aufabsent setzen, wird Ansible angewiesen, sicherzustellen, dass das Droplet mit dem angegebenen Namennot vorhanden ist, und alle mit dem angegebenen Namen übereinstimmenden Droplets werden gelöscht (solangeunique_name gesetzt ist).

Mit zunehmender Anzahl der von Ihnen verwalteten Droplets können Sie durch die Automatisierung des Prozesses Zeit beim Erstellen, Einrichten und Löschen von Droplets als Teil eines automatisierten Prozesses sparen. Sie können die Beispiele in diesem Lernprogramm anpassen und erweitern, um Ihre Bereitstellungsskripts an Ihre Einrichtung anzupassen.

Related