TOC

SaltStack-Infrastruktur: Konfigurieren von Salt-Cloud zur Aufstockung von DigitalOcean-Ressourcen

Einführung

SaltStack oder Salt ist ein leistungsstarkes Remote-Ausführungs- und Konfigurationsverwaltungssystem, mit dem die Infrastruktur auf einfache Weise strukturiert und wiederholbar verwaltet werden kann. In dieser Serie werden wir eine Methode zum Verwalten Ihrer Entwicklungs-, Staging- und Produktionsumgebungen anhand einer Salt-Bereitstellung demonstrieren. Wir werden das Salt-Status-System verwenden, um wiederholbare Aktionen zu schreiben und anzuwenden. Auf diese Weise können wir jede unserer Umgebungen zerstören, in der Gewissheit, dass wir sie zu einem späteren Zeitpunkt problemlos in identischem Zustand wieder online stellen können.

In our last guide haben wir zunächst die Erstkonfiguration unseres Salt-Masterservers abgeschlossen. Dieser Server sollte nun ausgeführt werden und Salt-Befehle an sich selbst senden können. In diesem Handbuch werden wir die Reichweite unseres Salt Masters erweitern, indem wir die "+ salt-cloud +" - Komponenten konfigurieren. Auf diese Weise können wir uns in unser DigitalOcean-Konto einbinden, um bei Bedarf Ressourcen aufzutreiben. Wir werden Profile erstellen, die die Eigenschaften unserer einzelnen Komponenten und unserer gesamten Umgebung definieren.

Voraussetzungen

Um dieses Tutorial abzuschließen, benötigen Sie einen Salt-Master-Server, der wie in this guide beschrieben konfiguriert ist. Wir werden die Schritte in diesem Handbuch unter Verwendung des Nicht-Root-Benutzerkontos auf diesem Server ausführen.

Sie benötigen außerdem Zugriff auf ein DigitalOcean-Konto. Wir werden die DigitalOcean-API über den Befehl "+ salt-cloud +" nutzen, um die Server zu erstellen und zu steuern, aus denen sich unsere verschiedenen Umgebungen zusammensetzen. Zu diesem Zweck müssen Sie ein API-Token erstellen, das im Handbuch behandelt wird.

Erstellen Sie die Main Cloud Minion-Konfiguration

Wir beginnen mit der Erstellung einer Konfigurationsdatei unter "+ / etc / salt / cloud +". Dies wird als gemeinsame Option für alle Server verwendet, die wir erstellen werden. Erstellen und öffnen Sie die Datei jetzt:

sudo nano /etc/salt/cloud

Die einzige Konfiguration, die wir an dieser Stelle anwenden, sind die Optionen "+ / etc / salt / minion ", die auf jedem der von uns erstellten Server festgelegt werden. Verwenden Sie die Taste " Minion: +", um die Struktur dieser Informationen zu beginnen:

/ etc / salt / cloud

minion:

Geben Sie zunächst unter diesem Schlüssel die IP-Adresse des Salt-Masterservers an. Dies ist die wichtigste Einstellung, da der Salt Minion nach der Bereitstellung eine Verbindung zum Master herstellen kann:

/ etc / salt / cloud

minion:
 master:

Note

Als nächstes müssen wir einige Minenfunktionen einrichten. Salt Minions können so konfiguriert werden, dass die Ergebnisse der Salt-Ausführungsmodule an ein zentrales Repository auf dem Salt-Master zurückgesendet werden. Dieses System bietet Minion-Servern die Möglichkeit, wichtige Informationen mit anderen Minions zu teilen.

Wir wollen zwei Minenfunktionen einrichten. Diese geben einfach die öffentlichen und privaten IP-Adressen des Minions an den Salt Master zurück. Andere Schergen können dann den Master nach diesen Informationen abfragen, um zu erfahren, wie man sich mit Gleichaltrigen verbindet:

/ etc / salt / cloud

minion:
 master:
 mine_functions:
   external_ip:
     - mine_function: network.interface_ip
     - eth0
   internal_ip:
     - mine_function: network.interface_ip
     - eth1

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Richten Sie den DigitalOcean Cloud Provider ein

Als Nächstes konfigurieren wir eine DigitalOcean-Cloud-Provider-Datei. Diese enthält die Informationen, die zum Herstellen einer Verbindung zu unserem DigitalOcean-Konto erforderlich sind, sowie einige allgemeine Einstellungen, die wir für die von uns erstellten Server verwenden möchten.

