Uma introdução ao Terraform para iniciantes – Tutorial do Terraform

Quer saber, o que é Terraform? Vamos descobrir sobre isso.

Infraestrutura como código (IaC) é uma terminologia difundida entre os profissionais de DevOps. É o processo de gerenciamento e provisionamento de toda a infraestrutura de TI (compreende máquinas físicas e virtuais) usando arquivos de definição legíveis por máquina. É uma abordagem de engenharia de software para operações. Ele ajuda a automatizar o data center completo usando scripts de programação.

Com todos os recursos que a Infraestrutura como Código oferece, ela tem vários desafios:

• Precisa aprender a codificar
• Não sei o impacto da mudança.
• Precisa reverter a alteração
• Não é possível acompanhar as alterações
• Não é possível automatizar um recurso
• Vários ambientes para infraestrutura

O Terraform foi criado para resolver esses desafios.

O que é Terraform?

Terraform é uma infraestrutura de código aberto como ferramenta de código desenvolvida pela HashiCorp. Ele é usado para definir e provisionar a infraestrutura completa usando uma linguagem declarativa fácil de aprender.

É uma ferramenta de provisionamento de infraestrutura onde você pode armazenar sua configuração de infraestrutura em nuvem como códigos. É muito semelhante a ferramentas como CloudFormation, que você usaria para automatizar sua infraestrutura da AWS, mas só pode usá-la na AWS. Com o Terraform, você também pode usá-lo em outras plataformas de nuvem.

Abaixo estão alguns dos benefícios de usar o Terraform.

• Faz orquestração, não apenas gerenciamento de configuração
• Suporta vários provedores, como AWS, Azure, GCP, DigitalOcean e muitos mais
• Forneça infraestrutura imutável onde a configuração muda sem problemas
• Usa linguagem fácil de entender, HCL (linguagem de configuração HashiCorp)
• Facilmente portátil para qualquer outro provedor
• Suporta arquitetura somente cliente, portanto, não há necessidade de gerenciamento de configuração adicional em um servidor

Conceitos do Terraform Core

Abaixo estão os principais conceitos/terminologias usados ​​no Terraform:

• Variáveis: Também usadas como variáveis ​​de entrada, é o par chave-valor usado pelos módulos do Terraform para permitir a customização.
• Provider: É um plugin para interagir com APIs de serviço e acessar seus recursos relacionados.
• Módulo: É uma pasta com templates do Terraform onde são definidas todas as configurações
• Estado: Consiste em informações armazenadas em cache sobre a infraestrutura gerenciada pelo Terraform e as configurações relacionadas.
• Recursos: Refere-se a um bloco de um ou mais objetos de infraestrutura (instâncias de computação, redes virtuais, etc.), que são usados ​​na configuração e gerenciamento da infraestrutura.
• Data Source: É implementado por provedores para retornar informações sobre objetos externos ao terraform.
• Valores de saída: são valores de retorno de um módulo terraform que podem ser usados ​​por outras configurações.
• Plano: É uma das etapas em que determina o que precisa ser criado, atualizado ou destruído para passar do estado real/atual da infraestrutura para o estado desejado.
• Aplicar: É uma das etapas em que se aplica as alterações do estado real/atual da infraestrutura para passar ao estado desejado.

Ciclo de vida do Terraform

O ciclo de vida do Terraform consiste em – iniciar, planejar, aplicar e destruir.

• O init do Terraform inicializa o diretório de trabalho que consiste em todos os arquivos de configuração
• O plano Terraform é usado para criar um plano de execução para alcançar um estado desejado da infraestrutura. As alterações nos arquivos de configuração são feitas para atingir o estado desejado.
• O Terraform apply então faz as alterações na infraestrutura conforme definido no plano, e a infraestrutura chega ao estado desejado.
• O Terraform destroy é usado para excluir todos os recursos de infraestrutura antigos, que são marcados como corrompidos após a fase de aplicação.

