Como importar ativos existentes da DigitalOcean para o Terraform

O autor selecionou o Free and Open Source Fund para receber uma doação como parte do programa Write for DOnations.

Introdução

O Terraform é uma infraestrutura como ferramenta de código criada pela HashiCorp que ajuda os desenvolvedores a implantar, atualizar e remover diferentes ativos de sua infraestrutura de maneira eficiente e mais escalonável.

Os desenvolvedores podem usar o Terraform para organizar diferentes ambientes, rastrear alterações através do controle de versão e automatizar trabalhos repetitivos para limitar o erro humano. Ele também fornece uma maneira das equipes colaborarem na melhoria da sua infraestrutura através de configurações compartilhadas.

Neste tutorial, você importará a infraestrutura existente da DigitalOcean para o Terraform. Até o final deste tutorial, você será capaz de usar o Terraform para toda a sua infraestrutura existente, além de criar ativos.

Pré-requisitos

• Um token de acesso pessoal da DigitalOcean Para criar isso, siga o guia Como criar um token de acesso pessoal.
• Um Droplet da DigitalOcean com um rótulo. Você pode usar o seguinte guia sobre Como criar um Droplet a partir do painel de controle da DigitalOcean.
• Um firewall em nuvem da DigitalOcean aplicado ao seu Droplet. Use o guia Como criar firewalls.
• O cliente de linha de comando da DigitalOcean instalado em sua máquina local, seguindo as instruções de instalação na página do GitHub do doctl. Você pode ler o seguinte tutorial para obter orientações sobre Como usar o Doctl, o cliente de linha de comando oficial da DigitalOcean.

Passo 1 — Instalando o Terraform localmente

Neste primeiro passo, você irá instalar o Terraform em sua máquina local. Esse passo detalha a instalação do binário do Linux. Caso esteja usando o Windows ou o Mac, verifique a página de download do Terraform no site do Terraform.

Vá até a pasta de sua máquina local na qual deseja baixar o Terraform e, em seguida, utilize a ferramenta wget para baixar o binário 0.12.12 do Terraform:

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

Para verificar se a soma de verificação de sha256 apresenta o mesmo valor fornecido no site do Terraform, você baixará o arquivo de soma de verificação com o seguinte comando:

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

Em seguida, execute o comando a seguir para verificar as somas de verificação:

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

O arquivo SHA256SUMS que você baixou lista os nomes dos arquivos e seus hashes. Esse comando irá procurar pelo mesmo arquivo terraform_0.12.12_SHA256SUMS localmente e, então, verificar se as hashes correspondem usando o sinalizador -x. Como esse arquivo tem mais de um nome de arquivo e tem sua plataforma listada, use o sinalizador --ignore-missing para evitar erros no seu resultado, já que não tem uma cópia dos outros arquivos.

Você verá um resultado como o seguinte:

Output
terraform_0.12.12_linux_amd64.zip: OK

Use unzip para extrair o binário:

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

Agora, verifique se o Terraform foi instalado corretamente, verificando a versão:

terraform version

Você verá um resultado parecido com este:

Output
Terraform v0.12.12

Você instalou o Terraform na sua máquina local e agora irá preparar os arquivos de configuração.

Passo 2 — Preparando os arquivos de configuração do Terraform

Neste passo, você importará ativos existentes para o Terraform, criando um diretório de projeto e gravando os arquivos de configuração. Como o Terraform não oferece suporte à geração de configurações do comando import neste momento, você precisa criar essas configurações manualmente.

Execute o comando a seguir para criar seu diretório de projeto:

mkdir -p do_terraform_import

Em seguida, vá até esse diretório com:

cd do_terraform_import

Neste passo, você criará três arquivos adicionas que terão as configurações necessárias. Sua estrutura de diretório para esse projeto ficará parecida com a seguinte:

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

Para começar, você criará o arquivo provider.tf para definir seu token de acesso à DigitalOcean como uma variável de ambiente, em vez de embuti-lo em sua configuração.

Além do seu token de acesso, você também irá especificar qual provedor quer usar. Neste tutorial, será digitalocean. Para uma lista completa das fontes de dados e recursos disponíveis para a DigitalOcean com o Terraform, acesse a Página de provedores no seu site.

Crie e edite o provider.tf com o seguinte comando:

nano provider.tf

Adicione o seguinte conteúdo ao arquivo provider.tf:

variable "do_token" {}

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

Neste arquivo, adicione seu token de acesso da DigitalOcean como uma variável, que o Terraform usará como identificação para a API da DigitalOcean. Especifique também a versão do plug-in do provedor DigitalOcean. O Terraform recomenda que você especifique qual versão do provedor está usando, de modo que as atualizações futuras não tenham a possibilidade de inutilizar sua configuração atual.