Erstellen Sie zunächst ein Verzeichnis für unsere Anbieterinformationen:

sudo mkdir -p /etc/salt/cloud.providers.d

Erstellen und öffnen Sie eine Datei mit dem Namen "+ do.conf +":

sudo nano /etc/salt/cloud.providers.d/do.conf

Im Inneren werden wir eine weitere YAML-Struktur erstellen. Der Schlüssel der obersten Ebene in der Struktur ist der Name des Anbieters. Wir werden hier "do" verwenden. Der + Treiber + gibt an, welche Cloud verwendet werden soll. Der Treiber von DigitalOcean in Salt heißt "+ digital_ocean +":

/etc/salt/cloud.providers.d/do.conf

do:
 driver: digital_ocean

Als Nächstes müssen Sie zu Ihrem DigitalOcean-Konto wechseln und ein API-Token erstellen. Sie können zum API-Bereich des Control Panels gelangen, indem Sie this link folgen. Klicken Sie oben rechts auf der Seite auf die Schaltfläche "Neuen Token erstellen":

image: https://assets.digitalocean.com/articles/salt_series_cloud/generate_new_token.png [DigitalOcean API-Token erstellen]

Geben Sie auf der folgenden Seite einen aussagekräftigen Namen ein und klicken Sie auf "Token generieren":

image: https://assets.digitalocean.com/articles/salt_series_cloud/name_token.png [DigitalOcean-Namenstoken]

Im unteren Bereich der nächsten Seite wird Ihr neues Token angezeigt:

image: https://assets.digitalocean.com/articles/salt_series_cloud/new_token.png [DigitalOcean neues Token]

Kopieren Sie diesen Wert, bevor Sie die Seite verlassen, da er nicht mehr angezeigt wird. Wenn Sie dies vergessen, zerstören Sie das Token und generieren Sie ein neues.

Setzen Sie in Ihrer Provider-Konfigurationsdatei die Option "+ personal_access_token +" auf den Wert des generierten Tokens, das Sie kopiert haben:

/etc/salt/cloud.providers.d/do.conf

do:
 driver: digital_ocean
 personal_access_token:

Als Nächstes geben wir die SSH-Schlüsselinformationen an. Der Befehl "+ salt-cloud " muss sich zunächst mit SSH bei den Servern anmelden, um den Salt Minion einzurichten. Wir werden den Schlüssel " ssh_key_file " so setzen, dass er auf den Speicherort im Dateisystem verweist, an den wir unseren privaten SSH-Schlüssel in Kürze kopieren werden. Sie sollten " ssh_key_names +" auf den Namen des SSH-Schlüssels setzen, den Sie DigitalOcean hinzugefügt haben:

/etc/salt/cloud.providers.d/do.conf

do:
 driver: digital_ocean
 personal_access_token:
 ssh_key_file: /etc/salt/pki/cloud/do.pem
 ssh_key_names: ,

Wir müssen auch das Skript und die Skriptargumente angeben, damit wir die genaue Version von Salt steuern können, die für neue Schergen bereitgestellt wird:

/etc/salt/cloud.providers.d/do.conf

do:
 driver: digital_ocean
 personal_access_token:
 ssh_key_file: /etc/salt/pki/cloud/do.pem
 ssh_key_names: ,
 script: bootstrap-salt
 script_args: -P git

Speichern und schließen Sie die Datei, wenn Sie fertig sind. Wir können sehen, dass unsere Anbieterkonfiguration von der Salt Mater übernommen wurde, indem wir Folgendes eingeben:

sudo salt-cloud --list-providers
Outputdo:
   ----------
   digital_ocean:
       ----------

Sie können Ihren API-Schlüssel testen, indem Sie Folgendes eingeben:

sudo salt-cloud --list-locations do

Es sollte eine Liste der verfügbaren Regionen für die Bereitstellung angezeigt werden.

Erstellen Sie die SSH-Schlüsseldatei

Bevor wir fortfahren, sollten wir die private SSH-Schlüsseldatei erstellen, auf die wir in der Anbieterdatei verwiesen haben. Erstellen Sie zunächst die erforderliche Verzeichnisstruktur:

sudo mkdir -p /etc/salt/pki/cloud

Als nächstes erstellen Sie eine Datei mit dem Namen "+ do.pem +" im neu erstellten Verzeichnis:

sudo nano /etc/salt/pki/cloud/do.pem

