Como Usar o Terraform com DigitalOcean

Introdução

O Terraform é uma ferramenta para construir e gerenciar infraestrutura de forma organizada. Você pode usá-lo para gerenciar Droplets da DigitalOcean, Balanceadores de Carga e até entradas DNS, além de uma grande variedade de serviços oferecidos por outros provedores. O Terraform utiliza uma interface de linha de comando e pode ser executado a partir do seu desktop ou de um servidor remoto.

O Terraform funciona lendo arquivos de configuração que descrevem os componentes que compõem o ambiente da sua aplicação ou datacenter. Com base na configuração, ele gera um plano de execução que descreve o que será feito para alcançar o estado desejado. Em seguida, você usa o Terraform para executar este plano e construir a infraestrutura. Quando ocorrem mudanças na configuração, o Terraform pode gerar e executar planos incrementais para atualizar a infraestrutura existente para o estado recém-descrito.

Neste tutorial, você irá instalar o Terraform e usá-lo para criar uma infraestrutura na DigitalOcean que consiste em dois servidores Nginx que são balanceados por um Balanceador de Carga da DigitalOcean. Em seguida, você usará o Terraform para adicionar uma entrada DNS na DigitalOcean que aponta para o seu Balanceador de Carga. Isso ajudará você a começar a usar o Terraform e dará uma ideia de como você pode usá-lo para gerenciar e implantar uma infraestrutura baseada na DigitalOcean que atenda às suas próprias necessidades.

Pré-requisitos

Para concluir este tutorial, você precisará de:

• A DigitalOcean account. If you do not have one, sign up for a new account.
• A DigitalOcean Personal Access Token, which you can create via the DigitalOcean control panel. Instructions to do that can be found at: How to Create a Personal Access Token.
• A password-less SSH key added to your DigitalOcean account, which you can create by following How To Use SSH Keys with DigitalOcean Droplets. When you add the key to your account, remember the name you give it, as you’ll need it in this tutorial. (For Terraform to accept the name of your key, it must start with a letter or underscore and may contain only letters, digits, underscores, and dashes.)
• A personal domain pointed to DigitalOcean’s nameserver, which you can do by following the tutorial, How To Point to DigitalOcean Nameservers From Common Domain Registrars.

Passo 1 — Instalando o Terraform

O Terraform é uma ferramenta de linha de comando que você executa no seu computador ou em um servidor remoto. Para instalá-lo, você irá baixá-lo e colocá-lo no seu PATH para que você possa executá-lo em qualquer diretório em que esteja trabalhando.

Primeiro, baixe o pacote apropriado para o seu sistema operacional e arquitetura da página oficial de downloads. Se estiver usando macOS ou Linux, você pode baixar o Terraform com o curl.

No macOS, use este comando para baixar o Terraform e colocá-lo no seu diretório home:

curl -o ~/terraform.zip https://releases.hashicorp.com/terraform/1.1.3/terraform_1.1.3_darwin_amd64.zip 

No Linux, use este comando:

curl -o ~/terraform.zip https://releases.hashicorp.com/terraform/1.1.3/terraform_1.1.3_linux_amd64.zip 

Crie o diretório ~/opt/terraform:

mkdir -p ~/opt/terraform

Em seguida, descompacte o Terraform para ~/opt/terraform usando o comando unzip. No Ubuntu, você pode instalar o unzip usando o apt:

sudo apt install unzip

Use-o para extrair o arquivo baixado para o diretório ~/opt/terraform executando:

unzip ~/terraform.zip -d ~/opt/terraform

Finalmente, adicione ~/opt/terraform à sua variável de ambiente PATH para que você possa executar o comando terraform sem especificar o caminho completo para o executável.

No Linux, você precisará redefinir o PATH no .bashrc, que é executado quando um novo shell é aberto. Abra-o para edição executando:

nano ~/.bashrc

Para acrescentar o caminho do Terraform ao seu PATH, adicione a seguinte linha no final do arquivo:

export PATH=$PATH:~/opt/terraform

Salve e feche o arquivo quando terminar.

Agora todas as suas novas sessões de shell serão capazes de encontrar o comando terraform. Para carregar o novo PATH na sua sessão atual, execute o seguinte comando se estiver usando o Bash em um sistema Linux:

. ~/.bashrc

Se estiver usando o Bash no macOS, execute este comando em vez disso:

. .bash_profile

Se estiver usando o ZSH, execute este comando:

. .zshrc

Para verificar se você instalou o Terraform corretamente, execute o comando terraform sem argumentos:

terraform

Você verá uma saída semelhante à seguinte:

Output
Usage: terraform [global options] <subcommand> [args]

The available commands for execution are listed below.
The primary workflow commands are given first, followed by
less common or more advanced commands.

Main commands:
  init          Prepare your working directory for other commands
  validate      Check whether the configuration is valid
  plan          Show changes required by the current configuration
  apply         Create or update infrastructure
  destroy       Destroy previously-created infrastructure

All other commands:
  console       Try Terraform expressions at an interactive command prompt
  fmt           Reformat your configuration in the standard style
  force-unlock  Release a stuck lock on the current workspace
  get           Install or upgrade remote Terraform modules
  graph         Generate a Graphviz graph of the steps in an operation
  import        Associate existing infrastructure with a Terraform resource
  login         Obtain and save credentials for a remote host
  logout        Remove locally-stored credentials for a remote host
  output        Show output values from your root module
  providers     Show the providers required for this configuration
  refresh       Update the state to match remote systems
  show          Show the current state or a saved plan
  state         Advanced state management
  taint         Mark a resource instance as not fully functional
  test          Experimental support for module integration testing
  untaint       Remove the 'tainted' state from a resource instance
  version       Show the current Terraform version
  workspace     Workspace management

Global options (use these before the subcommand, if any):
  -chdir=DIR    Switch to a different working directory before executing the
                given subcommand.
  -help         Show this help output, or the help for a specified subcommand.
  -version      An alias for the "version" subcommand.

Esses são os comandos que o Terraform aceita. A saída fornece uma breve descrição, e você aprenderá mais sobre eles ao longo deste tutorial.

Agora que o Terraform está instalado, vamos configurá-lo para funcionar com os recursos da DigitalOcean.

Passo 2 — Configurando o Terraform para a DigitalOcean

O Terraform suporta uma variedade de provedores de serviços por meio de provedores que você pode instalar. Cada provedor tem suas próprias especificações, que geralmente mapeiam para a API de seu respectivo provedor de serviços.

O provedor DigitalOcean permite que o Terraform interaja com a API da DigitalOcean para construir infraestrutura. Este provedor suporta a criação de vários recursos da DigitalOcean, incluindo os seguintes:

• digitalocean_droplet: Droplets (servidores)
• digitalocean_loadbalancer: Balanceadores de carga
• digitalocean_domain: Entradas de domínio DNS
• digitalocean_record: Registros DNS

O Terraform usará seu Token de Acesso Pessoal da DigitalOcean para se comunicar com a API da DigitalOcean e gerenciar recursos em sua conta. Não compartilhe esta chave com outras pessoas e mantenha-a fora de scripts e controle de versão. Exporte seu Token de Acesso Pessoal da DigitalOcean para uma variável de ambiente chamada DO_PAT executando:

export DO_PAT="your_personal_access_token"

Isso facilitará o uso dele em comandos subsequentes e o manterá separado de seu código.

Crie um diretório que irá armazenar a configuração da sua infraestrutura executando o seguinte comando:

mkdir ~/loadbalance

Navegue até o diretório recém-criado:

cd ~/loadbalance

As configurações do Terraform são arquivos de texto que terminam com a extensão de arquivo .tf. Eles são legíveis para humanos e suportam comentários. (O Terraform também suporta arquivos de configuração no formato JSON, mas isso não será abordado aqui.) O Terraform irá ler todos os arquivos de configuração no seu diretório de trabalho de forma declarativa, então a ordem das definições de recursos e variáveis não importa. Toda a sua infraestrutura pode existir em um único arquivo de configuração, mas você deve separar os arquivos de configuração por tipo de recurso para manter a clareza.

O primeiro passo para construir uma infraestrutura com o Terraform é definir o provedor que você vai usar.

Para usar o provedor DigitalOcean com o Terraform, você precisa informar ao Terraform sobre isso e configurar o plugin com as variáveis de credencial apropriadas. Crie um arquivo chamado provider.tf, que irá armazenar a configuração do provedor:

nano provider.tf

Adicione as seguintes linhas no arquivo para informar ao Terraform que você deseja usar o provedor DigitalOcean e instruir o Terraform sobre onde encontrá-lo:

terraform {
  required_providers {
    digitalocean = {
      source = "digitalocean/digitalocean"
      version = "~> 2.0"
    }
  }
}

Em seguida, defina as seguintes variáveis no arquivo para que você possa referenciá-las no restante dos seus arquivos de configuração:

• do_token: seu Token de Acesso Pessoal DigitalOcean.
• pvt_key: localização da chave privada, para que o Terraform possa usá-la para fazer login em novos Droplets e instalar o Nginx.

Você passará os valores dessas variáveis para o Terraform quando o executar, em vez de codificá-los aqui. Isso torna a configuração mais portátil.

Para definir essas variáveis, adicione estas linhas ao arquivo:

...
variable "do_token" {}
variable "pvt_key" {}

Em seguida, adicione estas linhas para configurar o provedor DigitalOcean e especificar as credenciais da sua conta DigitalOcean atribuindo o do_token ao argumento token do provedor:

...
provider "digitalocean" {
  token = var.do_token
}

Por fim, você desejará que o Terraform adicione automaticamente sua chave SSH a quaisquer novos Droplets que você criar. Quando você adicionou sua chave SSH ao DigitalOcean, deu a ela um nome. O Terraform pode usar esse nome para recuperar a chave pública. Adicione estas linhas, substituindo terraform pelo nome da chave fornecido em sua conta DigitalOcean:

...
data "digitalocean_ssh_key" "terraform" {
  name = "terraform"
}

Seu arquivo provider.tf completo ficará assim:

terraform {
  required_providers {
    digitalocean = {
      source = "digitalocean/digitalocean"
      version = "~> 2.0"
    }
  }
}

variable "do_token" {}
variable "pvt_key" {}

provider "digitalocean" {
  token = var.do_token
}

data "digitalocean_ssh_key" "terraform" {
  name = "terraform"
}

Quando terminar, salve e feche o arquivo.

export TF_LOG=1

Inicialize o Terraform para o seu projeto executando:

terraform init

Isso lerá sua configuração e instalará os plugins para o seu provedor. Você verá isso registrado na saída:

Output
Initializing the backend...

Initializing provider plugins...
- Finding digitalocean/digitalocean versions matching "~> 2.0"...
- Installing digitalocean/digitalocean v2.16.0...
- Installed digitalocean/digitalocean v2.16.0 (signed by a HashiCorp partner, key ID F82037E524B9C0E8)

Partner and community providers are signed by their developers.
If you'd like to know more about provider signing, you can read about it here:
https://www.terraform.io/docs/cli/plugins/signing.html

Terraform has created a lock file .terraform.lock.hcl to record the provider
selections it made above. Include this file in your version control repository
so that Terraform can guarantee to make the same selections by default when
you run "terraform init" in the future.

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.

Se por acaso ficar preso e o Terraform não estiver funcionando como esperado, você pode começar novamente excluindo o arquivo terraform.tfstate e destruindo manualmente os recursos que foram criados (por exemplo, através do painel de controle).

O Terraform agora está configurado e pode ser conectado à sua conta DigitalOcean. No próximo passo, você usará o Terraform para definir um Droplet que executará um servidor Nginx.

Passo 3 — Definindo o Primeiro Servidor Nginx

Você pode usar o Terraform para criar um Droplet DigitalOcean e instalar software no Droplet assim que ele for iniciado. Neste passo, você provisionará um único Droplet Ubuntu 20.04 e instalará o servidor web Nginx usando o Terraform.

Crie um novo arquivo de configuração Terraform chamado www-1.tf, que conterá a configuração para o Droplet:

nano www-1.tf

Insira as seguintes linhas para definir o recurso Droplet:

