One place for hosting & domains

      importieren

      So importieren und exportieren Sie eine MongoDB-Datenbank unter Ubuntu 20.04


      Der Autor hat den COVID-19 Relief Fund dazu ausgewählt, eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      MongoDB ist eine der beliebtesten NoSQL-Datenbank-Engines. Es ist berühmt für seine Skalierbarkeit, Leistung, Zuverlässigkeit und Benutzerfreundlichkeit. In diesem Artikel zeigen wir Ihnen, wie Sie Ihre MongoDB-Datenbanken importieren und exportieren.

      Wir sollten klarstellen, dass unter Import und Export diejenigen Vorgänge zu verstehen sind, die Daten in einem für Menschen lesbaren Format verarbeiten, das mit anderen Softwareprodukten kompatibel ist. Im Gegensatz dazu erstellen oder verwenden die Sicherungs- und Wiederherstellungsvorgänge MongoDB-spezifische Binärdaten, wodurch die Konsistenz und Integrität Ihrer Daten sowie deren spezifische MongoDB-Attribute erhalten bleiben. Daher ist es für die Migration normalerweise vorzuziehen, Backup und Wiederherstellung zu verwenden, solange das Quell- und das Zielsystem kompatibel sind.

      Backup-, Wiederherstellungs- und Migrationsaufgaben gehen über den Rahmen dieses Artikels hinaus. Weitere Informationen finden Sie unter So sichern Sie eine MongoDB-Datenbank unter Ubuntu 20.04.

      Voraussetzungen

      Um dieses Tutorial zu absolvieren, benötigen Sie Folgendes:

      Schritt 1 — Importieren von Informationen in MongoDB

      Um zu erfahren, wie Informationen in MongoDB importiert werden, verwenden wir eine beliebte Beispiel-MongoDB-Datenbank über Restaurants. Sie ist im .json-Format und kann mit wget wie folgt heruntergeladen werden:

      • wget https://raw.githubusercontent.com/mongodb/docs-assets/primer-dataset/primer-dataset.json

      Sobald der Download abgeschlossen ist, sollten Sie eine Datei mit dem Namen primer-dataset.json (12 MB Größe) im aktuellen Verzeichnis haben. Importieren wir die Daten aus dieser Datei in eine neue Datenbank namens newdb und in eine Sammlung mit dem Namen Restaurants.

      Verwenden Sie den Befehl mongoimport wie folgt:

      • sudo mongoimport --db newdb --collection restaurants --file primer-dataset.json

      Das Ergebnis sieht folgendermaßen aus:

      Output

      2020-11-11T19:37:55.607+0000 connected to: mongodb://localhost/ 2020-11-11T19:37:57.841+0000 25359 document(s) imported successfully. 0 document(s) failed to import

      Wie der obige Befehl zeigt, wurden 25359 Dokumente importiert. Da wir keine Datenbank mit dem Namen newdb haben, hat MongoDB sie automatisch erstellt.

      Überprüfen wir den Import.

      Stellen Sie eine Verbindung mit der neu erstellten newdb-Datenbank her:

      Sie sind nun mit der newdb-Datenbankinstanz verbunden. Beachten Sie, dass sich Ihre Eingabeaufforderung geändert hat, was anzeigt, dass Sie mit der Datenbank verbunden sind.

      Zählen Sie die Dokumente in der Sammlung Restaurants mit dem Befehl:

      Das Ergebnis zeigt 25359, was die Anzahl importierter Dokumente ist. Für eine noch bessere Überprüfung können Sie das erste Dokument aus der Sammlung Restaurants wie folgt auswählen:

      Das Ergebnis sieht folgendermaßen aus:

      [secondary label Output]
      {
          "_id" : ObjectId("5fac3d937f12c471b3f26733"),
          "address" : {
              "building" : "1007",
              "coord" : [
                  -73.856077,
                  40.848447
              ],
              "street" : "Morris Park Ave",
              "zipcode" : "10462"
          },
          "borough" : "Bronx",
          "cuisine" : "Bakery",
          "grades" : [
              {
                  "date" : ISODate("2014-03-03T00:00:00Z"),
                  "grade" : "A",
                  "score" : 2
              },
      ...
          ],
          "name" : "Morris Park Bake Shop",
          "restaurant_id" : "30075445"
      }
      

      Eine solche detaillierte Überprüfung kann Probleme mit den Dokumenten wie ihrem Inhalt, der Codierung usw. enthüllen. Das Format json verwendet UTF-8-Codierung und Ihre Exporte und Importe sollten in dieser Codierung vorhanden sein. Denken Sie daran, wenn Sie die json-Dateien manuell bearbeiten. Andernfalls verarbeitet MongoDB dies automatisch für Sie.

      Um die MongoDB-Eingabeaufforderung zu beenden, geben Sie exit an die Eingabeaufforderung ein:

      Sie werden als non-root user zur normalen Befehlszeilenaufforderung zurückgegeben.

      Schritt 2 — Exportieren von Informationen aus MongoDB

      Wie bereits erwähnt, können Sie durch den Export von MongoDB-Informationen eine für Menschen lesbare Textdatei mit Ihren Daten abrufen. Standardmäßig werden Informationen im JSON-Format exportiert. Sie können sie jedoch auch nach CSV exportieren (durch Kommas getrennter Wert).

      Um Informationen aus MongoDB zu exportieren, verwenden Sie den Befehl mongoexport. Es ermöglicht Ihnen, einen sehr feinkörnigen Export zu exportieren, sodass Sie eine Datenbank, eine Sammlung, ein Feld und sogar eine Abfrage für den Export angeben können.

      Ein einfaches mongoexport-Beispiel wäre die Sammlung Restaurants aus der newdb-Datenbank, die wir zuvor importiert haben. Dies kann wie folgt erfolgen:

      • sudo mongoexport --db newdb -c restaurants --out newdbexport.json

      Im obigen Befehl verwenden wir --db, um die Datenbank -c für die Sammlung und --out für die Datei zu spezifizieren, in der die Daten gespeichert werden.

      Die Ausgabe eines erfolgreichen mongoexport sollte folgendermaßen aussehen:

      Output

      2020-11-11T19:39:57.595+0000 connected to: mongodb://localhost/ 2020-11-11T19:39:58.619+0000 [###############.........] newdb.restaurants 16000/25359 (63.1%) 2020-11-11T19:39:58.871+0000 [########################] newdb.restaurants 25359/25359 (100.0%) 2020-11-11T19:39:58.871+0000 exported 25359 records

      Die obige Ausgabe zeigt, dass 25359 Dokumente importiert wurden, die gleiche Anzahl wie die importierten sind.

      In einigen Fällen müssen Sie möglicherweise nur einen Teil Ihrer Sammlung exportieren. Angesichts der Struktur und den Inhalt der Restaurants-json-Datei exportieren wir alle Restaurants, die die Kriterien erfüllen, die sich in der Bronx befinden und chinesische Küche anbieten. Wenn wir diese Informationen direkt während der Verbindung mit MongoDB erhalten möchten, stellen Sie erneut eine Verbindung zur Datenbank her:

      Verwenden Sie dann diese Abfrage:

      • db.restaurants.find( { "borough": "Bronx", "cuisine": "Chinese" } )

      Die Ergebnisse werden dem Terminal angezeigt:

      Output

      • 2020-12-03T01:35:25.366+0000 connected to: mongodb://localhost/
      • 2020-12-03T01:35:25.410+0000 exported 323 records

      Um die MongoDB-Eingabeaufforderung zu beenden, geben Sie exit ein:

      Wenn Sie die Daten von einer sudo-Befehlszeile exportieren möchten, anstatt mit der Datenbank verbunden zu sein, machen Sie die vorherige Abfrage zu einem Teil des mongoexport-Befehls, indem Sie sie für das Argument -q wie folgt angeben:

      • sudo mongoexport --db newdb -c restaurants -q "{"borough": "Bronx", "cuisine": "Chinese"}" --out Bronx_Chinese_retaurants.json

      Beachten Sie, dass wir die doppelten Anführungszeichen mit Backslash () in der Abfrage umgehen. Ähnlich müssen Sie alle anderen Sonderzeichen in der Abfrage umgehen.

      Wenn der Export erfolgreich war, sollte das Ergebnis folgendermaßen aussehen:

      Output

      2020-11-11T19:49:21.727+0000 connected to: mongodb://localhost/ 2020-11-11T19:49:21.765+0000 exported 323 records

      Das obige Beispiel zeigt, dass 323 Datensätze exportiert wurden, und Sie können sie in der von uns angegebenen Datei Bronx_Chinese_retaurants.json finden.

      Verwenden Sie cat und less, um die Daten zu durchsuchen:

      • cat Bronx_Chinese_retaurants.json | less

      Verwenden Sie SPACE, um die Daten zu übermitteln:

      Output

      • date":{"$date":"2015-01-14T00:00:00Z"},"grade":"Z","score":36}],"na{"_id":{"$oid":"5fc8402d141f5e54f9054f8d"},"address":{"building":"1236","coord":[-73.8893654,40.81376179999999],"street":"238 Spofford Ave","zipcode":"10474"},"borough":"Bronx","cuisine":"Chinese","grades":[{"date":{"$date":"2013-12-30T00:00:00Z"},"grade":"A","score":8},{"date":{"$date":"2013-01-08T00:00:00Z"},"grade":"A","score":10},{"date":{"$date":"2012-06-12T00:00:00Z"},"grade":"B","score":15}],
      • . . .

      Drücken Sie q, um zu beenden. Sie können nun eine MongoDB-Datenbank importieren und exportieren.

      Zusammenfassung

      Dieser Artikel hat Sie in die Grundlagen zum Importieren und Exportieren von Informationen zu und aus einer MongoDB-Datenbank eingeführt. Sie können weitere Informationen über So sichern Sie eine MongoDB-Datenbank unter Ubuntu 20.04 lesen.

      Sie können auch die Replikation berücksichtigen. Durch die Replikation können Sie Ihren MongoDB-Dienst ohne Unterbrechung von einem Slave-MongoDB-Server aus fortsetzen, während Sie den Master-Dienst nach einem Fehler wiederherstellen. Teil der Replikation ist das Betriebsprotokoll (oplog), das alle Operationen aufzeichnet, die Ihre Daten ändern. Sie können dieses Protokoll genauso verwenden wie das Binärprotokoll in MySQL, um Ihre Daten nach dem letzten Backup wiederherzustellen. Denken Sie daran, dass Backups normalerweise nachts stattfinden. Wenn Sie sich entscheiden, abends einen Backup wiederherzustellen, fehlen Ihnen alle Aktualisierungen seit dem letzten Backup.



      Source link

      So importieren Sie vorhandene DigitalOcean-Assets in Terraform


      Der Autor wählte den Free and Open Source Fund, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Terraform ist ein von HashiCorp entwickeltes Infrastruktur-als-Code-Tool, das Entwicklern bei der Bereitstellung, Aktualisierung und Entfernung verschiedener Assets ihrer Infrastruktur auf effiziente und skalierbare Weise hilft.

      Entwickler können Terraform verwenden, um verschiedene Umgebungen zu organisieren, Änderungen durch Versionskontrolle zu verfolgen und sich wiederholende Arbeiten zu automatisieren, um menschliche Fehler einzuschränken. Es bietet auch eine Möglichkeit für Teams, gemeinsam an der Verbesserung ihrer Infrastruktur durch freigegebene Konfigurationen zu arbeiten.

      In diesem Tutorial werden Sie die bestehende DigitalOcean-Infrastruktur in Terraform importieren. Am Ende dieses Tutorials werden Sie in der Lage sein, Terraform für Ihre gesamte bestehende Infrastruktur zu verwenden und zusätzlich neue Assets zu erstellen.

      Voraussetzungen

      Schritt 1 – Lokale Installation von Terraform

      In diesem ersten Schritt installieren Sie Terraform auf Ihrem lokalen Rechner. Dieser Schritt beschreibt die Installation der Linux-Binary. Wenn Sie Windows oder Mac verwenden, können Sie die Seite Terraform herunterladen auf der Terraform-Website aufrufen.

      Gehen Sie zu dem Ordner, in den Sie Terraform auf Ihrem lokalen Rechner herunterladen möchten, und verwenden Sie dann das Tool wget, um die Terraform 0.12.12 Binary herunterzuladen:

      • cd /tmp
      • wget https://releases.hashicorp.com/terraform/0.12.12/terraform_0.12.12_linux_amd64.zip

      Zur Überprüfung, ob die sha256-Prüfsumme mit dem auf der Terraform-Website angegebenen Wert übereinstimmt, laden Sie die Prüfsummendatei mit dem folgenden Befehl herunter:

      • wget -q https://releases.hashicorp.com/terraform/0.12.12/terraform_0.12.12_SHA256SUMS

      Führen Sie dann den folgenden Befehl zur Verifizierung der Prüfsummen aus:

      • sha256sum -c --ignore-missing terraform_0.12.12_SHA256SUMS

      Die heruntergeladene SHA256SUMS-Datei listet die Dateinamen und ihre Hashes auf. Dieser Befehl sucht lokal nach der gleichen Datei terraform_0.12.12_SHA256SUMS und prüft dann die Übereinstimmung der Hashes it dem Flag -c. Da in dieser Datei mehr als ein Dateiname und seine Plattform aufgeführt sind, verwenden Sie das Flag --ignore-missing, um Fehler in Ihrer Ausgabe zu vermeiden, da Sie keine Kopie der anderen Dateien haben.

      Sie werden eine Ausgabe wie die folgende sehen:

      Output

      terraform_0.12.12_linux_amd64.zip: OK

      Verwenden Sie unzip, um die Binary zu extrahieren:

      • sudo unzip terraform_0.12.12_linux_amd64.zip -d /usr/local/bin/

      Überprüfen Sie nun, ob Terraform korrekt installiert ist, indem Sie die Version überprüfen:

      Sie sehen eine Ausgabe, die der folgenden ähnelt:

      Output

      Terraform v0.12.12

      Nachdem Sie Terraform auf Ihrem lokalen Rechner installiert haben, werden Sie nun die Konfigurationsdateien vorbereiten.

      Schritt 2 – Vorbereiten der Terraform-Konfigurationsdateien

      In diesem Schritt importieren Sie Ihre vorhandenen Assets in Terraform, indem Sie ein Projektverzeichnis erstellen und Konfigurationsdateien schreiben. Da Terraform derzeit die Erstellung von Konfigurationen aus dem Befehl import nicht unterstützt, müssen Sie diese Konfigurationen manuell erstellen.

      Führen Sie den folgenden Befehl aus, um Ihr Projektverzeichnis zu erstellen:

      • mkdir -p do_terraform_import

      Wechseln Sie dann in dieses Verzeichnis mit:

      In diesem Schritt erstellen Sie drei zusätzliche Dateien, die die erforderlichen Konfigurationen enthalten. Ihre Verzeichnisstruktur für dieses Projekt wird wie folgt aussehen:

      ├── digitalocean_droplet.tf
      ├── digitalocean_firewall.tf
      └── provider.tf
      

      Zu Beginn erstellen Sie die Datei provider.tf, um Ihr DigitalOcean Zugangs-Token als Umgebungsvariable zu definieren, anstatt es fest in Ihre Konfiguration zu kodieren.

      Warnung: Ihr Zugangs-Token ermöglicht den Zugriff auf Ihre komplette Infrastruktur mit uneingeschränktem Zugriff, behandeln Sie es also als solches. Stellen Sie sicher, dass Sie die einzige Person mit Zugriff auf den Rechner sind, auf dem dieses Token gespeichert ist.

      Neben Ihrem Zugangs-Token geben Sie auch an, welchen Provider Sie verwenden möchten. In diesem Tutorial ist das digitalocean. Eine vollständige Liste der verfügbaren Datenquellen und Ressourcen für DigitalOcean mit Terraform finden Sie auf der Seite der Provider auf deren Website.

      Erstellen und bearbeiten Sie provider.tf mit dem folgenden Befehl:

      Fügen Sie den folgenden Inhalt in die Datei provider.tf ein:

      provider.tf

      variable "do_token" {}
      
      provider "digitalocean" {
          token   = "${var.do_token}"
          version = "1.9.1"
          }
      

      In dieser Datei fügen Sie Ihr DigitalOcean Zugangs-Token als Variable hinzu, die Terraform als Identifikation für die DigitalOcean-API verwendet. Darüber hinaus geben Sie die Version des DigitalOcean-Provider-Plugins an. Terraform empfiehlt, dass Sie die Version des von Ihnen verwendeten Providers angeben, damit zukünftige Aktualisierungen Ihre aktuelle Einrichtung nicht potenziell beeinträchtigen.

      Jetzt erstellen Sie die Datei digitalocean_droplet.tf. Hier geben Sie die Ressource an, die Sie verwenden werden, in diesem Fall: droplet.

      Erstellen Sie die Datei mit dem folgenden Befehl:

      • nano digitalocean_droplet.tf

      Fügen Sie die folgende Konfiguration hinzu:

      digitalocean_droplet.tf

      resource "digitalocean_droplet" "do_droplet" {
          name   = "testing-terraform"
          region = "fra1"
          tags   = ["terraform-testing"]
          count  = "1"
      }
      

      Hier geben Sie vier Parameter an:

      • name: Der Droplet-Name.

      • region: Der Bereich, in dem sich das Droplet befindet.

      • tags: Eine Liste der Tags, die auf dieses Droplet angewendet werden.

      • count: die Anzahl der für diese Konfiguration erforderlichen Ressourcen.

      Als Nächstes erstellen Sie eine Konfigurationsdatei für Ihre Firewall. Erstellen Sie die Datei digitalocean_firewall.tf mit dem folgenden Befehl:

      • nano digitalocean_firewall.tf

      Fügen Sie der Datei folgenden Inhalt hinzu:

      digitalocean_firewall.tf

      resource "digitalocean_firewall" "do_firewall" {
        name  = "testing-terraform-firewall"
        tags  = ["terraform-testing"]
        count = "1"
      }
      

      Hier geben Sie den Namen der zu importierenden Firewall und die Tags der Droplets an, für die die Firewall-Regeln gelten sollen. Schließlich definiert der Wert count von 1 die erforderliche Anzahl der jeweiligen Ressource.

      Anmerkung: Sie können Firewall-Ressourcen auch in die Datei digitalocean_droplet.tf aufnehmen. Aber wenn Sie mehrere Umgebungen haben, in denen sich mehrere Droplets dieselbe Firewall teilen, wird empfohlen, sie zu trennen, falls Sie nur ein einziges Droplet entfernen möchten. Die Firewall wird dann nicht beeinträchtigt.

      Jetzt ist es an der Zeit, diese Änderungen zu initialisieren, damit Terraform die erforderlichen Abhängigkeiten herunterladen kann. Dazu verwenden Sie den Befehl terraform init, der es Ihnen ermöglicht, ein Arbeitsverzeichnis zu initialisieren, das Terraform-Konfigurationsdateien enthält.

      Führen Sie diesen Befehl von Ihrem Projektverzeichnis aus:

      Sie sehen die folgende Ausgabe:

      Output

      Terraform has been successfully initialized!

      Terraform hat das Arbeitsverzeichnis durch das Herunterladen von Plugins, die Suche nach Modulen usw. erfolgreich vorbereitet. Als Nächstes beginnen Sie damit, Ihre Assets in Terraform zu importieren.

      Schritt 3 – Importieren Ihrer Assets in Terraform

      In diesem Schritt importieren Sie Ihre DigitalOcean-Assets in Terraform. Sie verwenden doctl, um die ID-Nummern Ihrer Droplets zu finden, bevor Sie Ihre Assets importieren. Anschließend überprüfen Sie die Importkonfiguration mit den Befehlen terraform show und terraform plan.

      Zu Beginn exportieren Sie Ihr DigitalOcean Zugangs-Token als Umgebungsvariable, die Sie dann während der Laufzeit in Terraform injizieren.

      Exportieren Sie es als Umgebungsvariable in Ihre aktuelle Shell-Sitzung mit dem folgenden Befehl:

      • export DO_TOKEN="YOUR_TOKEN"

      Um Ihre vorhandenen Droplets und Firewalls zu importieren, benötigen Sie deren ID-Nummern. Sie können doctl, die Befehlszeilenschnittstelle für die DigitalOcean-API, verwenden. Führen Sie den folgenden Befehl aus, um Ihre Droplets aufzulisten und auf ihre IDs zuzugreifen:

      • doctl compute droplet list

      Sie sehen eine Ausgabe, die der folgenden ähnelt:

      Output

      ID Name Public IPv4 Private IPv4 Public IPv6 Memory VCPUs Disk Region Image Status Tags Features Volumes DROPLET-ID DROPLET-NAME DROPLET-IPv4 1024 1 25 fra1 Ubuntu 18.04.3 (LTS) x64 active DROPLET-ID DROPLET-NAME DROPLET-IPv4 2048 1 50 fra1 Ubuntu 18.04.3 (LTS) x64 active DROPLET-ID DROPLET-NAME DROPLET-IPv4 1024 1 25 fra1 Ubuntu 18.04.3 (LTS) x64

      Jetzt importieren Sie Ihr vorhandenes Droplet und Ihre Firewall in Terraform:

      • terraform import -var "do_token=${DO_TOKEN}" digitalocean_droplet.do_droplet DROPLET_ID

      Sie verwenden das Flag -var, um den Wert Ihres DigitalOcean Zugangs-Tokens anzugeben, den Sie zuvor in Ihre Shell-Sitzung exportiert haben. Dies ist erforderlich, damit die DigitalOcean-API überprüfen kann, wer Sie sind, und Änderungen an Ihrer Infrastruktur vornehmen kann.

      Führen Sie nun denselben Befehl für Ihre Firewall aus:

      • terraform import -var "do_token=${DO_TOKEN}" digitalocean_firewall.do_firewall FIREWALL_ID

      Mit dem Befehl terraform show können Sie überprüfen, ob der Import erfolgreich war. Dieser Befehl liefert eine von Menschen lesbare Ausgabe Ihres Infrastrukturstatus. Er kann verwendet werden, um einen Plan zu überprüfen und sicherzustellen, dass die gewünschten Änderungen ausgeführt werden, oder um den aktuellen Zustand aus Sicht von Terraform zu inspizieren.

      In diesem Zusammenhang bezieht sich state auf die Zuordnung Ihrer DigitalOcean-Assets zur Terraform-Konfiguration, die Sie geschrieben haben, und auf die Verfolgung von Metadaten. Auf diese Weise können Sie bestätigen, dass es keinen Unterschied zwischen den vorhandenen DigitalOcean-Assets, die Sie importieren möchten, und den Assets, die Terraform nachverfolgt, gibt:

      Sie sehen eine Ausgabe, die dieser ähnelt:

      Output

      . . . # digitalocean_droplet.do_droplet: resource "digitalocean_droplet" "do_droplet" { backups = false created_at = "2020-02-03T16:12:02Z" disk = 25 id = "DROPLET-ID" image = "DROPLET-IMAGE" ipv4_address = "DROPLET-IP" ipv6 = false locked = false memory = 1024 monitoring = false name = "testing-terraform-0" price_hourly = 0.00744 price_monthly = 5 private_networking = false region = "fra1" resize_disk = true size = "s-1vcpu-1gb" status = "active" tags = [ "terraform-testing", ] urn = "DROPLET-URN" vcpus = 1 volume_ids = [] . . . }

      Sie werden in der Ausgabe zwei Ressourcen zusammen mit ihren Attributen sehen.

      Nachdem Sie Ihr Droplet und Ihre Firewall in den Terraform-Status importiert haben, müssen Sie sicherstellen, dass die Konfigurationen den aktuellen Status der importierten Assets repräsentieren. Dazu müssen Sie das image Ihres Droplets und dessen size angeben. Diese beiden Werte finden Sie in der Ausgabe von terraform show für die Ressource digitalocean_droplet.do_droplet.

      Öffnen Sie die Datei digitalocean_droplet.tf:

      • nano digitalocean_droplet.tf

      In diesem Tutorial:

      • Ist das für unser vorhandenes Droplet verwendete Betriebssystem-Image ubuntu-16-04-x64.
      • Ist die Region, in der sich das Droplet befindet fra1.
      • Ist das Droplet-Tag für Ihr vorhandenes Droplet terraform-testing.

      Das Droplet, das Sie mit der Konfiguration in digitalocean_droplet.tf importiert haben, sieht wie folgt aus:

      digitalocean_droplet.tf

      resource "digitalocean_droplet" "do_droplet" {
          image   = "ubuntu-16-04-x64"
          name    = "testing-terraform"
          region  = "fra1"
          size    = "s-1vcpu-1gb"
          tags    = ["terraform-testing"]
      }
      

      Als Nächstes fügen Sie die Firewall-Regeln hinzu. In unserem Beispiel sind die offenen Ports für eingehenden Datenverkehr 22, 80 und 443. Alle Ports sind für ausgehenden Datenverkehr geöffnet. Sie können diese Konfiguration entsprechend Ihrer offenen Ports anpassen.

      Öffnen Sie digitalocean_firewall.tf:

      • nano digitalocean_firewall.tf

      Fügen Sie die folgende Konfiguration hinzu:

      digitalocean_firewall.tf

      resource "digitalocean_firewall" "do_firewall" {
        name  = "testing-terraform-firewall"
        tags  = ["terraform-testing"]
        count = "1"
      
        inbound_rule {
            protocol                = "tcp"
            port_range              = "22"
            source_addresses        = ["0.0.0.0/0", "::/0"]
          }
        inbound_rule {
            protocol                = "tcp"
            port_range              = "80"
            source_addresses        = ["0.0.0.0/0", "::/0"]
          }
        inbound_rule {
            protocol                = "tcp"
            port_range              = "443"
            source_addresses        = ["0.0.0.0/0", "::/0"]
          }
      
        outbound_rule {
            protocol                = "tcp"
            port_range              = "all"
            destination_addresses   = ["0.0.0.0/0", "::/0"]
          }
        outbound_rule {
            protocol                = "udp"
            port_range              = "all"
            destination_addresses   = ["0.0.0.0/0", "::/0"]
          }
        outbound_rule {
            protocol                = "icmp"
            destination_addresses   = ["0.0.0.0/0", "::/0"]
          }
      }
      

      Diese Regeln replizieren den Status der vorhandenen Beispiel-Firewall. Wenn Sie den Datenverkehr auf andere IP-Adressen, Ports oder ein anderes Protokoll beschränken möchten, können Sie die Datei so anpassen, dass sie Ihre vorhandene Firewall repliziert.

      Nachdem Sie Ihre Terraform-Dateien aktualisiert haben, verwenden Sie den Befehl plan, um zu sehen, ob die von Ihnen vorgenommenen Änderungen den Status der vorhandenen Assets auf DigitalOcean replizieren.

      Der Befehl terraform plan wird als Testlauf verwendet. Mit diesem Befehl können Sie überprüfen, ob die Änderungen, die Terraform vornehmen wird, die Änderungen sind, die Sie vornehmen möchten. Es wird empfohlen, diesen Befehl immer zur Bestätigung auszuführen, bevor Änderungen vorgenommen werden.

      Führen Sie terraform plan wie folgt aus:

      • terraform plan -var "do_token=$DO_TOKEN"

      Sie sehen eine Ausgabe, die der folgenden Ausgabe ähnelt:

      Output

      No changes. Infrastructure is up-to-date.

      Sie haben vorhandene DigitalOcean-Assets erfolgreich in Terraform importiert und können jetzt über Terraform Änderungen an Ihrer Infrastruktur vornehmen, ohne das Risiko einzugehen, bestehende Assets versehentlich zu löschen oder zu modifizieren.

      Schritt 4 – Erstellen von neuen Assets über Terraform

      In diesem Schritt fügen Sie Ihrer bestehenden Infrastruktur zwei zusätzliche Droplets hinzu. Das Hinzufügen von Assets zu Ihrer bestehenden Infrastruktur kann z. B. dann sinnvoll sein, wenn Sie eine Live-Website haben und während der Arbeit an dieser Website keine potenziell schädlichen Änderungen vornehmen wollen. Stattdessen können Sie ein weiteres Droplet als Entwicklungsumgebung hinzufügen und an Ihrem Projekt in derselben Umgebung wie das Produktions-Droplet arbeiten, ohne dass Sie dabei ein potenzielles Risiko eingehen.

      Öffnen Sie jetzt digitalocean_droplet.tf, um die Regeln für Ihre neuen Droplets hinzuzufügen:

      • nano digitalocean_droplet.tf

      Fügen Sie in Ihrer Datei die folgenden Zeilen hinzu:

      digitalocean_droplet.tf

      resource "digitalocean_droplet" "do_droplet" {
          image   = "ubuntu-16-04-x64"
          name    = "testing-terraform"
          region  = "fra1"
          size    = "s-1vcpu-1gb"
          tags    = ["terraform-testing"]
          count   = "1"
      }
      
      resource "digitalocean_droplet" "do_droplet_new" {
          image   = "ubuntu-18-04-x64"
          name    = "testing-terraform-${count.index}"
          region  = "fra1"
          size    = "s-1vcpu-1gb"
          tags    = ["terraform-testing"]
          count   = "2"
      }
      

      Mit dem Meta-Argument count teilen Sie Terraform mit, wie viele Droplets mit den gleichen Spezifikationen Sie erstellen möchten. Diese neuen Droplets werden ebenfalls zu Ihrer bestehenden Firewall hinzugefügt, da Sie das gleiche Tag wie bei Ihrer Firewall angeben.

      Wenden Sie diese Regeln an, um die Änderungen zu überprüfen, die Sie in digitalocean_droplet.tf angeben:

      • terraform plan -var "do_token=$DO_TOKEN"

      Vergewissern Sie sich, dass die Änderungen, die Sie vornehmen möchten, in der Ausgabe dieses Befehls repliziert werden.

      Sie sehen eine Ausgabe, die der folgenden ähnelt:

      Output

      . . . # digitalocean_droplet.do_droplet_new[1] will be created + resource "digitalocean_droplet" "do_droplet_new" { + backups = false + created_at = (known after apply) + disk = (known after apply) + id = (known after apply) + image = "ubuntu-18-04-x64" + ipv4_address = (known after apply) + ipv4_address_private = (known after apply) + ipv6 = false + ipv6_address = (known after apply) + ipv6_address_private = (known after apply) + locked = (known after apply) + memory = (known after apply) + monitoring = false + name = "testing-terraform-1" + price_hourly = (known after apply) + price_monthly = (known after apply) + private_networking = true + region = "fra1" + resize_disk = true + size = "s-1vcpu-1gb" + status = (known after apply) + tags = [ + "terraform-testing", ] + urn = (known after apply) + vcpus = (known after apply) + volume_ids = (known after apply) } Plan: 2 to add, 1 to change, 0 to destroy.

      Wenn Sie mit der Ausgabe zufrieden sind, verwenden Sie den Befehl terraform apply, um die von Ihnen angegebenen Änderungen auf den Status der Konfiguration anzuwenden:

      • terraform apply -var "do_token=$DO_TOKEN"

      Bestätigen Sie die Änderungen, indem Sie in der Befehlszeile yes eingeben. Nach erfolgreicher Ausführung sehen Sie eine Ausgabe, die der folgenden ähnelt:

      Output

      . . . digitalocean_droplet.do_droplet_new[1]: Creating... digitalocean_droplet.do_droplet_new[0]: Creating... digitalocean_firewall.do_firewall[0]: Modifying... [id=FIREWALL-ID] digitalocean_firewall.do_firewall[0]: Modifications complete after 1s [id=FIREWALL-ID] digitalocean_droplet.do_droplet_new[0]: Still creating... [10s elapsed] digitalocean_droplet.do_droplet_new[1]: Still creating... [10s elapsed] digitalocean_droplet.do_droplet_new[0]: Creation complete after 16s [id=DROPLET-ID] digitalocean_droplet.do_droplet_new[1]: Still creating... [20s elapsed] digitalocean_droplet.do_droplet_new[1]: Creation complete after 22s [id=DROPLET-ID] Apply complete! Resources: 2 added, 1 changed, 0 destroyed.

      Sie sehen zwei neue Droplets in Ihrem DigitalOcean Web-Panel: Neue Droplets

      Sie sehen sie auch an Ihre bestehende Firewall angebunden: Bestehende Firewall

      Sie haben mit Terraform unter Verwendung Ihrer bereits vorhandenen Assets neue Assets erstellt. Um zu erfahren, wie man diese Assets vernichtet, können Sie optional den nächsten Schritt durchführen.

      Schritt 5 – Vernichtung importierter und erstellter Assets (optional)

      In diesem Schritt vernichten Sie Assets, die Sie importiert und erstellt haben, indem Sie die Konfiguration anpassen.

      Beginnen Sie, indem Sie digitalocean_droplet.tf öffnen:

      • nano digitalocean_droplet.tf

      Setzen Sie in der Datei den count auf 0, wie im Folgenden gezeigt:

      digitalocean_droplet.tf

      resource "digitalocean_droplet" "do_droplet" {
          image   = "ubuntu-16-04-x64"
          name    = "testing-terraform"
          region  = "fra1"
          size    = "s-1vcpu-1gb"
          tags    = ["terraform-testing"]
          count   = "0"
      }
      
      resource "digitalocean_droplet" "do_droplet_new" {
          image   = "ubuntu-18-04-x64"
          name    = "testing-terraform-${count.index}"
          region  = "fra1"
          size    = "s-1vcpu-1gb"
          tags    = ["terraform-testing"]
          count   = "0"
      }
      

      Speichern und schließen Sie die Datei.

      Öffnen Sie Ihre Firewall-Konfigurationsdatei, um count auch dort zu ändern:

      • nano digitalocean_firewall.tf

      Setzten Sie count auf 0, wie in der folgenden hervorgehobenen Zeile.

      digitalocean_firewall.tf

      resource "digitalocean_firewall" "do_firewall" {
        name  = "testing-terraform-firewall"
        tags  = ["terraform-testing"]
        count = "0"
      
        inbound_rule {
            protocol                = "tcp"
            port_range              = "22"
            source_addresses        = ["0.0.0.0/0", "::/0"]
          }
        inbound_rule {
            protocol                = "tcp"
            port_range              = "80"
            source_addresses        = ["0.0.0.0/0", "::/0"]
          }
        inbound_rule {
            protocol                = "tcp"
            port_range              = "443"
            source_addresses        = ["0.0.0.0/0", "::/0"]
          }
      
        outbound_rule {
            protocol                = "tcp"
            port_range              = "all"
            destination_addresses   = ["0.0.0.0/0", "::/0"]
          }
        outbound_rule {
            protocol                = "udp"
            port_range              = "all"
            destination_addresses   = ["0.0.0.0/0", "::/0"]
          }
        outbound_rule {
            protocol                = "icmp"
            destination_addresses   = ["0.0.0.0/0", "::/0"]
          }
      }
      

      Speichern und schließen Sie die Datei.

      Wenden Sie nun diese Änderungen mit dem folgenden Befehl an:

      • terraform apply -var "do_token=${DO_TOKEN}"

      Terraform wird Sie zu der Bestätigung auffordern, dass diese Droplets und die Firewall vernichtet werden sollen. Dadurch werden alle über Terraform importierten und erstellten Assets vernichtet. Stellen Sie daher vor der Eingabe von yes sicher, dass Sie fortfahren möchten.

      Sie sehen eine Ausgabe, die der folgenden ähnelt:

      Output

      . . . digitalocean_droplet.do_droplet[0]: Destroying... [id=YOUR-DROPLET-ID]] digitalocean_droplet.do_droplet_new[0]: Destroying... [id=YOUR-DROPLET-ID] digitalocean_droplet.do_droplet_new[1]: Destroying... [id=YOUR-DROPLET-ID] digitalocean_firewall.do_firewall[0]: Destroying... [id=YOUR-FIREWALL-ID] digitalocean_firewall.do_firewall[0]: Destruction complete after 1s digitalocean_droplet.do_droplet_new[1]: Still destroying... [id=YOUR-DROPLET-ID, 10s elapsed] digitalocean_droplet.do_droplet[0]: Still destroying... [id=YOUR-DROPLET-ID, 10s elapsed] digitalocean_droplet.do_droplet_new[0]: Still destroying... [id=YOUR-DROPLET-ID, 10s elapsed] digitalocean_droplet.do_droplet_new[1]: Still destroying... [id=YOUR-DROPLET-ID, 20s elapsed] digitalocean_droplet.do_droplet_new[0]: Still destroying... [id=YOUR-DROPLET-ID, 20s elapsed] digitalocean_droplet.do_droplet[0]: Still destroying... [id=YOUR-DROPLET-ID, 20s elapsed] digitalocean_droplet.do_droplet_new[1]: Destruction complete after 22s digitalocean_droplet.do_droplet[0]: Destruction complete after 22s digitalocean_droplet.do_droplet_new[0]: Destruction complete after 22s Apply complete! Resources: 0 added, 0 changed, 4 destroyed.

      Sie haben alle von Terraform verwalteten Assets gelöscht. Dies ist ein nützlicher Workflow, wenn Sie ein Asset nicht länger benötigen oder herunterskalieren möchten.

      Zusammenfassung

      In diesem Tutorial haben Sie Terraform installiert, vorhandene Assets importiert, neue Assets erstellt und diese optional vernichtet. Sie können diesen Workflow auf ein größeres Projekt skalieren, wie z. B. auf die Bereitstellung eines produktionsbereiten Kubernetes-Clusters. Mit Terraform könnten Sie alle Knoten, DNS-Einträge, Firewalls, Speicher und andere Assets verwalten sowie die Versionskontrolle zur Verfolgung von Änderungen und zur Zusammenarbeit mit einem Team nutzen.

      Um weitere Funktionen von Terraform zu erkunden, lesen Sie deren Dokumentation. Sie können auch den Terraform-Inhalt von DigitalOcean für weitere Tutorials sowie Fragen und Antworten lesen.



      Source link