Fügen Sie den Inhalt Ihres privaten Schlüssels ein, der einem Ihrer DigitalOcean-Schlüssel zugeordnet ist, den Sie in der Direktive + ssh_key_names + in der Provider-Datei angegeben haben. Normalerweise können Sie den Inhalt Ihres privaten Schlüssels abrufen, indem Sie Folgendes in Ihren * lokalen Computer * eingeben:

cat ~/.ssh/id_rsa

Es sollte ungefähr so ​​aussehen:

~ / .ssh / id_rsa auf dem lokalen Computer

-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEA39KuD8htHaIgUGFezpTsW0Y5XtNuoSTwVg/nih1rlVyKQIkJ
UhJRAakJ9ktQjSWdyAQr0i563WU1KYeHMzQuPPOQAK0vTbMjO5StuzqPEVfPPI1n
PIbMeAg9rjX5Lhy/jSOcTwf0E91jTMYuxkZCMCIDTzeVEFLV744APotQktCruJXf
L53cVUedOI1fQTEKGa1xEk92Ja4jm/Fn+4WKqYVTKRd2/vHX/ej8bI9Pomamskvc

. . .

hd4tdQKBgQCD8s2IbXVfGQ8x0D12a5K7sfysdnESF5I5ladEAoWP4wYctuGdlDso
lBl+jlm1di+1gPqBDMdJhic48ExRBVjKfB1adDeiwhzD4zNxFakhBXHjXHj6MBps
Oo/13JyvRs6QRpBolJfVaG1b5CAR+EhAJkxxCxWch8dlwE1gb9jxXw==
-----END RSA PRIVATE KEY-----

Fügen Sie das in die Datei unter + / etc / salt / pki / cloud / do.pem + ein und speichern und schließen Sie die Datei.

Damit Salt den Schlüssel verwenden kann, müssen die Datei und das Verzeichnis, in denen sich der Schlüssel befindet, über die richtigen Berechtigungen verfügen. Legen Sie die Berechtigungen fest, indem Sie Folgendes eingeben:

sudo chmod 700 /etc/salt/pki/cloud
sudo chmod 600 /etc/salt/pki/cloud/do.pem

Salt kann jetzt den privaten Schlüssel lesen und ihn zum Anmelden bei neuen Servern verwenden.

Richten Sie Cloud-Profile ein

Nachdem Sie den DigitalOcean-Anbieter konfiguriert haben, können wir Profile erstellen. Diese Profile definieren die Eigenschaften, die beim Erstellen neuer Serverinstanzen verwendet werden sollen. Wir können so viele konfigurieren, wie wir möchten.

Wir speichern diese Dateien in einem Verzeichnis + cloud.profiles.d +. Erstellen Sie dieses Verzeichnis jetzt:

sudo mkdir -p /etc/salt/cloud.profiles.d

In diesem Handbuch wird für jede zu konfigurierende Umgebung eine separate Datei verwendet. Beginnen wir mit der Entwicklungsumgebung:

sudo nano /etc/salt/cloud.profiles.d/dev-profiles.conf

Jedes Profil wird unter einem Profilnamen der obersten Ebene angegeben. Der Name ist das, was wir verwenden, wenn wir ein Droplet unter Verwendung der angegebenen Details erstellen möchten.

Wir beginnen mit der Angabe eines "+ base-dev +" - Profils. Darin sind die grundlegenden Eigenschaften enthalten, die alle unsere Entwicklungsmaschinen gemeinsam haben. In diesem Handbuch geben wir an, dass Ubuntu 14.04 64-Bit auf einem 1-Gigabyte-Droplet in der Region NYC3 verwendet werden soll. NYC3 ist die Region, in der unser Salt Master eingesetzt wird, sodass wir bei Bedarf über private Netzwerke kommunizieren können. In diesem Sinne werden wir das private Netzwerk (dies wird in unserer Konfiguration verwendet!) Und auch IPv6 aktivieren.

Sie können die Größe und den Bereich mithilfe der von diesen Befehlen zurückgegebenen Informationen beliebig ändern:

sudo salt-cloud --list-locations do
sudo salt-cloud --list-sizes do

In der zurückgegebenen Ausgabe ist der mit der Größe und Position, die Sie verwenden möchten, verknüpfte „Slug“ der Name, den Sie in Ihrer Konfiguration verwenden sollten.

Unter Verwendung der oben beschriebenen Droplet-Informationen sieht unser + base-dev + folgendermaßen aus:

/etc/salt/cloud.profiles.d/dev-profiles.conf

base-dev:
 provider: do
 image: ubuntu-14-04-x64
 size: 1gb
 location: nyc3
 private_networking: True
 ipv6: True

Dieses Profil enthält die meisten Details, die wir benötigen, aber wir möchten auch einige benutzerdefinierte Salzkörner in unsere Diener aufnehmen. Diese werden für die Ausrichtung auf bestimmte Computer verwendet, basierend auf der Rolle, die sie in der Infrastruktur und der Umgebung spielen, zu der sie gehören.

Wir können dies tun, indem wir das Basisprofil „verlängern“. Durch Erweitern können Sie ein neues Profil angeben, das die Eigenschaften eines vorhandenen Profils übernimmt, und Sie können neue Werte hinzufügen. Die Vererbung ist jedoch ziemlich wählerisch und lässt nur eine einzige Erweiterung zu (keine Erweiterung einer Erweiterung). Außerdem ersetzen Listenelemente (wie unsere Körner) frühere Daten, anstatt sie anzufügen (weshalb wir unsere Umgebung nicht in der Basis angeben konnten, obwohl sie von allen Servern in der Umgebung gemeinsam genutzt wird).

Das Webserver-spezifische Profil ist ziemlich einfach. Es verwendet alle ursprünglichen Attribute und fügt die beiden angegebenen Körner hinzu. Wir verwenden die Rolle "Webserver". Wir werden im gesamten Tutorial dagegen vorgehen. Die Entwicklungsumgebung wird durch den Wert "dev" angegeben:

/etc/salt/cloud.profiles.d/dev-profiles.conf

base-dev:
 provider: do
 image: ubuntu-14-04-x64
 size: 1gb
 location: nyc3
 private_networking: True
 ipv6: True

dev-web:
 extends: base-dev
 minion:
   grains:
     role: webserver
     env: dev

Unser Datenbankprofil funktioniert fast genauso. Wir werden einfach die Rolle "dbserver" anstelle von "webserver" verwenden und die Profil-ID "+ dev-db +" verwenden:

/etc/salt/cloud.profiles.d/dev-profiles.conf

base-dev:
 provider: do
 image: ubuntu-14-04-x64
 size: 1gb
 location: nyc3
 private_networking: True
 ipv6: True

dev-web:
 extends: base-dev
 minion:
   grains:
     role: webserver
     env: dev

dev-db:
 extends: base-dev
 minion:
   grains:
     role: dbserver
     env: dev

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Wir werden eine ähnliche Datei für unsere Staging-Umgebung erstellen. Erstellen Sie die Datei, indem Sie Folgendes eingeben:

sudo nano /etc/salt/cloud.profiles.d/stage-profiles.conf

Das "+ base-stage " - Profil ist genau das gleiche wie das " base-dev +" - Profil. Die erweiterten Profile stimmen auch eng mit den vorherigen Definitionen überein und ändern nur die Umgebung und die Namen. Wir fügen auch ein erweitertes Profil für unseren Load Balancer hinzu, da dies ein Servertyp ist, der in unserer Entwicklungsumgebung nicht vorhanden ist:

/etc/salt/cloud.profiles.d/stage-profiles.conf

base-stage:
 provider: do
 image: ubuntu-14-04-x64
 size: 1gb
 location: nyc3
 private_networking: True
 ipv6: True

stage-web:
 extends: base-stage
 minion:
   grains:
     role: webserver
     env: stage

stage-db:
 extends: base-stage
 minion:
   grains:
     role: dbserver
     env: stage

stage-lb:
 extends: base-stage
 minion:
   grains:
     role: lbserver
     env: stage

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Zuletzt erstellen wir die Produktionsprofile:

sudo nano /etc/salt/cloud.profiles.d/prod-profiles.conf

Die Produktionsprofile sind nahezu identisch mit den Staging-Profilen. Wir ändern einfach jede Instanz des Strings "stage" mit "prod":

/etc/salt/cloud.profiles.d/prod-profiles.conf

base-prod:
 provider: do
 image: ubuntu-14-04-x64
 size: 1gb
 location: nyc3
 private_networking: True
 ipv6: True

prod-web:
 extends: base-prod
 minion:
   grains:
     role: webserver
     env: prod

prod-db:
 extends: base-prod
 minion:
   grains:
     role: dbserver
     env: prod