resource "digitalocean_droplet" "www-1" {
    image = "ubuntu-20-04-x64"
    name = "www-1"
    region = "nyc3"
    size = "s-1vcpu-1gb"
    ssh_keys = [
      data.digitalocean_ssh_key.terraform.id
    ]

No configuração anterior, a primeira linha define um recurso digitalocean_droplet chamado www-1. O restante das linhas especifica os atributos do Droplet, incluindo o data center em que ele residirá e o slug que identifica o tamanho do Droplet que você deseja configurar. Neste caso, você está usando s-1vcpu-1gb, que criará um Droplet com uma CPU e 1GB de RAM. (Visite este gráfico de tamanhos de slug para ver os slugs disponíveis que você pode usar.)

A seção ssh_keys especifica uma lista de chaves públicas que você deseja adicionar ao Droplet. Neste caso, você está especificando a chave que definiu em provider.tf. Garanta que o nome aqui corresponda ao nome especificado em provider.tf.

Ao executar o Terraform contra a API da DigitalOcean, ele coletará uma variedade de informações sobre o Droplet, como seus endereços IP público e privado. Essas informações podem ser usadas por outros recursos em sua configuração.

Se você está se perguntando quais argumentos são obrigatórios ou opcionais para um recurso Droplet, consulte a documentação oficial do Terraform: Especificação do Droplet da DigitalOcean.

Para configurar uma connection que o Terraform possa usar para se conectar ao servidor via SSH, adicione as seguintes linhas no final do arquivo:

...
connection {
    host = self.ipv4_address
    user = "root"
    type = "ssh"
    private_key = file(var.pvt_key)
    timeout = "2m"
  }

Essas linhas descrevem como o Terraform deve se conectar ao servidor, para que o Terraform possa se conectar via SSH para instalar o Nginx. Observe o uso da variável de chave privada var.pvt_key — você passará seu valor quando executar o Terraform.

Agora que você configurou a conexão, configure o provisionador remote-exec, que você usará para instalar o Nginx. Adicione as seguintes linhas à configuração para fazer isso:

...
provisioner "remote-exec" {
    inline = [
      "export PATH=$PATH:/usr/bin",
      # instalar nginx
      "sudo apt update",
      "sudo apt install -y nginx"
    ]
  }
}

Observe que as strings no array inline são os comandos que o usuário root executará para instalar o Nginx.

O arquivo completo fica assim:

resource "digitalocean_droplet" "www-1" {
  image = "ubuntu-20-04-x64"
  name = "www-1"
  region = "nyc3"
  size = "s-1vcpu-1gb"
  ssh_keys = [
    data.digitalocean_ssh_key.terraform.id
  ]
  
  connection {
    host = self.ipv4_address
    user = "root"
    type = "ssh"
    private_key = file(var.pvt_key)
    timeout = "2m"
  }
  
  provisioner "remote-exec" {
    inline = [
      "export PATH=$PATH:/usr/bin",
      # instalar nginx
      "sudo apt update",
      "sudo apt install -y nginx"
    ]
  }
}

Salve o arquivo e saia do editor. Você definiu o servidor e está pronto para implantá-lo, o que fará agora.

Passo 4 — Usando o Terraform para Criar o Servidor Nginx

Sua configuração atual do Terraform descreve um único servidor Nginx. Agora você implantará o Droplet exatamente como está definido.

Execute o comando terraform plan para ver o plano de execução, ou o que o Terraform tentará fazer para construir a infraestrutura que você descreveu. Você terá que especificar os valores para o seu Token de Acesso DigitalOcean e o caminho para sua chave privada, pois sua configuração usa essas informações para acessar seu Droplet e instalar o Nginx. Execute o seguinte comando para criar um plano:

terraform plan \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa" 

Você verá uma saída semelhante a esta:

Output
Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # digitalocean_droplet.www-1 será criado
  + resource "digitalocean_droplet" "www-1" {
      + backups              = false
      + created_at           = (known after apply)
      + disk                 = (known after apply)
      + graceful_shutdown    = false
      + id                   = (known after apply)
      + image                = "ubuntu-20-04-x64"
      + ipv4_address         = (known after apply)
      + ipv4_address_private = (known after apply)
      + ipv6                 = false
      + ipv6_address         = (known after apply)
      + locked               = (known after apply)
      + memory               = (known after apply)
      + monitoring           = false
      + name                 = "www-1"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = (known after apply)
      + region               = "nyc3"
      + resize_disk          = true
      + size                 = "s-1vcpu-1gb"
      + ssh_keys             = [
          + "...",
        ]
      + status               = (known after apply)
      + urn                  = (known after apply)
      + vcpus                = (known after apply)
      + volume_ids           = (known after apply)
      + vpc_uuid             = (known after apply)
    }