Agora, você criará o arquivo digitalocean_droplet.tf. Aqui, você irá especificar o recurso que será usado; neste caso: droplet.

Crie o arquivo com o seguinte comando:

nano digitalocean_droplet.tf

Adicione a seguinte configuração:

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

Aqui, você especifica quatro parâmetros:

• name: o nome do Droplet.

• region: a região onde o Droplet está localizado.

• tags: uma lista de rótulos que são aplicados a esse Droplet.

• count: o número de recursos necessários para essa configuração.

Em seguida, você criará um arquivo de configuração para seu firewall. Crie o arquivo digitalocean_firewall.tf com o seguinte comando:

nano digitalocean_firewall.tf

Adicione o conteúdo a seguir ao arquivo:

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

Aqui, você especifica o nome do firewall que deseja importar e os rótulos dos Droplets aos quais as regras do firewall se aplicam. Por fim, o valor count de 1 define o número necessário do recurso específico.

Agora, é hora de inicializar essas alterações, de modo que o Terraform possa baixar as dependências necessárias. Para tanto, você usará o comando terraform init, o qual permitirá que você inicialize um diretório de trabalho que contém os arquivos de configuração do Terraform.

Execute este comando do seu diretório de projeto:

terraform init

Você verá o seguinte resultado:

Output
Terraform has been successfully initialized!

O Terraform preparou o diretório de trabalho com sucesso, baixando plug-ins, procurando módulos e assim por diante. Em seguida, você começará a importar seus ativos para o Terraform.

Passo 3 — Importando seus ativos para o Terraform

Neste passo, você importará seus ativos da DigitalOcean para o Terraform. Você usará o doctl para encontrar os números de ID dos seus Droplets, antes de importar seus ativos. Então, você irá verificar a configuração da importação com os comandos terraform show e terraform plan.

Para começar, você irá exportar seu token de acesso da DigitalOcean como uma variável de ambiente, a qual você irá, na sequência, injetar no Terraform durante o tempo de execução.

Exporte-o como uma variável de ambiente para sua sessão atual do shell com o seguinte comando:

export DO_TOKEN="YOUR_TOKEN"

Para importar seu Droplet e firewall existentes, precisará de seus números de ID. Você pode usar o doctl, a interface de linha de comando da API da DigitalOcean. Execute o comando a seguir para listar seus Droplets e acessar seus IDs:

doctl compute droplet list

Você verá um resultado parecido com este:

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

Agora, você importará seu Droplet e firewall existentes para o Terraform:

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

Use o sinalizador -var para especificar o valor do seu token de acesso à DigitalOcean - que você exportou anteriormente para sua sessão do shell. Isso é necessário para que a API da DigitalOcean possa verificar quem é você e aplicar alterações na sua infraestrutura.

Agora, execute o mesmo comando para o seu firewall:

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

Você irá verificar se a importação foi bem-sucedida, usando o comando terraform show. Esse comando possibilita que o resultado do estado de sua infraestrutura fique legível para humanos. Ele pode ser usado para inspecionar um plano, no intuito de garantir que as alterações desejadas serão executadas, ou inspecionar o estado atual - da maneira como o Terraform o vê.

Nesse contexto, state se refere ao mapeamento de seus ativos da DigitalOcean para a configuração do Terraform que você gravou e ao rastreamento dos metadados. Isso permite que você confirme se não há diferenças entre os ativos existentes da DigitalOcean que você deseja importar e os ativos que o Terraform está controlando:

terraform show

Você verá um resultado parecido com este:

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         = []
. . .
}

Você verá dois recursos no resultado, junto com seus atributos.

Após importar seu Droplet e firewall para o estado do Terraform, certifique-se de que as configurações representam o estado atual dos ativos importados. Para fazer isso, você irá especificar a image (imagem) do Droplet e seu size (tamanho). Esses dois valores podem ser encontrados no resultado do terraform show em relação ao recurso digitalocean_droplet.do_droplet.

Abra o arquivo digitalocean_droplet.tf:

nano digitalocean_droplet.tf

Neste tutorial:

• A imagem do sistema operacional usada para nosso Droplet existente é ubuntu-16-04-x64.
• A região onde o Droplet está localizado é fra1.
• O rótulo do Droplet para seu Droplet existente é terraform-testing.

O Droplet que você importou usando a configuração no digitalocean_droplet.tf ficará parecido com o seguinte:

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

Em seguida, você adicionará as regras do firewall. No nosso exemplo, as portas abertas para o tráfego de entrada são: 22, 80 e 443. Todas as portas estão abertas para o tráfego de saída. Você pode ajustar essa configuração de acordo com suas portas abertas.

Abra o digitalocean_firewall.tf:

nano digitalocean_firewall.tf

Adicione a seguinte configuração:

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"]
    }
}