prod-lb:
 extends: base-prod
 minion:
   grains:
     role: lbserver
     env: prod

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Testen Sie, ob Ihre Profile erfasst werden, indem Sie Folgendes eingeben:

sudo salt-cloud --list-profiles do

Sie sollten eine Liste aller von Ihnen konfigurierten Profile sehen.

Umgebungskarten erstellen

Wir haben jetzt Profile, die genau definieren, wie die einzelnen Server erstellt werden, die wir benötigen. Wir können diese einfach verwenden, um die Server, die wir benötigen, einzeln zu erstellen.

"+ Salt-cloud +" kann jedoch auch zusätzliche Konfigurationsdateien nutzen, die "Maps" genannt werden. In Maps können Sie auf die von uns erstellten Profile verweisen, um die gesamte Infrastruktur zu skizzieren, die Sie erstellen möchten. Sie geben die Namen der Server an, die Sie für jeden Profiltyp erstellen möchten.

Erstellen Sie ein Verzeichnis für die Kartendateien mit dem Namen "+ cloud.maps.d +":

sudo mkdir -p /etc/salt/cloud.maps.d

Beginnen wir mit der Definition unserer Entwicklungsumgebung. Erstellen und öffnen Sie eine Datei mit dem Namen "+ dev-environment.map +" in diesem Verzeichnis:

sudo nano /etc/salt/cloud.maps.d/dev-environment.map

Wenn Sie sich an die previous article erinnern, in der die zu konfigurierenden Umgebungen beschrieben wurden, verfügt unsere Entwicklungsumgebung nur über zwei Server: ein Webserver und ein Datenbankserver. Wenn Sie dies wissen, sollte unsere Entwicklungszuordnungsdatei folgendermaßen aussehen:

/etc/salt/cloud.maps.d/dev-environment.map

dev-web:
 - dev-web

dev-db:
 - dev-db

Das Element der obersten Ebene gibt das Profil an, mit dem die Ressource bereitgestellt wird. Die Liste unter dem Profilnamen (mit einem Bindestrich gekennzeichnet) gibt die Namen der Server an, die hochgefahren werden sollen.

In diesem Beispiel werden ein Webserver mit dem Namen "dev-web" und ein Datenbankserver mit dem Namen "dev-db" definiert. Diese Server können beide gleichzeitig erstellt werden, indem Sie auf diese Datei zeigen. Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Als Nächstes erstellen wir die Staging-Umgebungskarte:

sudo nano /etc/salt/cloud.maps.d/stage-environment.map

Unsere Staging-Umgebung verfügt über zwei Webserver, zwei Datenbankserver und einen Lastenausgleich. Wir werden unsere redundanten Server nummerieren, um sie voneinander zu unterscheiden. Unsere Karte sollte ungefähr so ​​aussehen:

/etc/salt/cloud.maps.d/stage-environment.map

stage-web:
 - stage-www1
 - stage-www2

stage-db:
 - stage-db1
 - stage-db2

stage-lb:
 - stage-lb

Mit dieser Datei können insgesamt fünf Server bereitgestellt werden. Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Schließlich können wir unsere Produktionsumgebungs-Zuordnungsdatei erstellen, indem wir Folgendes eingeben:

sudo nano /etc/salt/cloud.maps.d/prod-environment.map

Dies wird unserer Staging-Umgebungszuordnung ziemlich ähnlich sein (mit den offensichtlichen Ausnahmen der Servernamen und der verwendeten Profile). Die Produktion verfügt über einen zusätzlichen Lastenausgleich, sodass das Failover konfiguriert werden kann:

/etc/salt/cloud.maps.d/prod-environment.map

prod-web:
 - prod-www1
 - prod-www2

prod-db:
 - prod-db1
 - prod-db2

prod-lb:
 - prod-lb1
 - prod-lb2

Mit dieser Datei können die für unsere Produktionsumgebung benötigten Bare-Server in Betrieb genommen werden. Speichern und schließen Sie es, wenn Sie fertig sind.

Bereitstellung der Testumgebung

Nachdem wir unsere Kartendateien erstellt haben, können wir einfach eine oder alle unsere Umgebungen hochfahren.

Bevor wir dies tun können, müssen wir das Salt-Bootstrap-Skript auf unseren Master-Server herunterladen. Der Master stellt eine Verbindung zum Minion her, lädt das Skript hoch und führt es aus, um Salt Minions auf den von uns erstellten Servern zu starten.