Plan: 1 to add, 0 to change, 0 to destroy.

───────────────────────────────────────────────────────────────

Note: You didn't use the -out option to save this plan, so Terraform can't guarantee to take exactly these actions if you run "terraform apply" now.

A linha + recurso "digitalocean_droplet" "www-1" significa que o Terraform criará um novo recurso Droplet chamado www-1, com os detalhes que o seguem. Isso é exatamente o que deve acontecer, então execute o comando terraform apply para executar o plano atual:

terraform apply \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Você obterá a mesma saída como antes, mas desta vez, o Terraform perguntará se você deseja prosseguir:

Output
...
Plan: 1 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

Insira yes e pressione ENTER. O Terraform provisionará seu Droplet:

Output
digitalocean_droplet.www-1: Creating...

Depois de um pouco de tempo, você verá o Terraform instalando o Nginx com o provisionador remote-exec, e então o processo será concluído:

Output
digitalocean_droplet.www-1: Provisioning with 'remote-exec'...

....

digitalocean_droplet.www-1: Creation complete after 1m54s [id=your_www-1_droplet_id]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
...

O Terraform criou um novo Droplet chamado www-1 e instalou o Nginx nele. Se você visitar o endereço IP público do seu novo Droplet, verá a tela de boas-vindas do Nginx. O endereço IP público foi exibido quando o Droplet foi criado, mas você sempre pode visualizá-lo olhando para o estado atual do Terraform. O Terraform atualiza o arquivo de estado terraform.tfstate toda vez que executa um plano ou atualiza seu estado.

Para visualizar o estado atual do seu ambiente, use o seguinte comando:

terraform show terraform.tfstate

Isso mostrará o endereço IP público do seu Droplet.