Como funciona o Terraform?

O Terraform possui dois componentes principais que compõem sua arquitetura:

Núcleo Terraform

O núcleo do Terraform usa duas fontes de entrada para fazer seu trabalho.

A primeira fonte de entrada é uma configuração do Terraform que você, como usuário, configura. Aqui, você define o que precisa ser criado ou provisionado. E a segunda fonte de entrada é um estado em que o terraform mantém o estado atualizado de como é a configuração atual da infraestrutura.

Então, o que o Terraform Core faz é pegar a entrada e descobrir o plano do que precisa ser feito. Ele compara o estado, qual é o estado atual e qual é a configuração que você deseja no resultado final. Ele descobre o que precisa ser feito para chegar ao estado desejado no arquivo de configuração. Ele calcula o que precisa ser criado, o que precisa ser atualizado, o que precisa ser excluído para criar e provisionar a infraestrutura.

Provedores

O segundo componente da arquitetura são os provedores de tecnologias específicas. Podem ser provedores de nuvem como AWS, Azure, GCP ou outra plataforma de infraestrutura como serviço. Também é um fornecedor de componentes de mais alto nível, como Kubernetes ou outras ferramentas de plataforma como serviço, até mesmo alguns softwares como ferramenta de autoatendimento.

Dá-lhe a possibilidade de criar infraestruturas em diferentes níveis.

Por exemplo, crie uma infraestrutura da AWS, implante o Kubernetes sobre ela e crie serviços/componentes dentro desse cluster do Kubernetes.

O Terraform tem mais de uma centena de provedores para diferentes tecnologias, e cada provedor dá ao usuário do terraform acesso aos seus recursos. Assim, por meio do provedor da AWS, por exemplo, você tem acesso a centenas de recursos da AWS, como instâncias do EC2, usuários da AWS, etc. Com o provedor do Kubernetes, você acessa commodities, recursos como serviços e implantações e namespaces, etc.

Portanto, é assim que o Terraform funciona e, dessa forma, tenta ajudá-lo a provisionar e cobrir toda a configuração do aplicativo, desde a infraestrutura até o aplicativo.

Vamos fazer algumas coisas práticas. 👨‍💻

Vamos instalar o Terraform no Ubuntu e fornecer uma infraestrutura muito básica.

Instalar o Terraform

Baixe o pacote terraform mais recente.

Consulte o página oficial de download para obter a versão mais recente para o respectivo sistema operacional.

[email protected]:~$ wget https://releases.hashicorp.com/terraform/0.13.0/terraform_0.13.0_linux_amd64.zip
--2020-08-14 16:55:38--
https://releases.hashicorp.com/terraform/0.13.0/terraform_0.13.0_linux_amd64.zip
Resolving releases.hashicorp.com (releases.hashicorp.com)... 151.101.153.183, 2a04:4e42:24::439
Connecting to releases.hashicorp.com (releases.hashicorp.com)|151.101.153.183|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 34851622 (33M) [application/zip]
Saving to: ‘terraform_0.13.0_linux_amd64.zip’

terraform_0.13.0_linux_amd64.zip
100%[=================================================================>] 33.24M
90.3KB/s in 5m 28s

2020-08-14 17:01:06 (104 KB/s) - ‘terraform_0.13.0_linux_amd64.zip’ saved [34851622/34851622]

Extraia o pacote baixado.

[email protected]:~$ unzip terraform_0.13.0_linux_amd64.zip
Archive:
terraform_0.13.0_linux_amd64.zip
inflating: terraform

Mova o arquivo executável do terraform para o caminho mostrado abaixo. Verifique a versão terraform.

[email protected]:~$ sudo mv terraform /usr/local/bin/
[sudo] password for etechpt.com:
[email protected]:~$ terraform -v
Terraform v0.13.0

Você pode ver que esses são os comandos disponíveis no terraform para execução.

[email protected]:~$ terraform
Usage: terraform [-version] [-help] <command> [args]

