Introdução
Imagine que você é um arquiteto projetando um bairro. Você não desenharia cada casa do zero, tijolo por tijolo. Em vez disso, criaria a planta de uma “Casa Padrão” e simplesmente copiaria essa planta 50 vezes.
No Terraform, essas plantas reutilizáveis são chamadas de módulos.
Os módulos são a principal forma de o Terraform evoluir de pequenos exemplos para bases de código de infraestrutura reais. Eles permitem que as equipes empacotem padrões uma vez e os reutilizem muitas vezes.
Em vez de repetir a mesma configuração várias vezes, você a escreve uma vez dentro de um módulo e a reutiliza. Os módulos são importantes porque as bases de código de infraestrutura reais crescem rapidamente e precisam de estrutura, assim como o código de aplicações.
Neste laboratório, você criará um módulo simples que gera arquivos de configuração de servidores e, em seguida, usará esse módulo para criar dois servidores diferentes.
Criar o diretório do módulo
Primeiro, precisamos de um local para armazenar nossas plantas. Os módulos do Terraform são apenas pastas comuns que contêm arquivos do Terraform.
Este é um detalhe importante: em termos de formato de arquivo, um módulo não é um novo recurso especial da linguagem. Ele é simplesmente uma configuração do Terraform empacotada por trás de uma interface reutilizável.
Por convenção, geralmente criamos uma pasta chamada modules para manter tudo organizado. Dentro dela, criaremos uma pasta para nosso módulo específico de “webserver”.
Configure essa estrutura:
cd ~/project
mkdir -p modules/webserver
Verifique o resultado:
ls -R
Você deverá ver um diretório modules contendo um diretório webserver. Essa pasta webserver funcionará como um miniprojeto independente.
Definir o módulo
Agora precisamos escrever a própria planta.
Um módulo funciona como um projeto raiz: ele tem um arquivo main.tf para definir recursos e um arquivo variables.tf para aceitar entradas.
Neste laboratório, usaremos um recurso simples chamado local_file. Ele apenas cria um arquivo de texto no disco. Isso é ideal para aprender sobre módulos, porque é rápido e não exige configurações complexas de nuvem.
Primeiro, crie o arquivo main.tf do módulo usando o nano:
nano modules/webserver/main.tf
Adicione este conteúdo. Ele instrui o Terraform a criar um arquivo com um texto específico dentro dele.
resource "local_file" "server_config" {
content = "Server Name: ${var.server_name}\nEnvironment: ${var.env}"
filename = "${path.root}/${var.server_name}-config.txt"
}
Salve e saia do nano (Ctrl+O, Enter, Ctrl+X).
Espere: var.server_name? Ainda não definimos isso! Um módulo precisa declarar quais entradas aceita, assim como uma função em uma linguagem de programação.
Essa analogia com funções é uma forma adequada de entender o conceito. Um módulo expõe entradas e saídas, enquanto oculta do chamador os detalhes de seus recursos internos.
Crie o arquivo variables.tf do módulo:
nano modules/webserver/variables.tf
Adicione estas definições de entrada:
variable "server_name" {
description = "The name of the server"
type = string
}
variable "env" {
description = "The environment (e.g., dev, prod)"
type = string
default = "dev"
}
Salve e saia do nano.
Agora nossa planta (o módulo) está completa. Ela sabe como criar um arquivo e sabe quais informações precisa — nome e ambiente — para executar essa tarefa.
Chamar o módulo
Agora vamos assumir o papel de gerente do site. Queremos criar um servidor, mas não queremos nos preocupar com os detalhes. Queremos apenas “contratar” o módulo para fazer isso.
Faremos isso criando um bloco module no arquivo main.tf raiz — o arquivo localizado em ~/project.
Crie o arquivo main.tf raiz:
cd ~/project
nano main.tf
Adicione este conteúdo para “chamar” o módulo:
module "my_first_server" {
source = "./modules/webserver"
server_name = "web-01"
env = "production"
}
Lembre-se de salvar e sair do nano.
Veja o significado de cada parte:
module "my_first_server": este é o nome desta instância específica.source: essencial! Ele informa ao Terraform onde encontrar a pasta da planta (./modules/webserver).server_nameeenv: são as entradas que estamos passando para o módulo.
Isso significa que uma chamada de módulo permite que a configuração raiz descreva a intenção em um nível mais alto. Em vez de redigitar cada recurso de baixo nível, você diz: “instancie este padrão reutilizável com estas entradas”.
IMPORTANTE: sempre que adicionar um novo módulo, você deverá informar ao Terraform que ele precisa ser preparado. Execute init para instalar o módulo:
terraform init
Agora aplique o projeto:
terraform apply -auto-approve
Verifique o resultado. Você deverá ver um novo arquivo criado pelo módulo:
cat web-01-config.txt
Sucesso! O módulo recebeu nossas entradas ("web-01" e "production") e executou o trabalho por nós.
Reutilizar o módulo
É aqui que a mágica acontece. Queremos um segundo servidor. Em vez de copiar todo o código do recurso, basta aplicar a planta mais uma vez.
Abra novamente o arquivo main.tf raiz usando o nano:
nano main.tf
Use as teclas de seta para ir até o final do arquivo e acrescente este bloco:
module "my_second_server" {
source = "./modules/webserver"
server_name = "web-02"
## We are not setting 'env' here, so it will use the default value "dev"
}
Salve e saia do nano.
Observe como isso é simples. Apenas dizemos: “quero outro servidor chamado web-02”. Não precisamos saber como o local_file funciona internamente. Basta usar a interface.
Aplique as alterações:
terraform init
terraform apply -auto-approve
Verifique se agora você tem dois arquivos de servidor separados:
ls -l *-config.txt
Depois, confirme que o segundo arquivo usou o ambiente padrão "dev":
cat web-02-config.txt
Você acabou de dominar o princípio básico da infraestrutura reutilizável!
Resumo
Parabéns! Você deu um grande passo em direção à escrita de código profissional com o Terraform.
Neste laboratório, você aprendeu:
- Módulos: como agrupar código em pastas reutilizáveis, suas “plantas”.
- Entradas: como usar variáveis para tornar os módulos flexíveis.
- Chamada de módulos: como usar o bloco
modulepara criar instâncias da sua planta. - Reutilização: como criar facilmente várias cópias da infraestrutura usando uma quantidade mínima de código.
Em vez de uma pilha desorganizada de tijolos, agora você tem um conjunto de componentes reutilizáveis. Isso ajuda a criar uma infraestrutura mais rápida, segura e organizada.