Output
resource "digitalocean_droplet" "www-1" {
    backups              = false
    created_at           = "..."
    disk                 = 25
    id                   = "your_www-1_droplet_id"
    image                = "ubuntu-20-04-x64"
    ipv4_address         = "your_www-1_server_ip"
    ipv4_address_private = "10.128.0.2"
    ...

Navegue para http://seu_www-1_server_ip em seu navegador para verificar se o seu servidor Nginx está em execução.

terraform refresh \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Neste passo, você implantou o Droplet que você descreveu no Terraform. Agora, você criará um segundo.

Passo 5 — Criando o Segundo Servidor Nginx

Agora que você descreveu um servidor Nginx, você pode adicionar um segundo rapidamente copiando o arquivo de configuração do servidor existente e substituindo o nome e o hostname do recurso Droplet.

Você pode fazer isso manualmente, mas é mais rápido usar o comando sed para ler o arquivo www-1.tf, substituir todas as instâncias de www-1 por www-2 e criar um novo arquivo chamado www-2.tf. Aqui está o comando sed para fazer isso:

sed 's/www-1/www-2/g' www-1.tf > www-2.tf

Você pode aprender mais sobre sed visitando Usando sed.

Execute terraform plan novamente para visualizar as alterações que o Terraform fará:

terraform plan \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

A saída mostra que o Terraform criará o segundo servidor, www-2:

Output
Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # digitalocean_droplet.www-2 será criado
  + resource "digitalocean_droplet" "www-2" {
      + backups              = false
      + created_at           = (known after apply)
      + disk                 = (known after apply)
      + id                   = (known after apply)
      + image                = "ubuntu-20-04-x64"
      + ipv4_address         = (known after apply)
      + ipv4_address_private = (known after apply)
      + ipv6                 = false
      + ipv6_address         = (known after apply)
      + locked               = (known after apply)
      + memory               = (known after apply)
      + monitoring           = false
      + name                 = "www-2"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = true
      + region               = "nyc3"
      + resize_disk          = true
      + size                 = "s-1vcpu-1gb"
      + ssh_keys             = [
          + "...",
        ]
      + status               = (known after apply)
      + urn                  = (known after apply)
      + vcpus                = (known after apply)
      + volume_ids           = (known after apply)
      + vpc_uuid             = (known after apply)
    }

Plan: 1 to add, 0 to change, 0 to destroy.
...

Execute terraform apply novamente para criar o segundo Droplet:

terraform apply \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Como antes, o Terraform irá pedir para confirmar se deseja prosseguir. Revise o plano novamente e digite yes para continuar.

Após algum tempo, o Terraform criará o novo servidor e exibirá os resultados:

Output
digitalocean_droplet.www-2: Creation complete after 1m47s [id=your_www-2_droplet_id]
...
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

O Terraform criou o novo servidor, sem alterar o existente. Você pode repetir este passo para adicionar servidores Nginx adicionais.

Agora que você tem dois Droplets executando Nginx, você definirá e implantará um balanceador de carga para dividir o tráfego entre eles.

Passo 6 — Criando o Balanceador de Carga

Você usará um Balanceador de Carga DigitalOcean, suportado pelo provedor oficial do Terraform, para rotear o tráfego entre os dois servidores web.

Crie um novo arquivo de configuração do Terraform chamado loadbalancer.tf:

nano loadbalancer.tf

Adicione as seguintes linhas para definir o Balanceador de Carga:

resource "digitalocean_loadbalancer" "www-lb" {
  name = "www-lb"
  region = "nyc3"

  forwarding_rule {
    entry_port = 80
    entry_protocol = "http"

    target_port = 80
    target_protocol = "http"
  }

  healthcheck {
    port = 22
    protocol = "tcp"
  }

  droplet_ids = [digitalocean_droplet.www-1.id, digitalocean_droplet.www-2.id ]
}

A definição do Balanceador de Carga especifica seu nome, o datacenter em que estará, as portas nas quais ele deve escutar para balancear o tráfego, a configuração para a verificação de saúde e os IDs dos Droplets que ele deve balancear, os quais você obtém usando variáveis do Terraform. Salve e feche o arquivo.

Execute o comando terraform plan novamente para revisar o novo plano de execução:

terraform plan \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Você verá várias linhas de saída, incluindo as seguintes linhas:

Output
...
Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # digitalocean_loadbalancer.www-lb será criado
  + resource "digitalocean_loadbalancer" "www-lb" {
      + algorithm                        = "round_robin"
      + disable_lets_encrypt_dns_records = false
      + droplet_ids                      = [
          + ...,
          + ...,
        ]
      + enable_backend_keepalive         = false
      + enable_proxy_protocol            = false
      + id                               = (known after apply)
      + ip                               = (known after apply)
      + name                             = "www-lb"
      + redirect_http_to_https           = false
      + region                           = "nyc3"
      + size_unit                        = (known after apply)
      + status                           = (known after apply)
      + urn                              = (known after apply)
      + vpc_uuid                         = (known after apply)

      + forwarding_rule {
          + certificate_id   = (known after apply)
          + certificate_name = (known after apply)
          + entry_port       = 80
          + entry_protocol   = "http"
          + target_port      = 80
          + target_protocol  = "http"
          + tls_passthrough  = false
        }

      + healthcheck {
          + check_interval_seconds   = 10
          + healthy_threshold        = 5
          + port                     = 22
          + protocol                 = "tcp"
          + response_timeout_seconds = 5
          + unhealthy_threshold      = 3
        }

      + sticky_sessions {
          + cookie_name        = (known after apply)
          + cookie_ttl_seconds = (known after apply)
          + type               = (known after apply)
        }
    }

Plan: 1 to add, 0 to change, 0 to destroy.
...

Isto significa que os Droplets www-1 e www-2 já existem, e o Terraform criará o Balanceador de Carga www-lb.

Execute terraform apply para construir o Balanceador de Carga:

terraform apply \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Mais uma vez, o Terraform irá pedir-lhe para revisar o plano. Aprovar o plano digitando yes para continuar.

Assim que o fizer, você verá uma saída que contém as seguintes linhas, truncadas por brevidade:

Output
...
digitalocean_loadbalancer.www-lb: Creating...
...
digitalocean_loadbalancer.www-lb: Creation complete after 1m18s [id=your_load_balancer_id]
...
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
...

Use terraform show terraform.tfstate para localizar o endereço IP do seu Balanceador de Carga:

terraform show terraform.tfstate

Você encontrará o IP sob a entrada www-lb:

Output
...
# digitalocean_loadbalancer.www-lb:
resource "digitalocean_loadbalancer" "www-lb" {
    algorithm                = "round_robin"
    disable_lets_encrypt_dns_records = false
    droplet_ids              = [
        your_www-1_droplet_id,
        your_www-2_droplet_id,
    ]
    enable_backend_keepalive = false
    enable_proxy_protocol    = false
    id                       = "your_load_balancer_id"
    ip                       = "your_load_balancer_ip"
    name                     = "www-lb"
    ...

Navegue até http://seu_endereço_ip_do_balanceador em seu navegador e você verá uma tela de boas-vindas do Nginx porque o Balanceador de Carga está enviando tráfego para um dos dois servidores Nginx.

Agora você aprenderá como configurar o DNS para sua conta DigitalOcean usando o Terraform.

Passo 7 — Criando Domínios e Registros DNS

Além de Droplets e Balanceadores de Carga, o Terraform também pode criar domínios DNS e registros de domínio. Por exemplo, se você quiser apontar seu domínio para o seu Balanceador de Carga, você pode escrever a configuração descrevendo essa relação.

Crie um novo arquivo para descrever seu DNS:

nano domain_root.tf

Adicione o seguinte recurso de domínio, substituindo seu_domínio pelo seu nome de domínio:

resource "digitalocean_domain" "default" {
   name = "your_domain"
   ip_address = digitalocean_loadbalancer.www-lb.ip
}

Salve e feche o arquivo quando terminar.

Você também pode adicionar um registro CNAME que aponta www.seu_domínio para seu_domínio. Crie um novo arquivo para o registro CNAME:

nano domain_cname.tf

Adicione estas linhas ao arquivo:

resource "digitalocean_record" "CNAME-www" {
  domain = digitalocean_domain.default.name
  type = "CNAME"
  name = "www"
  value = "@"
}

Salve e feche o arquivo quando terminar.

Para adicionar as entradas DNS, execute terraform plan seguido por terraform apply, como nos outros recursos.

Acesse seu nome de domínio e você verá uma tela de boas-vindas do Nginx porque o domínio está apontando para o Balanceador de Carga, que está enviando tráfego para um dos dois servidores Nginx.

Passo 8 — Destruindo sua Infraestrutura

Embora não seja comumente usado em ambientes de produção, o Terraform também pode destruir a infraestrutura que criou. Isso é principalmente útil em ambientes de desenvolvimento que são implantados e destruídos várias vezes.

Primeiro, crie um plano de execução para destruir a infraestrutura usando terraform plan -destroy:

terraform plan -destroy -out=terraform.tfplan \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

O Terraform irá gerar um plano com recursos marcados em vermelho e prefixados com um sinal de menos, indicando que irá excluir os recursos em sua infraestrutura.

Em seguida, use terraform apply para executar o plano:

terraform apply terraform.tfplan

O Terraform procederá à destruição dos recursos, conforme indicado no plano gerado.

Conclusão

Neste tutorial, você usou o Terraform para construir uma infraestrutura web balanceada de carga na DigitalOcean, com dois servidores web Nginx rodando atrás de um Balanceador de Carga DigitalOcean. Você sabe como criar e destruir recursos, visualizar o estado atual e usar o Terraform para configurar entradas DNS.

Agora que você entende como o Terraform funciona, você pode criar arquivos de configuração que descrevem uma infraestrutura de servidor para seus próprios projetos. O exemplo neste tutorial é um bom ponto de partida que demonstra como você pode automatizar a implantação de servidores. Se você já usa ferramentas de provisionamento, pode integrá-las ao Terraform para configurar servidores como parte de seu processo de criação, em vez de usar o método de provisionamento usado neste tutorial.

O Terraform possui muitos recursos adicionais e pode trabalhar com outros provedores. Consulte a Documentação Oficial do Terraform para aprender mais sobre como você pode usar o Terraform para melhorar sua própria infraestrutura.

Este tutorial faz parte da série Como Gerenciar Infraestrutura com Terraform. A série abrange diversos tópicos do Terraform, desde a instalação do Terraform pela primeira vez até o gerenciamento de projetos complexos.