Como Estruturar um Projeto Terraform

Introdução

A estruturação apropriada de projetos Terraform de acordo com os seus casos de uso e complexidade percebida é fundamental para garantir sua manutenibilidade e extensibilidade nas operações diárias. Uma abordagem sistemática para a organização adequada de arquivos de código é necessária para garantir que o projeto permaneça escalável durante a implantação e útil para você e sua equipe.

Neste tutorial, você vai aprender a estruturar projetos Terraform de acordo com seu propósito geral e complexidade. Em seguida, você vai criar um projeto com uma estrutura simples usando as funcionalidades mais comuns do Terraform: variáveis, locais, fontes de dados e fornecedores. No final, seu projeto vai implantar um servidor Ubuntu 20.04 (Droplet) no DigitalOcean, instalar um servidor web Apache e apontar seu domínio para o servidor web.

Pré-requisitos

• Um token de acesso pessoal do DigitalOcean, que você pode criar através do painel de controle do DigitalOcean. Você pode encontrar instruções no documento do produto do DigitalOcean, Como Criar um Token de Acesso Pessoal.

• Uma chave SSH sem senha adicionada à sua conta DigitalOceano, que você pode criar seguindo as instruções de Como Usar Chaves SSH com Dropletse DigitalOceano.

• Terraform instalado na máquina local. Para instruções de acordo com o sistema operativo, veja Step 1 do tutorial Como Usar Terraform com DigitalOceano.

• Python 3 instalado no seu computador local. Você pode concluir Step 1 de Como Instalar e Configurar um Ambiente de Programação Local para Python 3 para o seu Sistema Operacional.

• Um nome de domínio totalmente registrado adicionado à sua conta do DigitalOcean. Para instruções sobre como fazer isso, visite as documentações oficiais.

Compreensão da Estrutura de um Projeto Terraform

Neste seção, você aprenderá o que o Terraform considera um projeto, como organizar o código de infraestrutura e quando escolher uma determinada abordagem. Você também aprenderá sobre espaços de trabalho do Terraform, o que eles fazem e como o Terraform está armazenando estado.

Um recurso é uma entidade de um serviço na nuvem (como um Droplo DigitalOcean) declarada no código do Terraform que é criada de acordo com propriedades especificadas e inferidas. Múltiplos recursos formam infraestrutura com suas conexões mutuais. Vários recursos formam infraestrutura com suas conexões mutuais.

O Terraform usa uma linguagem de programação especializada para definir infraestrutura, chamada Linguagem de Configuração Hashicorp (HCL). O código HCL do Terraform é usualmente armazenado em arquivos com extensão tf. Um projeto do Terraform é qualquer diretório que contém arquivos tf e que foi inicializado usando o comando init, o qual estabelece cache de Terraform e estado local padrão.

O Terraform estado é o mecanismo por meio do qual ele mantém rastrego das instâncias realmente implantadas na nuvem. O estado é armazenado em repositórios (localmente no disco ou remotamente em um serviço de armazenamento de arquivos na nuvem ou software especializado de gerenciamento de estado). Você pode levar mais tempo lendo sobre diferentes repositórios no documentação do Terraform.

Projetos de espaços de trabalho permitem que você tenha múltiplas estratégias em uma mesma infraestrutura de segundo plano, associadas à mesma configuração. Isso permite que você deploy multiple instâncias distintas da mesma infraestrutura com o mesmo conjunto de configurações. Cada projeto começa com um espaço de trabalho chamado default. Este será usado se você não criar ou mudar para outro explicitamente.

Módulos em Terraform (semelhantes a bibliotecas em outras linguagens de programação) são containers de código parametrizados que envolvem declarações de recursos múltiplos. Eles permitem abstrair parte comum da sua infraestrutura e reusá-la mais tarde com entradas diferentes.

Um projeto Terraform também pode incluir arquivos de código externos para uso com entradas dinamicas, que podem interpretar a saída JSON de um comando de linha de comandos e oferecer-lhe para uso nas declarações de recursos. Neste tutorial, você faz isso com um script Python.

Após saber o que um projeto Terraform consiste, vamos revisitar duas abordagens gerais para estruturar o projeto Terraform.