The available commands for execution are listed below.
The most common, useful commands are shown first, followed by
less common or more advanced commands. If you're just getting
started with Terraform, stick with the common commands. For the
other commands, please read the help and docs before usage.

Common commands:
apply Builds or changes infrastructure
console Interactive console for Terraform interpolations
destroy Destroy Terraform-managed infrastructure
env Workspace management
fmt Rewrites config files to canonical format
get Download and install modules for the configuration
graph Create a visual graph of Terraform resources
import Import existing infrastructure into Terraform
init Initialize a Terraform working directory
login Obtain and save credentials for a remote host
logout Remove locally-stored credentials for a remote host
output Read an output from a state file
plan Generate and show an execution plan
providers Prints a tree of the providers used in the configuration
refresh Update local state file against real resources
show Inspect Terraform state or plan
taint Manually mark a resource for recreation
untaint Manually unmark a resource as tainted
validate Validates the Terraform files
version Prints the Terraform version
workspace Workspace management

All other commands:
0.12upgrade Rewrites pre-0.12 module source code for v0.12
0.13upgrade Rewrites pre-0.13 module source code for v0.13
debug Debug output management (experimental)
force-unlock Manually unlock the terraform state
push Obsolete command for Terraform Enterprise legacy (v1)
state Advanced state management

Provisionar a instância do AWS EC2 usando o Terraform

Nesta demonstração, lançarei uma nova instância do AWS EC2 usando o Terraform.

Crie um diretório de trabalho para esta demonstração do Terraform.

[email protected]:~$ mkdir terraform_demo

Acesse o diretório e crie um arquivo de configuração do terraform onde você define o provedor e os recursos para executar uma instância do AWS EC2.

[email protected]:~$ cd terraform_demo/
[email protected]:~/terraform_demo$ gedit awsec2.tf

provider "aws" {
access_key = "B5KG6Fe5GUKIATUF5UD"
secret_key = "R4gb65y56GBF6765ejYSJA4YtaZ+T6GY7H"
region = "us-west-2"
}

resource "aws_instance" "terraform_demo" {
ami = "ami-0a634ae95e11c6f91"
instance_type = "t2.micro"
}

Nota: alterei as chaves de acesso e secretas 😛, você precisa usar as suas próprias.

A partir da configuração mencionada acima, você pode ver que estou mencionando o provedor como AWS. Dentro do provedor, estou fornecendo credenciais de usuário da AWS e regiões onde a instância deve ser executada.

Em recursos, estou dando detalhes da AMI do Ubuntu (ami-0a634ae95e11c6f91) e mencionando que o tipo de instância deve ser t2.micro

Você pode ver o quão fácil e legível é o arquivo de configuração, mesmo se você não for um codificador obstinado.

inicialização do terraform

Agora, o primeiro passo é inicializar o terraform.

[email protected]:~/terraform_demo$ terraform init

Initializing the backend...

Initializing provider plugins...
- Using previously-installed hashicorp/aws v3.2.0

The following providers do not have any version constraints in configuration,
so the latest version was installed.

To prevent automatic upgrades to new major versions that may contain breaking
changes, we recommend adding version constraints in a required_providers block
in your configuration, with the constraint strings suggested below.

* hashicorp/aws: version = "~> 3.2.0"

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.

plano de terraformação

Em seguida é o estágio do plano; ele criará o gráfico de execução para criar e provisionar a infraestrutura.

[email protected]:~/terraform_demo$ terraform plan
Refreshing Terraform state in-memory prior to plan...
The refreshed state will be used to calculate this plan, but will not be
persisted to local or remote state storage.

------------------------------------------------------------------------

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
+ create

Terraform will perform the following actions:

# aws_instance.terraform_demo will be created
+ resource "aws_instance" "terraform_demo" {
+ ami = "ami-0a634ae95e11c6f91"
+ arn = (known after apply)
+ associate_public_ip_address = (known after apply)
+ availability_zone = (known after apply)
+ cpu_core_count = (known after apply)
+ cpu_threads_per_core = (known after apply)
+ get_password_data = false
+ host_id = (known after apply)
+ id = (known after apply)
+ instance_state = (known after apply)
+ instance_type = "t2.micro"
+ ipv6_address_count = (known after apply)
+ ipv6_addresses = (known after apply)
+ key_name = (known after apply)
+ outpost_arn = (known after apply)
+ password_data = (known after apply)
+ placement_group = (known after apply)
+ primary_network_interface_id = (known after apply)
+ private_dns = (known after apply)
+ private_ip = (known after apply)
+ public_dns = (known after apply)
+ public_ip = (known after apply)
+ secondary_private_ips = (known after apply)
+ security_groups = (known after apply)
+ source_dest_check = true
+ subnet_id = (known after apply)
+ tenancy = (known after apply)
+ volume_tags = (known after apply)
+ vpc_security_group_ids = (known after apply)

+ ebs_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ snapshot_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}

+ ephemeral_block_device {
+ device_name = (known after apply)
+ no_device = (known after apply)
+ virtual_name = (known after apply)
}

+ metadata_options {
+ http_endpoint = (known after apply)
+ http_put_response_hop_limit = (known after apply)
+ http_tokens = (known after apply)
}

+ network_interface {
+ delete_on_termination = (known after apply)
+ device_index = (known after apply)
+ network_interface_id = (known after apply)
}

+ root_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}
}

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

------------------------------------------------------------------------

Note: You didn't specify an "-out" parameter to save this plan, so Terraform
can't guarantee that exactly these actions will be performed if
"terraform apply" is subsequently run.

aplicar terraform

O estágio apply executará o arquivo de configuração e iniciará uma instância AWS EC2. Quando você executar o comando apply, ele perguntará: “Você deseja executar essas ações?”, você precisa digitar sim e pressionar enter.

[email protected]:~/terraform_demo$ terraform apply

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
+ create

Terraform will perform the following actions:

# aws_instance.terraform_demo will be created
+ resource "aws_instance" "terraform_demo" {
+ ami = "ami-0a634ae95e11c6f91"
+ arn = (known after apply)
+ associate_public_ip_address = (known after apply)
+ availability_zone = (known after apply)
+ cpu_core_count = (known after apply)
+ cpu_threads_per_core = (known after apply)
+ get_password_data = false
+ host_id = (known after apply)
+ id = (known after apply)
+ instance_state = (known after apply)
+ instance_type = "t2.micro"
+ ipv6_address_count = (known after apply)
+ ipv6_addresses = (known after apply)
+ key_name = (known after apply)
+ outpost_arn = (known after apply)
+ password_data = (known after apply)
+ placement_group = (known after apply)
+ primary_network_interface_id = (known after apply)
+ private_dns = (known after apply)
+ private_ip = (known after apply)
+ public_dns = (known after apply)
+ public_ip = (known after apply)
+ secondary_private_ips = (known after apply)
+ security_groups = (known after apply)
+ source_dest_check = true
+ subnet_id = (known after apply)
+ tenancy = (known after apply)
+ volume_tags = (known after apply)
+ vpc_security_group_ids = (known after apply)

+ ebs_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ snapshot_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}

+ ephemeral_block_device {
+ device_name = (known after apply)
+ no_device = (known after apply)
+ virtual_name = (known after apply)
}

+ metadata_options {
+ http_endpoint = (known after apply)
+ http_put_response_hop_limit = (known after apply)
+ http_tokens = (known after apply)
}

+ network_interface {
+ delete_on_termination = (known after apply)
+ device_index = (known after apply)
+ network_interface_id = (known after apply)
}

+ root_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}
}

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

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

Enter a value: yes

