One place for hosting & domains

      existentes

      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

      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:

      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:

      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.

      Aviso: seu token de acesso dá acesso irrestrito à sua infraestrutura completa, então trate-o como tal. Certifique-se de que você é a única pessoa que tem acesso à máquina onde o token está armazenado.

      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:

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

      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:

      digitalocean_droplet.tf

      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:

      digitalocean_firewall.tf

      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.

      Nota: você também pode incluir recursos de firewall no arquivo digitalocean_droplet.tf. No entanto, caso tenha vários ambientes onde vários Droplets compartilhem o mesmo firewall, é boa ideia separá-lo caso você quiser remover somente um único Droplet. Depois de fazer isso, o firewall não será afetado.

      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:

      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:

      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:

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

      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:

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

      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:

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

      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:

      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: New Droplets

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

      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:

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

      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:

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

      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



      Source link

      Cómo importar recursos existentes de DigitalOcean a Terraform


      El autor seleccionó la Free and Open Source Fund para recibir una donación como parte del programa Write for DOnations.

      Introducción

      Terraform es una herramienta de infraestructura como código creada por HashiCorp que permite a los desarrolladores a implementar, actualizar y eliminar diferentes recursos de su infraestructura de manera eficiente y más escalable.

      Los desarrolladores pueden usar Terraform para organizar diferentes entornos, realizar un seguimiento de los cambios a través del control de versiones y automatizar el trabajo repetitivo para reducir los errores humanos. La herramienta ofrece una alternativa para que los equipos colaboren en la mejora de su infraestructura a través de configuraciones compartidas.

      A través de este turorial, importará infraestructura existente de DigitalOcean a Terraform. Al finalizar, podrá utilizar Terraform para toda su infraestructura existente además de crear nuevos recursos.

      Requisitos previos

      Paso 1: Instalar Terraform de forma local

      En este primer paso, instalará Terraform en su máquina local. En este paso, se detalla la instalación del binario de Linux. Si utiliza Windows o Mac, puede revisar la página de Descarga de Terraform en el sitio web de Terraform.

      Diríjase a la carpeta en la que desee descargar Terraform en su máquina local y luego utilice la herramienta wget para descargar el binario 0.12.12 de Terraform:

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

      Para verificar si la suma de comprobación sha256 es el mismo valor que se proporciona en el sitio web de Terraform, descargará el archivo de suma de comprobación con el siguiente comando:

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

      Luego ejecute el siguiente comando para verificar las sumas de comprobación:

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

      En el archivo SHA256SUMS que descargó se enumeran los nombres de archivos y sus hash. Con este comando se buscará el mismo archivo terraform_0.12.12_SHA256SUMS de forma local y luego se verificará que los hash coincidan usando el indicador -c. Debido a que en este archivo se incluye más de un nombre de archivo y su plataforma indicada, utilice el indicador --ignore-missing para evitar errores en el resultado, ya que no tiene copias de los demás archivos.

      Verá un resultado como el siguiente:

      Output

      terraform_0.12.12_linux_amd64.zip: OK

      Utilice unzip para extraer el binario:

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

      Ahora verifique si Terraform está correctamente instalado revisando la versión:

      Visualizará un resultado similar al siguiente:

      Output

      Terraform v0.12.12

      Instaló Terraform en su máquina local. Ahora, preparará los archivos de configuración.

      Paso 2: Preparar los archivos de configuración de Terraform

      En este paso, importará sus activos existentes a Terraform creando un directorio de proyecto y escribiendo archivos de configuración. Debido a que Terraform por el momento no admite la generación de configuraciones a partir del comando import, debe crearlas de forma manual.

      Ejecute el siguiente comando para crear el directorio de su proyecto:

      • mkdir -p do_terraform_import

      Posiciónese en ese directorio con lo siguiente:

      Durante este paso, creará tres archivos adicionales que contendrán las configuraciones necesarias. Su estructura de directorios para este proyecto tendrá el siguiente aspecto:

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

      Para comenzar, creará el archivo provider.tf a fin de definir su Token de acceso de DigitalOcean como una variable de entorno en lugar de codificarlo de forma rígida en su configuración.

      Advertencia: Con su token de acceso se le proporciona acceso a toda su infraestructura sin restricciones; considérelo como tal. Asegúrese de ser la única persona que tenga acceso a la máquina en la que se almacene ese token.

      Además de su token de acceso, también especificará el proveedor que desee usar. En este tutorial, es digitalocean. Si desea acceder a una lista completa de las fuentes y los recursos de datos disponibles para DigitalOcean con Terraform, consulte la página de proveedores en el sitio web.

      Cree y edite provider.tf con el siguiente comando:

      Añada el siguiente contenido al archivo provider.tf:

      provider.tf

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

      En este archivo, se agrega el Token de acceso de DigitalOcean como una variable que Terraform usará como identificación para la API de DigitalOcean. También se especifica la versión del complemento del proveedor de DigitalOcean. Desde Terraform, se recomienda especificar la versión del proveedor que usará para que las actualizaciones futuras no puedan dañar su configuración actual.

      Ahora creará el archivo digitalocean_droplet.tf. Aquí, especificará el recurso que usará; en este caso, droplet.

      Cree el archivo con el siguiente comando:

      • nano digitalocean_droplet.tf

      Añada la siguiente configuración:

      digitalocean_droplet.tf

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

      Aquí, especifique cuatro parámetros:

      • name: nombre del Droplet.

      • region: región en la que se ubica el Droplet.

      • tags: lista de las etiquetas que se aplican a este Droplet.

      • count: número de recursos necesarios para esta configuración.

      A continuación, creará un archivo de configuración para su firewall. Cree el archivo digitalocean_firewall.tf con el siguiente comando:

      • nano digitalocean_firewall.tf

      Añada el siguiente contenido al archivo:

      digitalocean_firewall.tf

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

      Aquí especifica el nombre del firewall que desea importar y las etiquetas de los Droplets a las que se aplican las reglas del firewall. Por último, en el valor count de 1 se define el número requerido del recurso específico.

      Nota: También puede incluir recursos del firewall en el archivo digitalocean_droplet.tf. Sin embargo, si dispone de varios entornos en los cuales varios Droplets comparten el mismo firewall, se recomienda separarlo en caso de querer eliminar un solo Droplet. Esto dejará el firewall intacto.

      Ahora, es momento de inicializar esos cambios para que en Terraform se puedan descargar las dependencias necesarias. Para esto utilizará el comando terraform init, el cual le permitirá inicializar un directorio de trabajo que contenga archivos de configuración de Terraform.

      Ejecute el siguiente comando desde el directorio de su proyecto:

      Verá el siguiente resultado:

      Output

      Terraform has been successfully initialized!

      Terraform preparó de forma correcta el directorio de trabajo descargando complementos y buscando módulos, entre otras acciones. A continuación, comenzará a importar sus recursos a Terraform.

      Paso 3: Importar sus activos a Terraform

      Durante este paso, importará sus activos de DigitalOcean a Terraform. Usará doctl para encontrar los números de ID de sus Droplets antes de importar sus recursos. Luego, verificará la configuración de importación con los comandos terraform show y terraform plan.

      Para comenzar, exportará su Token de acceso de DigitalOcean como una variable de entorno que luego insertará en Terraform durante el tiempo de ejecución.

      Expórtelo como una variable de entorno a su sesión de shell actual con el siguiente comando:

      • export DO_TOKEN="YOUR_TOKEN"

      Para poder importar su Droplet y firewall existentes, necesitará los números de ID de estos. Puede usar doctl, la interfaz de línea de comandos de la API de DigitalOcean. Ejecute el siguiente comando para listar sus Droplets y acceder a sus IDs:

      • doctl compute droplet list

      Visualizará un resultado similar al siguiente:

      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

      Ahora, importará su Droplet y firewall existentes a Terraform:

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

      Se utiliza el indicador -var para especificar el valor de su Token de acceso de DigitalOcean, previamente exportado a su sesión de shell. Esto es necesario para que en la API de DigitalOcean se verifique su identidad y se apliquen cambios en su infraestructura.

      Ahora, ejecute el mismo comando para su firewall:

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

      Compruebe que la importación se haya realizado correctamente usando el comando terraform show. Este comando proporciona un resultado legible para humanos del estado de su infraestructura. Puede utilizarse para inspeccionar un plan a fin de garantizar que los cambios requeridos se ejecuten o inspeccionar el estado actual tal como se ve en Terraform.

      En este contexto, el estado hace referencia a la asignación de sus recursos de DigitalOcean en la configuración de Terraform que escribió y al seguimiento de los metadatos. Esto le permite confirmar que no existe diferencia entre los recursos existentes de DigitalOcean que desea importar y los recursos que Terraform somete a seguimiento:

      Verá un resultado similar a 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 = [] . . . }

      Verá dos recursos en el resultado junto con sus atributos.

      Después de importar su Droplet y firewall al estado de Terraform, debe asegurarse que las configuraciones representen el estado actual de los recursos importados. Para hacer esto, especificará la image de su Droplet y su size. Puede encontrar estos dos valores en el resultado de terraform show relacionado con el recurso digitalocean_droplet.do_droplet.

      Abra el archivo digitalocean_droplet.tf:

      • nano digitalocean_droplet.tf

      En este tutorial:

      • La imagen del sistema operativo empleada para nuestro Droplet existente es ubuntu-16-04-x64.
      • La región en la que se ubica su Droplet es fra1.
      • La etiqueta para su Droplet existente es terraform-testing.

      El Droplet que importó usando la configuración en digitalocean_droplet.tf tendrá el siguiente aspecto:

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

      A continuación, añadirá las reglas del firewall. En nuestro ejemplo, los puertos abiertos para el tráfico entrante son 22, 80 y 443. Todos los puertos están abiertos para el tráfico saliente. Puede ajustar esta configuración de manera correspondiente para sus puertos abiertos.

      Abra digitalocean_firewall.tf:

      • nano digitalocean_firewall.tf

      Añada la siguiente configuración:

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

      En estas reglas se replica el estado del firewall de ejemplo existente. Si desea limitar el tráfico a diferentes direcciones IP, puertos o protocolos, puede ajustar el archivo para replicar su firewall existente.

      Una vez que haya actualizado sus archivos de Terraform, usará el comando plan para ver si en los cambios realizados se replica el estado de los activos existentes en DigitalOcean.

      El comando terraform plan se utiliza a modo de simulacro. Con este comando, puede verificar si los cambios que se realizarán en Terraform son los cambios que quiere hacer. Es recomendable ejecutar siempre este comando para confirmarlo antes de aplicar los cambios.

      Ejecute terraform plan con lo siguiente:

      • terraform plan -var "do_token=$DO_TOKEN"

      Verá un resultado similar al siguiente:

      Output

      No changes. Infrastructure is up-to-date.

      Importó de forma correcta los recursos de DigitalOcean existentes a Terraform y ahora podrá realizar cambios en su infraestructura mediante Terraform sin el riesgo de eliminar o modificar los recursos existentes.

      En este paso, agregará dos Droplets adicionales a su infraestructura existente. Añadir recursos de esta manera a su infraestructura existente puede ser útil, por ejemplo, si tiene un sitio web activo y no quiere realizar cambios que puedan ocasionar perjuicios en dicho sitio mientras realiza tareas en él. En su lugar, puede añadir un Droplet adicional para usarlo como entorno de desarrollo y trabajar en su proyecto en el mismo entorno que el Droplet de producción sin riesgos.

      Ahora, abra digitalocean_droplet.tf para añadir las reglas de sus nuevos Droplets:

      • nano digitalocean_droplet.tf

      Añada las siguientes líneas a su archivo:

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

      Utilizará el metargumento count para indicar a Terraform la cantidad de Droplets con las mismas especificaciones que desea. Estos nuevos Droplets también se agregarán a su firewall existente a medida que especifique la misma etiqueta que en su firewall.

      Aplique estas reglas para verificar los cambios que especifique en DigitalOcean_droplet.tf:

      • terraform plan -var "do_token=$DO_TOKEN"

      Verifique que los cambios que desea realizar se repliquen en el resultado de este comando.

      Visualizará un resultado similar al siguiente:

      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.

      Una vez que esté satisfecho con el resultado, utilice el comando terraform apply para aplicar los cambios que especificó al estado de la configuración:

      • terraform apply -var "do_token=$DO_TOKEN"

      Confirme los cambios ingresando yes en la línea de comandos. Cuando la ejecución sea exitosa, verá un resultado similar al siguiente:

      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.

      Visualizará dos nuevos Droplets en su panel web de DigitalOcean: Nuevos Droplets

      También los verá adjuntos a su firewall existente: Firewall existente

      Creó nuevos recursos con Terraform usando sus activos existentes. Para aprender a destruir estos recursos, opcionalmente puede completar el paso siguiente.

      Paso 5: Destruir activos importados y creados (opcional)

      En este paso, destruirá los activos que importó y creó ajustando la configuración.

      Comience abriendo digitalocean_droplet.tf:

      • nano digitalocean_droplet.tf

      En el archivo, fije count en 0 como se muestra a continuación:

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

      Guarde el archivo y ciérrelo.

      Abra su archivo de configuración de firewall para modificar count también:

      • nano digitalocean_firewall.tf

      Fije count en 0 como en la siguiente línea resaltada:

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

      Guarde el archivo y ciérrelo.

      Ahora, aplique esos cambios con el siguiente comando:

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

      Terraform le solicitará confirmar si desea destruir los Droplets y el firewall. Con esto se eliminarán todos los activos que importó y creó mediante Terraform. Por lo tanto, asegúrese de verificar que desee proceder antes de escribir yes.

      Verá un resultado similar a lo siguiente:

      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.

      Eliminó todos los activos administrados por Terraform. Este es un flujo de trabajo útil si ya no necesita un recurso o realiza una reducción.

      Conclusión

      A lo largo de este tutorial, instaló Terraform, importó los recursos existentes, creó recursos nuevos y, opcionalmente, los destruyó. Puede escalar este flujo de trabajo para un proyecto más grande, como la implementación de un clúster de Kubernetes listo para la producción. A través de Terraform, puede administrar los nodos, las entradas de DNS, los firewalls, el almacenamiento y otros recurss, además de usar el control de versiones para supervisar cambios y colaborar con un equipo.

      Para explorar más características de Terraform, lea la documentación pertinente. También puede leer contenido de Terraform de DigitalOcean para acceder a más tutoriales y preguntas y respuestas.



      Source link