Estrutura Simples

Uma estrutura simples é adequada a pequenos projetos e a projetos de teste, com poucos recursos de diferentes tipos e variáveis. Ela tem poucos arquivos de configuração, normalmente um por tipo de recurso (ou mais arquivos auxiliares juntos com o principal), e não tem módulos personalizados, pois a maioria dos recursos é única e não há o suficiente para se generalizar e reutilizar. Seguindo isso, a maioria do código está armazenado no mesmo diretório, lado a lado. Estes projetos frequentemente têm algumas variáveis (como uma chave API para acessar o cloud) e podem usar entradas de dados dinâmicos e outras funcionalidades de Terraform e HCL, embora não de forma destacada.

Como exemplo da estrutura de arquivo deste método, este é o aspecto final do projeto que você construirá neste tutorial:

.
└── tf/
    ├── versions.tf
    ├── variables.tf
    ├── provider.tf
    ├── droplets.tf
    ├── dns.tf
    ├── data-sources.tf
    └── external/
        └── name-generator.py

Como este projeto irá deploy um servidor web Apache Droplet e configurar registros de DNS, as definições de variáveis de projeto, o provedor Terraform DigitalOcean, o Droplet e os registros de DNS serão armazenadas em seus respectivos arquivos. As versões mínimas necessárias do Terraform e do provedor DigitalOcean serão especificadas em versions.tf, enquanto o script Python que gerará um nome para o Droplet (e será usado como fonte de dados dinâmico em data-sources.tf) será armazenado na pasta external, para separá-lo do código HCL.

Estrutura Complexa

Contrário à estrutura simples, este método é adequado a projetos grandes, com estruturas de subdiretórios claramente definidas que contêm múltiplos módulos de diferentes níveis de complexidade, além do código usual. Esses módulos podem dependê-se uns dos outros. Acompanhado de sistemas de controle de versão, esses projetos podem fazer uso extensivo de workspaces. Este método é adequado a projetos maiores que gerenciam várias aplicações, reutilizando o código tanto quanto possível.

Instâncias de infraestrutura de desenvolvimento, estação de atuação, avaliação de qualidade e produção também podem ser alojadas no mesmo projeto em diretórios diferentes, com base em módulos comuns, eliminando assim código duplicado e tornando o projeto a fonte central de verdade. Aqui está a estrutura de arquivo de um projeto de exemplo com uma estrutura mais complexa, contendo várias aplicações de implantação, módulos Terraform e ambientes de nuvem alvo:

.
└── tf/
    ├── modules/
    │   ├── network/
    │   │   ├── main.tf
    │   │   ├── dns.tf
    │   │   ├── outputs.tf
    │   │   └── variables.tf
    │   └── spaces/
    │       ├── main.tf
    │       ├── outputs.tf
    │       └── variables.tf
    └── applications/
        ├── backend-app/
        │   ├── env/
        │   │   ├── dev.tfvars
        │   │   ├── staging.tfvars
        │   │   ├── qa.tfvars
        │   │   └── production.tfvars
        │   └── main.tf
        └── frontend-app/
            ├── env/
            │   ├── dev.tfvars
            │   ├── staging.tfvars
            │   ├── qa.tfvars
            │   └── production.tfvars
            └── main.tf

Este método é explorado em detalhes na série Como Gerenciar Infraestrutura com Terraform.

Agora você sabe o que é um projeto Terraform, como melhor structurá-lo de acordo com a complexidade percebida e qual papel servem as workspaces Terraform. Nas próximas etapas, você criará um projeto com uma estrutura simples que provisionará um Droplet com um servidor web Apache instalado e registros de DNS configurados para seu domínio. Primeiro, inicializará seu projeto com o fornecedor DigitalOcean e variáveis, e então procederá a definir o Droplet, uma fonte de dados dinâmica para fornecer seu nome, e um registro de DNS para a implantação.

Passo 1 – Configurando o Seu Projeto Inicial

Nesta seção, você adicionará o fornecedor DigitalOcean Terraform ao seu projeto, define as variáveis de projeto e declara uma instância de fornecedor DigitalOcean, para que o Terraform consiga se conectar à sua conta.