aws_instance.terraform_demo: Creating...
aws_instance.terraform_demo: Still creating... [10s elapsed]
aws_instance.terraform_demo: Still creating... [20s elapsed]
aws_instance.terraform_demo: Still creating... [30s elapsed]
aws_instance.terraform_demo: Still creating... [40s elapsed]
aws_instance.terraform_demo: Creation complete after 44s [id=i-0eec33286ea4b0740]

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

Vá para o painel do AWS EC2 e você verá uma nova instância com o id de instância mencionado no final do comando apply que foi criado.

Você executou com êxito uma instância do AWS EC2 usando o Terraform.

terraform destruir

Por fim, se você quiser excluir a infraestrutura, precisará executar o comando destroy.

[email protected]:~/terraform_demo$ terraform destroy
aws_instance.terraform_demo: Refreshing state... [id=i-0eec33286ea4b0740]

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
- destroy

Terraform will perform the following actions:

# aws_instance.terraform_demo will be destroyed
- resource "aws_instance" "terraform_demo" {
- ami = "ami-0a634ae95e11c6f91" -> null
- arn = "arn:aws:ec2:us-west-2:259212389929:instance/i-0eec33286ea4b0740" -> null
- associate_public_ip_address = true -> null
- availability_zone = "us-west-2c" -> null
- cpu_core_count = 1 -> null
- cpu_threads_per_core = 1 -> null
- disable_api_termination = false -> null
- ebs_optimized = false -> null
- get_password_data = false -> null
- hibernation = false -> null
- id = "i-0eec33286ea4b0740" -> null
- instance_state = "running" -> null
- instance_type = "t2.micro" -> null
- ipv6_address_count = 0 -> null
- ipv6_addresses = [] -> null
- monitoring = false -> null
- primary_network_interface_id = "eni-02a46f2802fd15634" -> null
- private_dns = "ip-172-31-13-160.us-west-2.compute.internal" -> null
- private_ip = "172.31.13.160" -> null
- public_dns = "ec2-34-221-77-94.us-west-2.compute.amazonaws.com" -> null
- public_ip = "34.221.77.94" -> null
- secondary_private_ips = [] -> null
- security_groups = [
- "default",
] -> null
- source_dest_check = true -> null
- subnet_id = "subnet-5551200c" -> null
- tags = {} -> null
- tenancy = "default" -> null
- volume_tags = {} -> null
- vpc_security_group_ids = [
- "sg-b5b480d1",
] -> null

- credit_specification {
- cpu_credits = "standard" -> null
}

- metadata_options {
- http_endpoint = "enabled" -> null
- http_put_response_hop_limit = 1 -> null
- http_tokens = "optional" -> null
}

- root_block_device {
- delete_on_termination = true -> null
- device_name = "/dev/sda1" -> null
- encrypted = false -> null
- iops = 100 -> null
- volume_id = "vol-0be2673afff6b1a86" -> null
- volume_size = 8 -> null
- volume_type = "gp2" -> null
}
}

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

Do you really want to destroy all resources?
Terraform will destroy all your managed infrastructure, as shown above.
There is no undo. Only 'yes' will be accepted to confirm.

Enter a value: yes

aws_instance.terraform_demo: Destroying... [id=i-0eec33286ea4b0740]
aws_instance.terraform_demo: Still destroying... [id=i-0eec33286ea4b0740, 10s elapsed]
aws_instance.terraform_demo: Still destroying... [id=i-0eec33286ea4b0740, 20s elapsed]
aws_instance.terraform_demo: Still destroying... [id=i-0eec33286ea4b0740, 30s elapsed]
aws_instance.terraform_demo: Destruction complete after 34s

Destroy complete! Resources: 1 destroyed.

Se você verificar novamente o painel do EC2, verá que a instância foi encerrada.

Conclusão

Eu acredito que o acima lhe dá uma ideia para começar com o Terraform. Vá em frente e experimente o exemplo que acabei de mostrar.

Você também deve verificar esses softwares de automação de infraestrutura.

Se você estiver interessado em aprender mais, sugiro verificar Curso Aprendendo DevOps com Terraform.