Essas regras replicam o estado do firewall exemplo existente. Se quiser limitar o tráfego a diferentes endereços IP, portas diferentes ou protocolos diferentes, você pode ajustar o arquivo para replicar seu firewall existente.

Após atualizar seus arquivos do Terraform, você usará o comando plan para ver se as alterações que você fez replicam o estado dos ativos existentes na DigitalOcean.

O comando terraform plan é usado como uma simulação. Com esse comando, você pode verificar se as alterações que o Terraform irá fazer são as alterações que deseja fazer. É uma boa ideia executar sempre esse comando para confirmação, antes de aplicar alterações.

Execute o terraform plan com o seguinte:

terraform plan -var "do_token=$DO_TOKEN"

Você verá um resultado parecido com o seguinte:

Output
No changes. Infrastructure is up-to-date.

Você importou os ativos existentes da DigitalOcean com sucesso no Terraform. Agora, você pode fazer alterações na sua infraestrutura através do Terraform, sem o risco de excluir ou modificar acidentalmente ativos existentes.

Passo 4 — Criando ativos via Terraform

Neste passo, você adicionará dois Droplets adicionais à sua infraestrutura existente. Adicionar ativos dessa maneira à sua infraestrutura existente pode ser útil, por exemplo, se você tiver um site ativo e não quiser fazer quaisquer alterações com possibilidade de interromper as alterações naquele site enquanto você trabalha nele. Em vez disso, você pode adicionar mais um Droplet para usar como um ambiente de desenvolvimento e trabalhar em seu projeto no mesmo ambiente de produção do Droplet, sem qualquer risco em potencial.

Agora, abra o digitalocean_droplet.tf para adicionar as regras aos seus novos Droplets:

nano digitalocean_droplet.tf

Adicione as seguintes linhas ao seu arquivo:

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"
}

Use o meta-argumento count para informar ao Terraform quantos Droplets com as mesmas especificações você deseja. Esses novos Droplets também serão adicionados ao seu firewall existente, à medida que você especificará o mesmo rótulo, de acordo com o seu firewall.

Aplique essas regras para verificar as alterações que está especificando no digitalocean_droplet.tf:

terraform plan -var "do_token=$DO_TOKEN"

Verifique se as alterações que deseja fazer foram replicadas no resultado desse comando.

Você verá um resultado parecido com este:

. . .
[secondary_label 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.

Assim que estiver satisfeito com o resultado, use o comando terraform apply para aplicar as alterações que você especificou ao estado da configuração:

terraform apply -var "do_token=$DO_TOKEN"

Confirme as alterações, digitando yes na linha de comando. Após a execução bem-sucedida, você verá um resultado parecido com o seguinte:

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.

Você verá dois novos Droplets no seu painel Web da DigitalOcean:

Você também os verá anexados ao seu firewall existente:

Você criou ativos com o Terraform usando seus ativos existentes. Para aprender como destruir esses ativos, você pode, de maneira opcional, completar o próximo passo.

Passo 5 — Destruindo ativos importados e criados (Opcional)

Neste passo, você irá destruir os ativos que você importou e criou, ajustando a configuração.

Comece abrindo o digitalocean_droplet.tf:

nano digitalocean_droplet.tf

No arquivo, defina count como 0, de acordo com o seguinte:

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"
}

Salve e saia do arquivo.

Abra seu arquivo de configuração do firewall para alterar o count também:

nano digitalocean_firewall.tf

Defina o count como 0, assim como na linha destacada a seguir:

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"]
    }
}

Salve e saia do arquivo.

Agora, aplique essas alterações com o seguinte comando:

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

O Terraform irá pedir a você para confirmar se deseja destruir os Droplets e o firewall. Isso irá destruir todos os ativos que você importou e criou através do Terraform. Assim, certifique-se de verificar se deseja prosseguir, antes de digitar yes.

Você verá um resultado parecido com este:

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.

Você excluiu todos os ativos gerenciados pelo Terraform. Esse é um fluxo de trabalho útil se você não for mais precisar de um ativo ou se estiver fazendo uma redução.

Conclusão

Neste tutorial, você instalou o Terraform, importou ativos existentes, criou ativos e, de maneira opcional, destruiu esses ativos. Você pode dimensionar esse fluxo de trabalho para um projeto maior, como a implantação de um cluster do Kubernetes pronto para produção. Usando o Terraform, você poderia gerenciar todos os nós, entradas DNS, firewalls, armazenamento e outros ativos, além de usar o controle de versão para rastrear alterações e colaborar com uma equipe.

Para explorar outras características do Terraform, leia sua documentação. Você também pode ler o conteúdo do Terraform da DigitalOcean para obter mais tutoriais e o arquivo de Perguntas e ReDigitalOcean