Comece criando um diretório para o seu projeto Terraform com o seguinte comando:

mkdir ~/apache-droplet-terraform

Navegue até ele:

cd ~/apache-droplet-terraform

Como este projeto seguirá a abordagem de estrutura simples, você armazenará o código do fornecedor, variáveis, Droplet e registro DNS em arquivos separados, de acordo com a estrutura de arquivos do exemplo anterior. Primeiro, você precisará adicionar o fornecedor DigitalOcean Terraform ao seu projeto como um fornecedor necessário.

Crie um arquivo chamado versions.tf e abra-o para edição executando:

nano versions.tf

Adicione as seguintes linhas:

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

Neste bloco terraform, você lista os fornecedores necessários (DigitalOcean, versão 2.x). Quando terminar, salve e feche o arquivo.

Em seguida, defina as variáveis que seu projeto exporá no arquivo variables.tf, seguindo a abordagem de armazenar diferentes tipos de recursos em arquivos de código separados:

nano variables.tf

Adicione as seguintes variáveis:

variable "do_token" {}
variable "domain_name" {}

Salve e feche o arquivo.

A seguir, o valor da variável do_token será guardado em seu Token de Acesso Pessoal da DigitalOcean e domain_name especificará o nome do domínio desejado. O droplet deployado terá a chave SSH, identificada por um padrão de impressão digital, instalada automaticamente.

Agora, defina a instância do provedor DigitalOcean para este projeto. Você armazenará-la em um arquivo chamado provider.tf. Crie e abra-o para edição executando:

nano provider.tf

Adicione o provedor:

provider "digitalocean" {
  token = var.do_token
}

Salve e saia quando você estiver pronto. Voce definiu o provedor digitalocean, que corresponde ao provedor especificado anteriormente no provider.tf, e estabeleceu uma conexão com a instância do provedor usando um token de autenticação que será fornecido posteriormente.

Neste passo, você criou um diretório para seu projeto, solicitou que o provedor DigitalOcean fosse disponível, declarou variáveis do projeto, e configurou a conexão com uma instância do provedor DigitalOcean para usar um token de autenticação que será fornecido mais tarde. Agora, escreva um script em Python que genere dados dinamicos para as definições do seu projeto.

Passo 2 – Criando um Script Python para Dados Dinâmicos

Antes de seguir para a definição da Droplet, você criará um script em Python que gerará o nome da Droplet de forma dinâmica e declarará uma fonte de dados para a mesma. O nome será gerado pela concatenação de uma string constante (web) com o tempo atual da máquina local, expresso no formato UNIX epoch. Um script de nomeação pode ser útil quando são geradas múltiplas Droplet de acordo com um esquema de nomenclatura, para diferenciá-las facilmente.

Você armazenará o script em um arquivo chamado name-generator.py, dentro de um diretório chamado external. Primeiro, crie o diretório executando:

mkdir external

O diretório external fica no root do seu projeto e armazenará arquivos de código não-HCL, como o script Python que você vai escrever.

Crie name-generator.py dentro de external e abra-o para edição:

nano external/name-generator.py

Adicione o seguinte código:

import json, time

fixed_name = "web"
result = {
  "name": f"{fixed_name}-{int(time.time())}",
}

print(json.dumps(result))

Este script Python importa os módulos json e time, declara um dicionário chamado result e define o valor da chave name para uma string interpolada, que combina o fixed_name com o tempo UNIX atual da máquina em que está sendo executado. Em seguida, o result é convertido em JSON e enviado para stdout. A saída será diferente cada vez que o script for executado:

Output
{"name": "web-1597747959"}

Quando você estiver pronto, salve e fechar o arquivo.

Agora que o script está pronto, você pode definir a fonte de dados, que irá buscar dados do script. Você armazenará a fonte no arquivo chamado data-sources.tf na raiz do seu projeto de acordo com a abordagem de estruturamento simples.

Crie-lo para edição executando:

nano data-sources.tf

Adicione a seguinte definição:

data "external" "droplet_name" {
  program = ["python3", "${path.module}/external/name-generator.py"]
}

Salve e fecha o arquivo.