Laden Sie das Bootstrap-Skript herunter, indem Sie Folgendes eingeben:

sudo salt-cloud -u

Dieser Befehl sollte gelegentlich ausgeführt werden, um sicherzustellen, dass Sie die neueste Version des Bootstrap-Skripts verwenden.

Sobald das Bootstrap-Skript heruntergeladen wurde, können Sie jede Ihrer Umgebungen mit dem Befehl + salt-cloud + starten. Wir werden dies mit der Entwicklungsumgebung testen, da sie den Prozess mit den wenigsten Ressourcen demonstriert.

Wir übergeben das Flag "+ -P ", um " salt-cloud " anzuweisen, die Server parallel zu erstellen. Ohne dies würde Salt warten, bis ein Server das Bootstrapping beendet hat, bevor mit der Arbeit am nächsten Server begonnen wird. Wir müssen das ` -m +` Flag verwenden und es auf die Umgebungskarte verweisen, die wir verwenden möchten.

Der vollständige Befehl sieht folgendermaßen aus:

sudo salt-cloud -P -m /etc/salt/cloud.maps.d/dev-environment.map

Sie werden aufgefordert, die Erstellung der beiden in dieser Datei definierten Server zu bestätigen:

Output[INFO    ] salt-cloud starting
[INFO    ] Applying map from '/etc/salt/cloud.maps.d/dev-environment.map'.
[INFO    ] Starting new HTTPS connection (1): api.digitalocean.com
The following virtual machines are set to be created:
 dev-db
 dev-web

Proceed? [N/y]

Geben Sie "Y" ein, um die Server zu erstellen.

Nachdem die Server erstellt wurden, können Sie die Salt-Verbindung überprüfen, indem Sie Folgendes eingeben:

sudo salt '*' test.ping

Sie sollten eine Antwort von Ihrem Salt Master Minion und den beiden neuen Entwicklungsmaschinen erhalten. Während des Bereitstellungsprozesses generierte und akzeptierte der Salt-Master Schlüssel für die neuen Server, bevor er sie auf die Minion-Maschinen stellte. Aus diesem Grund müssen wir nicht "+ salt-key +" verwenden, um jeden der neuen Schlüssel zu akzeptieren. Die neuen Server sollten sofort antworten:

Outputdev-db:
   True
sm:
   True
dev-web:
   True

Sie können die Map-Datei verwenden, um die Befehle "+ salt-cloud +" als Gruppe an die definierten Server zu senden. Wenn Sie momentan nicht vorhaben, die Entwicklungsmaschinen zu verwenden, können Sie sie jederzeit wieder zerstören, indem Sie Folgendes eingeben:

sudo salt-cloud -d -m /etc/salt/cloud.maps.d/dev-environment.map

Dadurch werden die Server über die API zerstört und die Minion-Schlüssel aus dem Speicher entfernt.

Alternativ können Sie einzelne Maschinen nach Namen zerstören:

sudo salt-cloud -d dev-db

Wenn Sie dies tun, erstellt "+ salt-cloud +" beim nächsten Erstellen mit der Kartendatei nur die Server, die noch nicht vorhanden sind:

sudo salt-cloud -P -m /etc/salt/cloud.maps.d/dev-environment.map
Output[INFO    ] salt-cloud starting
[INFO    ] Applying map from '/etc/salt/cloud.maps.d/dev-environment.map'.
[INFO    ] Starting new HTTPS connection (1): api.digitalocean.com
[WARNING ] u'dev-web' already exists, removing from the create map.
The following virtual machines already exist:
 dev-web
The following virtual machines are set to be created:
 dev-db

Proceed? [N/y]

Testen Sie an dieser Stelle Ihre anderen Kartendateien, um sicherzustellen, dass sie die für die zu konfigurierenden Umgebungen erforderlichen Server ordnungsgemäß bereitstellen können.

Fazit

Zu diesem Zeitpunkt sollte Ihr Salt-Master-Server in der Lage sein, Ressourcen mithilfe des DigitalOcean-Cloud-Anbieters hochzufahren. Wir haben Profile für die Eigenschaften unserer einzelnen Maschinen erstellt und Karten erstellt, um die einzelnen Server, die wir für jedes Setup benötigen, einfach zu beschreiben.

In der next guide in dieser Reihe werden wir uns mit dem Konfigurationsmanagement von Salt befassen Funktionen durch Einrichten einer reproduzierbaren Nginx-Konfiguration.

Related