One place for hosting & domains

      Terraform

      How to Deploy a Linode Kubernetes Engine Cluster Using Terraform


      Updated by Linode Contributed by Linode

      What is the Linode Kubernetes Engine (LKE)?

      The Linode Kubernetes Engine (LKE) is a fully-managed container orchestration engine for deploying and managing containerized applications and workloads. LKE combines Linode’s ease of use and simple pricing with the infrastructure efficiency of Kubernetes. When you deploy a LKE cluster, you receive a Kubernetes Master at no additional cost; you only pay for the Linodes (worker nodes), NodeBalancers (load balancers), and Block Storage Volumes. Your LKE Cluster’s Master node runs the Kubernetes control plane processes – including the API, scheduler, and resource controllers.

      In this Guide

      This guide will walk you through the steps needed to deploy a Kubernetes cluster using LKE and the popular infrastructure as code (IaC) tool, Terraform. Throughout the guide you will:

      Before you Begin

      1. Create a personal access token for Linode’s API v4. Follow the Getting Started with the Linode API to get a token. You will need a token to be able to create Linode resources using Terraform.

        Note

        Ensure that your token has, at minimum, Read/Write permissions for Linodes, Kubernetes, NodeBalancers, and Volumes.

      2. Review the A Beginner’s Guide to Terraform to familiarize yourself with Terraform concepts if you have not used the tool before. This guide assumes familiarity with Terraform and its native HCL syntax.

      Prepare your Local Environment

      Install Terraform

      Install Terraform on your computer by following the Install Terraform section of our Use Terraform to Provision Linode Environments guide.

      Install kubectl

      macOS:

      Install via Homebrew:

      brew install kubernetes-cli
      

      If you don’t have Homebrew installed, visit the Homebrew home page for instructions. Alternatively, you can manually install the binary; visit the Kubernetes documentation for instructions.

      Linux:

      1. Download the latest kubectl release:

        curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl
        
      2. Make the downloaded file executable:

        chmod +x ./kubectl
        
      3. Move the command into your PATH:

        sudo mv ./kubectl /usr/local/bin/kubectl
        

      Note

      Windows:

      Visit the Kubernetes documentation for a link to the most recent Windows release.

      Create your Terraform Configuration Files

      In this section, you will create Terraform configuration files that define the resources needed to create a Kubernetes cluster. You will create a main.tf file to store your resource declarations, a variables.tf file to store your input variable definitions, and a terraform.tfvars file to assign values to your input variables. Setting up your Terraform project in this way will allow you to reuse your configuration files to deploy more Kubernetes clusters, if desired.

      Create your Resource Configuration File

      Terraform defines the elements of your Linode infrastructure inside of configuration files. Terraform refers to these infrastructure elements as resources. Once you declare your Terraform configuration, you then apply it, which results in the creation of those resources on the Linode platform. The Linode Provider for Terraform exposes the Linode resources you will need to deploy a Kubernetes cluster using LKE.

      1. Navigate to the directory where you installed Terraform. Replace ~/terraform with the location of your installation.

        cd ~/terraform
        
      2. Create a new directory to store your LKE cluster’s Terraform configurations. Replace lke-cluster with your preferred directory name.

        mkdir lke-cluster
        
      3. Using the text editor of your choice, create your cluster’s main configuration file named main.tf which will store your resource definitions. Add the following contents to the file.

        ~/terraform/lke-cluster/main.tf
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        41
        42
        43
        
        //Use the Linode Provider
        provider "linode" {
          token = var.token
        }
        
        //Use the linode_lke_cluster resource to create
        //a Kubernetes cluster
        resource "linode_lke_cluster" "foobar" {
            k8s_version = var.k8s_version
            label = var.label
            region = var.region
            tags = var.tags
        
            dynamic "pool" {
                for_each = var.pools
                content {
                    type  = pool.value["type"]
                    count = pool.value["count"]
                }
            }
        }
        
        //Export this cluster's attributes
        output "kubeconfig" {
           value = linode_lke_cluster.foobar.kubeconfig
        }
        
        output "api_endpoints" {
           value = linode_lke_cluster.foobar.api_endpoints
        }
        
        output "status" {
           value = linode_lke_cluster.foobar.status
        }
        
        output "id" {
           value = linode_lke_cluster.foobar.id
        }
        
        output "pool" {
           value = linode_lke_cluster.foobar.pool
        }
            

        This file contains your cluster’s main configuration arguments and output variables. In this example, you make use of Terraform’s input variables so that your main.tf configuration can be easily reused across different clusters.

        Variables and their values will be created in separate files later on in this guide. Using separate files for variable declaration allows you to avoid hard-coding values into your resources. This strategy can help you reuse, share, and version control your Terraform configurations.

        This configuration file uses the Linode provider to create a Kubernetes cluster. All arguments within the linode_lke_cluster.foobar resource are required, except for tags. The pool argument accepts a list of pool objects. In order to read their input variable values, the configuration file makes use of Terraform’s dynamic blocks. Finally, output values are declared in order to capture your cluster’s attribute values that will be returned to Terraform after creating your cluster.

        Note

        For a complete linode_lke_cluster resource argument reference, see the Linode Provider Terraform documentation. You can update the main.tf file to include any additional arguments you would like to use.

      Define your Input Variables

      You are now ready to define the input variables that were referenced in your main.tf file.

      1. Create a new file named variables.tf in the same directory as your main.tf file. Add the following contents to the file:

        ~/terraform/lke-cluster/variables.tf
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        41
        42
        43
        
            variable "token" {
              description = "Your Linode API Personal Access Token.(required)."
            }
        
            variable "k8s_version" {
              description = "The Kubernetes version to use for this cluster.(required)"
              default = "1.17"
            }
        
            variable "label" {
              description = "The unique label to assign to this cluster.(required)"
              default = "default-lke-cluster"
            }
        
            variable "region" {
              description = "The region where your cluster will be located.(required)"
              default = "us-east"
            }
        
            variable "tags" {
              description = "Tags to apply to your cluster for organizational purposes.(optional)"
              type = list(string)
              default = ["testing"]
            }
        
            variable "pools" {
              description = "The Node Pool specifications for the Kubernetes cluster.(required)"
              type = list(object({
                type = string
                count = number
              }))
              default = [
                {
                  type = "g6-standard-4"
                  count = 3
                },
                {
                  type = "g6-standard-8"
                  count = 3
                }
              ]
            }
            

        This file describes each variable and provides them with default values. You can update the file with your own preferred default values.

      Assign Values to your Input Variables

      You will now need to define the values you would like to use in order to create your Kubernetes cluster. These values are stored in a separate file named terraform.tfvars. This file should be the only file that requires updating when reusing the files created in this guide to deploy a new Kubernetes cluster or to add a new node pool to the cluster.

      1. Create a new file named terraform.tfvars to provide values for all the input variables declared in the previous section.

        Note

        If you leave out a variable value in this file, Terraform will use the variable’s default value that you provided in your variables.tf file.

        $~/terraform/lke-cluster/terraform.tfvars
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        
        label = "example-lke-cluster"
        k8s_version = "1.17"
        region = "us-west"
        pools = [
          {
            type : "g6-standard-2"
            count : 3
          }
        ]
              

        Terraform will use the values in this file to create a new Kubernetes cluster with one node pool that contains three 4 GB nodes. The cluster will be located in the us-west data center (Dallas, Texas, USA). Each node in the cluster’s node pool will use Kubernetes version 1.17 and the cluster will be named example-lke-cluster. You can replace any of the values in this file with your own preferred cluster configurations.

      Deploy your Kubernetes Cluster

      Now that all your Terraform configuration files are ready, you can deploy your Kubernetes cluster.

      1. Ensure that you are in your lke-cluster project directory which should contain all of your Terraform configuration files. If you followed the naming conventions used in this guide, your project directory will be ~/terraform/lke-cluster.

        cd ~/terraform/lke-cluster
        
      2. Install the Linode Provider to your Terraform project directory. Whenever a new provider is used in a Terraform configuration, it must be initialized before you can create resources with it.

        terraform init
        

        You will see a message that confirms that the Linode provider plugins have been successfully initialized.

      3. Export your API token to an environment variable. Terraform environment variables have the prefix TF_VAR_ and are supplied at the command line. This method is preferable over storing your token in a plain text file. Replace the example’s token value with your own.

        export TF_VAR_token=70a1416a9.....d182041e1c6bd2c40eebd
        

        Caution

        This method commits the environment variable to your shell’s history, so take care when using this method.

      4. View your Terraform’s execution plan before deploying your infrastructure. This command won’t take any actions or make any changes on your Linode account. It will provide a report displaying all the resources that will be created or modified when the plan is executed.

        terraform plan 
        -var-file="terraform.tfvars"
        
      5. Apply your Terraform configurations to deploy your Kubernetes cluster.

        terraform apply 
        -var-file="terraform.tfvars"
        

        Terraform will begin to create the resources you’ve defined throughout this guide. This process will take several minutes to complete. Once the cluster has been successfully created the output will include a success message and the values that you exposed as output when creating your main.tf file (the example output has been truncated for brevity).

          
        Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
        
        Outputs:
        
        api_endpoints = [
          "https://91132f3d-fd20-4a70-a171-06ddec5d9c4d.us-west-2.linodelke.net:443",
          "https://91132f3d-fd20-4a70-a171-06ddec5d9c4d.us-west-2.linodelke.net:6443",
          "https://192.0.2.0:443",
          "https://192.0.2.0:6443",
        ]
        ...
                  
        

      Connect to your LKE Cluster

      Now that your Kubernetes cluster is deployed, you can use kubectl to connect to it and begin defining your workload. In this section, you will access your cluster’s kubeconfig and use it to connect to your cluster with kubectl.

      1. Use Terraform to access your cluster’s kubeconfig, decode its contents, and save them to a file. Terraform returns a base64 encoded string (a useful format for automated pipelines) representing your kubeconfig. Replace lke-cluster-config.yaml with your preferred file name.

        export KUBE_VAR=`terraform output kubeconfig` && echo $KUBE_VAR | base64 -D > lke-cluster-config.yaml
        

        Note

        Depending on your local operating system, to decode the kubeconfig’s base64 format, you may need to replace base64 -D with base64 -d. For example, this is update is needed on an Ubuntu 18.04 system.

      2. Add the kubeconfig file to your $KUBECONFIG environment variable. This will give kubectl access to your cluster’s kubeconfig file.

        export KUBECONFIG=lke-cluster-config.yaml
        
      3. Verify that your cluster is selected as kubectl’s current context:

        kubectl config get-contexts
        
      4. View all nodes in your Kubernetes cluster using kubectl:

        kubectl get nodes
        

        Your output will resemble the following example, but will vary depending on your own cluster’s configurations.

          
        NAME                        STATUS   ROLES    AGE   VERSION
        lke4377-5673-5eb331ac7f89   Ready       17h   v1.17.0
        lke4377-5673-5eb331acab1d   Ready       17h   v1.17.0
        lke4377-5673-5eb331acd6c2   Ready       17h   v1.17.0
            
        

        Now that you are connected to your LKE cluster, you can begin using kubectl to deploy applications, inspect and manage cluster resources, and view logs.

      Destroy your Kubernetes Cluster (optional)

      Terraform includes a destroy command to remove resources managed by Terraform.

      1. Run the plan command with the -destroy option to verify which resources will be destroyed.

        terraform plan -destroy
        

        Follow the prompt to enter your Linode API v4 access token and review the report to ensure the resources you expect to be destroyed are listed.

      2. Destroy the resources outlined in the above command.

        terraform destroy
        

        Follow the prompt to enter your Linode API v4 access token and type in yes when prompted to destroy your Kubernetes cluster.

      More Information

      You may wish to consult the following resources for additional information on this topic. While these are provided in the hope that they will be useful, please note that we cannot vouch for the accuracy or timeliness of externally hosted materials.

      This guide is published under a CC BY-ND 4.0 license.



      Source link

      Erstellen eines Hashicorp-Vault-Servers mit Packer und Terraform in DigitalOcean [Schnellstart]


      Einführung

      Vault von Hashicorp ist ein Open-Source-Tool, um Geheimnisse und sensible Daten in dynamischen Cloud-Umgebungen sicher zu speichern. Packer und Terraform, ebenfalls von Hashicorp entwickelt, können zusammen verwendet werden, um Images von Vault zu kreieren und bereitzustellen.

      In diesem Tutorial erstellen Sie mit Packer einen unveränderlichen Snapshot des Systems mit installiertem Vault und dirigieren dessen Bereitstellung mit Terraform.

      Eine ausführlichere Version dieses Tutorials finden Sie in Erstellen eines Hashicorp Vault-Servers mit Packer und Terraform in DigitalOcean.

      Voraussetzungen

      • Auf Ihrem lokalen Rechner installierter Packer. Lesen Sie für Anweisungen die offizielle Dokumentation.
      • Auf Ihrem lokalen Rechner installiertes Terraform. Lesen Sie die offizielle Dokumentation für eine Anleitung.
      • Ein persönliches Zugriffstoken (API-Schlüssel) mit Lese- und Schreibberechtigungen für Ihr DigitalOcean-Konto. Besuchen Sie Erstellen eines persönlichen Zugriffstokens, um ein Token zu erstellen.
      • Einen SSH-Schlüssel, den Sie zur Authentifizierung mit den bereitgestellten Vault Droplets verwenden, die auf Ihrem lokalen Rechner verfügbar sind und Ihrem DigitalOcean-Konto hinzugefügt werden. Sie benötigen auch dessen Fingerabdruck, den Sie von der Security-Seite Ihres Kontos nach dem Erstellen kopieren können. Besuchen Sie die DigitalOcean-Dokumentation für detaillierte Anweisungen oder das Tutorial Einrichten von SSH-Schlüsseln.

      Schritt 1 — Erstellen einer Packer-Vorlage

      Erstellen und wechseln Sie in das Verzeichnis ~/vault-orchestration, um Ihre Vault-Dateien zu speichern:

      • mkdir ~/vault-orchestration
      • cd ~/vault-orchestration

      Erstellen Sie separate Verzeichnisse für die Packer- und Terraform-Konfiguration, indem Sie Folgendes ausführen:

      Navigieren Sie zum Verzeichnis Packer:

      Verwenden von Vorlagenvariablen

      Erstellen Sie eine variables.json in Ihrem packer-Unterverzeichnis, um Ihre privaten variablen Daten zu speichern:

      Fügen Sie die folgenden Zeilen hinzu:

      ~/vault-orchestration/packer/variables.json

      {
        "do_token": "your_do_api_key",
        "base_system_image": "ubuntu-18-04-x64",
        "region": "nyc3",
        "size": "s-1vcpu-1gb"
      }
      

      Sie verwenden diese Variablen in der Vorlage, die Sie erstellen. Sie können die Werte Basisbild, Region und Droplet-Größe entsprechend den developer docs bearbeiten.

      Ersetzen Sie your_do_api_key durch Ihren API-Schlüssel. Speichern und schließen Sie dann die Datei.

      Erstellen von Builders und Provisioners

      Erstellen Sie Ihre Packer-Vorlage für Vault in einer Datei namens template.json:

      Fügen Sie die folgenden Zeilen hinzu:

      ~/vault-orchestration/packer/template.json

      {
         "builders": [{
             "type": "digitalocean",
             "api_token": "{{user `do_token`}}",
             "image": "{{user `base_system_image`}}",
             "region": "{{user `region`}}",
             "size": "{{user `size`}}",
             "ssh_username": "root"
         }],
         "provisioners": [{
             "type": "shell",
             "inline": [
                 "sleep 30",
                 "sudo apt-get update",
                 "sudo apt-get install unzip -y",
                 "curl -L https://releases.hashicorp.com/vault/1.3.2/vault_1.3.2_linux_amd64.zip -o vault.zip",
                 "unzip vault.zip",
                 "sudo chown root:root vault",
                 "mv vault /usr/local/bin/",
                 "rm -f vault.zip"
             ]
      }]
      }
      

      Sie definieren einen einfachen digitalocean-Builder. Packer erstellt ein temporäres Droplet der definierten Größe, des definierten Bilds und der definierten Region, wobei der bereitgestellte API-Schlüssel verwendet wird.

      Der Provisioner stellt über SSH eine Verbindung mit dem angegebenen Benutzernamen her und führt nacheinander alle definierten Provisioners aus, bevor ein DigitalOcean-Snapshot aus dem Droplet erstellt und gelöscht wird.

      Es ist eine Art Shell, die die angegebenen Befehle auf das Ziel ausführt. Die Befehle in der Vorlage warten 30 Sekunden, bis das System hochgefahren ist. Anschließend wird Vault 1.3.2 heruntergeladen und entpackt. Konsultieren Sie die offizielle Vault-Downloadseite, um die aktuellste Version für Linux zu erhalten.

      Speichern und schließen Sie die Datei.

      Überprüfen Sie die Gültigkeit Ihrer Vorlage:

      • packer validate -var-file=variables.json template.json

      Sie sehen die folgende Ausgabe:

      Output

      Template validated successfully.

      Schritt 2 — Erstellen des Snapshots

      Erstellen Sie Ihren Snapshot mit dem Packer-Befehl build:

      • packer build -var-file=variables.json template.json

      Sie sehen eine Menge Ausgabe, die so aussehen wird:

      Output

      digitalocean: output will be in this color. ==> digitalocean: Creating temporary ssh key for droplet... ==> digitalocean: Creating droplet... ==> digitalocean: Waiting for droplet to become active... ==> digitalocean: Using ssh communicator to connect: ... ==> digitalocean: Waiting for SSH to become available... ==> digitalocean: Connected to SSH! ==> digitalocean: Provisioning with shell script: /tmp/packer-shell035430322 ... ==> digitalocean: % Total % Received % Xferd Average Speed Time Time Time Current ==> digitalocean: Dload Upload Total Spent Left Speed digitalocean: Archive: vault.zip ==> digitalocean: 100 45.5M 100 45.5M 0 0 154M 0 --:--:-- --:--:-- --:--:-- 153M digitalocean: inflating: vault ==> digitalocean: Gracefully shutting down droplet... ==> digitalocean: Creating snapshot: packer-1581537927 ==> digitalocean: Waiting for snapshot to complete... ==> digitalocean: Destroying droplet... ==> digitalocean: Deleting temporary ssh key... Build 'digitalocean' finished. ==> Builds finished. The artifacts of successful builds are: --> digitalocean: A snapshot was created: 'packer-1581537927' (ID: 58230938) in regions '...'

      Die letzte Zeile enthält den Namen des Snapshots (wie packer-1581537927) und seine ID in Klammern, wie hier hervorgehoben. Notieren Sie sich die ID des Snapshots, da Sie diese im nächsten Schritt benötigen.

      Falls der Build-Prozess durch Fehler in der API fehlschlägt, warten Sie einige Minuten und versuchen Sie es dann erneut.

      Schritt 3 — Schreiben der Terraform-Konfiguration

      Navigieren Sie zum Unterverzeichnis terraform:

      • cd ~/vault-orchestration/terraform

      Erstellen Sie eine Datei namens do-provider.tf, um den Provider zu speichern:

      Fügen Sie die folgenden Zeilen hinzu:

      ~/vault-orchestration/terraform/do-provider.tf

      variable "do_token" {
      }
      
      variable "ssh_fingerprint" {
      }
      
      variable "instance_count" {
      default = "1"
      }
      
      variable "do_snapshot_id" {
      }
      
      variable "do_name" {
      default = "vault"
      }
      
      variable "do_region" {
      }
      
      variable "do_size" {
      }
      
      variable "do_private_networking" {
      default = true
      }
      
      provider "digitalocean" {
      token = var.do_token
      }
      

      Diese Datei stellt dem digitalocean-Provider einen API-Schlüssel zur Verfügung. Um die Werte dieser Variablen anzugeben, erstellen Sie eine Variablendefinitionsdatei, ähnlich wie bei Packer. Der Dateiname muss entweder auf .tfvars oder auf .tfvars.json enden.

      Speichern und schließen Sie die Datei.

      Erstellen Sie eine Variablendefinitionsdatei:

      Fügen Sie die folgenden Zeilen hinzu:

      ~/vault-orchestration/terraform/definitions.tf

      do_token         = "your_do_api_key"
      ssh_fingerprint  = "your_ssh_key_fingerprint"
      do_snapshot_id   = your_do_snapshot_id
      do_name          = "vault"
      do_region        = "nyc3"
      do_size          = "s-1vcpu-1gb"
      instance_count   = 1
      

      Ersetzen Sie your_do_api_key, your_ssh_key_fingerprint und your_do_snapshot_id (die Snapshot-ID, die Sie im vorherigen Schritt notiert haben). Die Parameter do_region und do_size müssen die gleichen Werte wie in der Packer-Variablendatei haben.

      Speichern und schließen Sie die Datei.

      Erstellen Sie die folgende Datei, um die Bereitstellungskonfiguration des Vault-Snapshots zu speichern:

      Fügen Sie die folgenden Zeilen hinzu:

      ~/vault-orchestration/terraform/deployment.tf

      resource "digitalocean_droplet" "vault" {
      count              = var.instance_count
      image              = var.do_snapshot_id
      name               = var.do_name
      region             = var.do_region
      size               = var.do_size
      private_networking = var.do_private_networking
      ssh_keys = [
        var.ssh_fingerprint
      ]
      }
      
      output "instance_ip_addr" {
      value = {
        for instance in digitalocean_droplet.vault:
        instance.id => instance.ipv4_address
      }
      description = "The IP addresses of the deployed instances, paired with their IDs."
      }
      

      Sie definieren eine einzelne resource vom Typ digitalocean_droplet namens vault. Sie legen ihre Parameter entsprechend den Variablenwerten fest und fügen (mit seinem Fingerabdruck) einen SSH-Schlüssel von Ihrem DigitalOcean-Konto zur Droplet-Ressource hinzu. Sie output die IP-Adressen aller neu erstellten Instanzen an die Konsole aus.

      Speichern und schließen Sie die Datei.

      Initialisieren Sie das Verzeichnis als Terraform-Projekt:

      Sie sehen die folgende Ausgabe:

      Output

      Initializing the backend... Initializing provider plugins... The following providers do not have any version constraints in configuration, so the latest version was installed. To prevent automatic upgrades to new major versions that may contain breaking changes, it is recommended to add version = "..." constraints to the corresponding provider blocks in configuration, with the constraint strings suggested below. * provider.digitalocean: version = "~> 1.14" Terraform has been successfully initialized! You may now begin working with Terraform. Try running "terraform plan" to see any changes that are required for your infrastructure. All Terraform commands should now work. If you ever set or change modules or backend configuration for Terraform, rerun this command to reinitialize your working directory. If you forget, other commands will detect it and remind you to do so if necessary.

      Schritt 4 — Bereitstellung von Vault mit Terraform

      Testen Sie die Gültigkeit Ihrer Konfiguration:

      Sie sehen die folgende Ausgabe:

      Output

      Success! The configuration is valid.

      Führen Sie den Befehl plan aus, um zu sehen, was Terraform bei der Bereitstellung der Infrastruktur versucht:

      • terraform plan -var-file="definitions.tfvars"

      Die Ausgabe wird ähnlich sein wie:

      Output

      Refreshing Terraform state in-memory prior to plan... The refreshed state will be used to calculate this plan, but will not be persisted to local or remote state storage. ------------------------------------------------------------------------ An execution plan has been generated and is shown below. Resource actions are indicated with the following symbols: + create Terraform will perform the following actions: # digitalocean_droplet.vault[0] will be created + resource "digitalocean_droplet" "vault" { ... } Plan: 1 to add, 0 to change, 0 to destroy. ------------------------------------------------------------------------ Note: You didn't specify an "-out" parameter to save this plan, so Terraform can't guarantee that exactly these actions will be performed if "terraform apply" is subsequently run.

      Führen Sie den Plan aus:

      • terraform apply -var-file="definitions.tfvars"

      Das Droplet wird die Bereitstellung abschließen und Sie sehen eine Ausgabe, die etwa folgendermaßen aussieht:

      Output

      An execution plan has been generated and is shown below. Resource actions are indicated with the following symbols: + create Terraform will perform the following actions: + digitalocean_droplet.vault-droplet ... Plan: 1 to add, 0 to change, 0 to destroy. ... digitalocean_droplet.vault-droplet: Creating... ... Apply complete! Resources: 1 added, 0 changed, 0 destroyed. Outputs: instance_ip_addr = { "181254240" = "your_new_server_ip" }

      Schritt 5 — Verifizieren Ihres bereitgestellten Droplet

      Führen Sie Folgendes aus, um sich mit Ihrem neuen Droplet zu verbinden:

      Nach der Anmeldung führen Sie Vault aus mit:

      Sie sehen die entsprechende “Hilfe”-Ausgabe:

      Output

      Usage: vault <command> [args] Common commands: read Read data and retrieves secrets write Write data, configuration, and secrets delete Delete secrets and configuration list List data or secrets login Authenticate locally agent Start a Vault agent server Start a Vault server status Print seal and HA status unwrap Unwrap a wrapped secret Other commands: audit Interact with audit devices auth Interact with auth methods debug Runs the debug command kv Interact with Vault's Key-Value storage lease Interact with leases namespace Interact with namespaces operator Perform operator-specific tasks path-help Retrieve API help for paths plugin Interact with Vault plugins and catalog policy Interact with policies print Prints runtime configurations secrets Interact with secrets engines ssh Initiate an SSH session token Interact with tokens

      Zusammenfassung

      Sie verfügen jetzt über ein automatisiertes System zur Bereitstellung von Hashicorp Vault auf DigitalOcean Droplets mit Unterstützung von Terraform und Packer. Um Vault zu verwenden, müssen Sie es initialisieren und weiter konfigurieren. Anweisungen hierzu finden Sie in den Offiziellen Dokumenten.

      Weitere Tutorials zur Verwendung von Terraform finden Sie auf der Terraform Content Page.



      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