Esta fonte é chamada droplet_name e executa o script name-generator.py usando Python 3, que reside no diretório external que você acabou de criar. Ele automaticamente analisa sua saída e apresenta os dados deserializados sob seu atributo result.

Com a fonte agora declarada, você pode definir o Dropletto que o Apache irá rodar.

Passo 3 — Definindo o Pérola

Neste passo, você escreverá a definição da recurso de Pérola e armazenará-la em um arquivo de código dedicado às Pérolas, conforme a abordagem de estruturação simples. O nome desta pérola será diferente cada vez que seja deployada, derivando-se dos dados dinâmicos que você acabou de criar.

Crie e abra o arquivo droplets.tf para editar:

nano droplets.tf

Adicione a seguinte definição de recurso de Pérola:

data "digitalocean_ssh_key" "ssh_key" {
  name = "your_ssh_key_name"
}

resource "digitalocean_droplet" "web" {
  image  = "ubuntu-20-04-x64"
  name   = data.external.droplet_name.result.name
  region = "fra1"
  size   = "s-1vcpu-1gb"
  ssh_keys = [
    data.digitalocean_ssh_key.ssh_key.id
  ]
}

Você primeiro declara uma chave SSH do DigitalOcean chamada ssh_key, que irá buscar uma chave de sua conta. Certifique-se de substituir o código destacado com o nome da sua chave SSH.

Então, declara um recurso de Pérola chamado web. Seu nome real na nuvem será diferente, pois é solicitado a partir do droplet_name fonte de dados externa. Para inicializar a Pérola com uma chave SSH cada vez que seja deployada, o ID da ssh_key é passado para o parâmetro ssh_keys, assim o DigitalOcean saberá qual chave aplicar.

Por agora, isso é tudo que você precisa configurar relacionado ao droplet.tf, então salve e fecha o arquivo quando terminar.

Agora você escreverá a configuração para o registro DNS que apontará seu domínio para a pérola declarada recentemente.

Passo 4 — Definindo Registros DNS

O último passo no processo é configurar o registro de DNS que aponta para o Droplets da sua domínio.

Você armazenará a configuração do DNS em um arquivo chamado dns.tf, porque é um tipo de recurso diferente dos outros que você criou nas etapas anteriores. Crie e abra-o para editar:

nano dns.tf

Adicione as seguintes linhas:

resource "digitalocean_record" "www" {
  domain = var.domain_name
  type   = "A"
  name   = "@"
  value  = digitalocean_droplet.web.ipv4_address
}

Este código declara um registro DigitalOcean DNS na sua domínio (passada usando a variável), do tipo A. O registro tem um nome de @, que é um espécie de alias para o próprio domínio e com a adressa IP do Droplet como seu valor. Você pode substituir o valor de nome por algo outro, o que resultará em uma subdomínio sendo criado.

Quando você estiver terminado, salve e fecha o arquivo.

Agora que você configurou o Droplet, a fonte de dados do gerador de nomes e um registro DNS, vai prosseguir para a implantação do projeto na nuvem.

Passo 5 — Planejamento e Aplicação da Configuração

Neste seção, você inicializará seu projeto de terraform e o deployá-lo para a nuvem, verificando depois se tudo foi provisionado corretamente.

Agora que a infraestrutura do projeto está definida completamente, o último passo antes de deployar é inicializar o projeto Terraform. Faça isso executando o comando seguinte:

terraform init

Você receberá o seguinte output:

Output
Initializing the backend...

Initializing provider plugins...
- Finding digitalocean/digitalocean versions matching "~> 2.0"...
- Finding latest version of hashicorp/external...
- Installing digitalocean/digitalocean v2.10.1...
- Installed digitalocean/digitalocean v2.10.1 (signed by a HashiCorp partner, key ID F82037E524B9C0E8)
- Installing hashicorp/external v2.1.0...
- Installed hashicorp/external v2.1.0 (signed by HashiCorp)

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.

Você agora pode deployar seu Droplets com um nome dinâmico gerado e um domínio associado à sua conta DigitalOcean.

Comece definindo o nome do domínio, impressão digital da chave SSH e sua chave de acesso personalizada como variáveis de ambiente, assim não terá que copiar os valores cada vez que execute o Terraform. Executar os seguintes comandos, substituindo os valores destacados:

export DO_PAT="your_do_api_token"
export DO_DOMAIN_NAME="your_domain"

Você pode encontrar sua chave de acesso API na Painel de Controle da DigitalOcean.

Executar o comando plan com as variáveis passadas para ver quais etapas o Terraform iria tomar para deployar seu projeto:

terraform plan -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}"

O output será semelhante ao seguinte:

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.web será criado
  + resource "digitalocean_droplet" "web" {
      + 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                 = "web-1625908814"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = (known after apply)
      + region               = "fra1"
      + 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)
    }

  # digitalocean_record.www será criado
  + resource "digitalocean_record" "www" {
      + domain = "your_domain'"
      + fqdn   = (known after apply)
      + id     = (known after apply)
      + name   = "@"
      + ttl    = (known after apply)
      + type   = "A"
      + value  = (known after apply)
    }

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

As linhas começando com uma marca + significam que o Terraform irá criar cada recurso que veja em seguida após o que seja especificado, então você pode apply a configuração:

terraform apply -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}"

O output será o mesmo que antes, mas esta vez você será solicitado a confirmação:

Output
Plan: 2 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`

Digite yes, e o Terraform provisionará seu Droplet e o registro DNS:

Output
digitalocean_droplet.web: Creating...
...
digitalocean_droplet.web: Creation complete after 33s [id=204432105]
digitalocean_record.www: Creating...
digitalocean_record.www: Creation complete after 1s [id=110657456]

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

Terraform agora registrou as suas ressourcos implantadas no seu estado. Para confirmar que os registros de DNS e o Droplets se conectaram com sucesso, você pode extrair o endereço IP do Droplet da sua estado local e verificar se ele corresponde às recordes públicos de DNS para seu domínio. Executar o seguinte comando para obter o endereço IP do Droplet:

terraform show | grep "ipv4"

Você receberá o endereço IP do Droplet:

Output
ipv4_address       = "your_Droplet_IP"
...

Você pode checar os registros públicos A executando:

nslookup -type=a your_domain | grep "Address" | tail -1

A saída mostrará o endereço IP para o qual o registro A está apontando:

Output
Address: your_Droplet_IP

Eles são o mesmo, como devem ser, significando que o Droplet e o registro DNS foram provisionados com sucesso.

Para as alterações na próxima etapa serem aplicadas, destruir as recursos implantados executando:

terraform destroy -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}"

Quando solicitado, digite yes para continuar.

Neste passo, você criou sua infraestrutura e a aplicou à sua conta DigitalOcean. Agora você modificará-la para instalar o servidor Web Apache no Droplet provisionado usando provisioners do Terraform.

Passo 6 — Executando Código Usando Provisioners

Agora você configurará a instalação do servidor Apache no seu Droplet implantado usando o provisioner remote-exec para executar comandos personalizados.

Os provisioners do Terraform podem ser usados para executar ações específicas sobre recursos remotos criados (o provisionador remote-exec) ou na máquina local onde o código está sendo executado (usando o provisionador local-exec). Se um provisionador falhar, o nó será marcado como tainted no estado atual, o que significa que ele será excluído e recriado durante a próxima execução.

Para conectar-se à instância Droplet provisoriada, o Terraform precisa da chave privada SSH do Droplet configurado. A melhor maneira de passar o local da chave privada é usando variáveis, então abra variables.tf para editar:

nano variables.tf

Adicione a linha destacada:

variable "do_token" {}
variable "domain_name" {}
variable "private_key" {}

Você agora adicionou uma nova variável, chamada private_key , ao seu projeto. Salve e fechar o arquivo.

Agora, você adicionará os dados de conexão e declarações do provisionador remoto à configuração do Droplet. Abra droplets.tf para editar comando executando:

nano droplets.tf

Expanda o bloco existente com as linhas destacadas:

data "digitalocean_ssh_key" "ssh_key" {
  name = "your_ssh_key_name"
}

resource "digitalocean_droplet" "web" {
  image  = "ubuntu-20-04-x64"
  name   = data.external.droplet_name.result.name
  region = "fra1"
  size   = "s-1vcpu-1gb"
  ssh_keys = [
    data.digitalocean_ssh_key.ssh_key.id
  ]

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

  provisioner "remote-exec" {
    inline = [
      "export PATH=$PATH:/usr/bin",
      # Instalar Apache
      "apt update",
      "apt -y install apache2"
    ]
  }
}

O bloco connection especifica como o Terraform deve conectar-se ao alvo do Droplet. O bloco provisioner contém o array de comandos, dentro do parâmetro inline, que executará após a provisionação. Isso é, atualizando o cache do gerenciador de pacotes e instalando o Apache. Salve e sair quando terminar.

Você pode criar uma variável de ambiente temporária para o caminho da chave privada também:

export DO_PRIVATE_KEY="private_key_location"

Tente aplicar a configuração novamente:

terraform apply -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}" -var "private_key=${DO_PRIVATE_KEY}"

Digite yes quando solicitado. Você receberá saída semelhante à anterior, mas seguida por uma saída longa do provisor remote-exec.

Output
digitalocean_droplet.web: Creating...
digitalocean_droplet.web: Still creating... [10s elapsed]
digitalocean_droplet.web: Still creating... [20s elapsed]
digitalocean_droplet.web: Still creating... [30s elapsed]
digitalocean_droplet.web: Provisioning with 'remote-exec'...
digitalocean_droplet.web (remote-exec): Connecting to remote host via SSH...
digitalocean_droplet.web (remote-exec):   Host: ...
digitalocean_droplet.web (remote-exec):   User: root
digitalocean_droplet.web (remote-exec):   Password: false
digitalocean_droplet.web (remote-exec):   Private key: true
digitalocean_droplet.web (remote-exec):   Certificate: false
digitalocean_droplet.web (remote-exec):   SSH Agent: false
digitalocean_droplet.web (remote-exec):   Checking Host Key: false
digitalocean_droplet.web (remote-exec): Connected!
...
digitalocean_droplet.web: Creation complete after 1m5s [id=204442200]
digitalocean_record.www: Creating...
digitalocean_record.www: Creation complete after 1s [id=110666268]

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

Agora você pode navegar até sua domínio na web usando um navegador. Voulez-vous voir la page d’accueil par défaut Apache. Cela signifie que Apache a été installé avec succès et que Terraform a fourni tout correctement.

Vous pouvez maintenant naviguer vers votre domaine dans un navigateur Web. Vous verrez une page d’accueil par défaut Apache. Cela signifie que Apache a été installé avec succès et que Terraform a fourni tous les éléments correctement.

Pour détruire les ressources déployées, exécutez la commande suivante et entrez yes lorsque vous le soyez invité :

terraform destroy -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}" -var "private_key=${DO_PRIVATE_KEY}"

Vous avez maintenant terminé un petit projet Terraform avec une structure simple qui déploie le serveur Web Apache sur un Droplet et configure les enregistres DNS pour le domaine souhaité.

Conclusion

Você aprendeu sobre duas abordagens gerais para estruturar seus projetos Terraform, de acordo com sua complexidade. Seguindo a abordagem simples de estruturação e usando o provisionador remote-exec para executar comandos, você então implantou um Droplet executando o Apache com registros de DNS para seu domínio.

Para referência, aqui está a estrutura de arquivos do projeto que você criou neste tutorial:

.
└── tf/
    ├── versions.tf
    ├── variables.tf
    ├── provider.tf
    ├── droplets.tf
    ├── dns.tf
    ├── data-sources.tf
    └── external/
        └── name-generator.py

As recursos que você definiu (o Droplet, o registro de DNS e a fonte de dados dinâmica, o fornecedor DigitalOcean e as variáveis) são armazenados cada um em seu próprio arquivo separado, de acordo com a estrutura simples de projeto descrita na primeira seção deste tutorial.

Para obter mais informações sobre provisionadores Terraform e seus parâmetros, visite a documentação oficial.

Este tutorial é parte da série Como Gerenciar Infraestrutura com Terraform. A série abrange vários tópicos Terraform, desde instalar Terraform pela primeira vez até gerenciar projetos complexos.