Primeiras aulas do curso
Bem-vindos ao curso de Fundamentos de Terraform. Hoje, além de conhecermos esta ferramenta, vamos praticar. Esta é uma introdução simples sobre o que é infraestrutura como código e o que seria o Terraform, conhecido por ser uma ferramenta de infraestrutura como código. Esta ferramenta foi criada pela HashiCorp e é utilizada para provisionar e gerenciar infraestrutura na nuvem, não apenas na nuvem, mas também em instalações locais (on-premises) e SaaS. On-premises refere-se às instalações locais. O Terraform utiliza uma sintaxe declarativa, e esse será o conceito encontrado na internet sobre esta ferramenta. No entanto, hoje, enquanto praticamos, vamos assimilar esse conceito, sempre com um cenário da vida real para facilitar a compreensão.
Considerando que é uma ferramenta que trabalha com infraestrutura na nuvem, vamos entender primeiro o que é a nuvem. A nuvem refere-se a provedores que disponibilizam serviços e infraestrutura na Internet. O uso dessas plataformas é sob demanda, ou seja, levantamos o recurso que precisamos, utilizamos e, em seguida, destruímos ou mantemos no cenário, dependendo da nossa necessidade. São serviços de fácil manejo, entre aspas, precisamente porque são escaláveis e flexíveis, características que também encontramos sobre a nuvem se pesquisarmos na internet.
O que queremos dizer com escalável e flexível? Criamos e adaptamos o cenário conforme nossa necessidade, exatamente o que precisamos, e como é algo que podemos manipular o tempo todo, sempre ajustando ao cenário atual que está mudando, é uma ferramenta pela qual pagamos conforme o uso. Este é um detalhe extremamente importante. Se nunca tivemos contato com algum provedor de nuvem, como AWS, Azure, Google Cloud, entre outros, devemos ter esse ponto em atenção. Levantamos um serviço, utilizamos, destruímos ou mantemos, e a fatura chega ao final.
Neste curso, precisaremos ter uma conta na AWS para levantar alguns recursos, fazer algumas provas e realmente ter uma experiência com um cenário real. No entanto, o que vamos fazer, os recursos que vamos criar, as configurações que faremos dentro do Terraform para o provedor, são relativamente simples. Assim, gerarão movimento na conta, mas a AWS permite ter uma conta gratuita, e durante esse período de uso há um limite que não é cobrado. Portanto, este curso não criará uma conta paga automaticamente. Contudo, atenção: se em algum momento nos entusiasmarmos e fizermos outras provas, levantarmos mais de um recurso, melhorarmos o cenário, ou formos para um projeto mais real, devemos ter em mente que seremos cobrados por isso.
Sem mais delongas, vamos falar de fato sobre Terraform e IAC. Antes disso, vamos mostrar na tela quatro pontos principais que acabamos de comentar sobre a nuvem: é uma infraestrutura disponível via Internet, os recursos são sob demanda, que criamos, usamos, destruímos ou mantemos, a fatura chega ao final conforme o uso, é considerada escalável e flexível, e o pagamento é conforme o uso.
Agora, oficialmente, falando de IAC e Terraform, o que seria IAC e Terraform? No início, comentamos como um resumo que, se pesquisarmos na internet, o que significa Terraform, o que é infraestrutura como código, Terraform é uma ferramenta de infraestrutura como código que usa uma sintaxe declarativa, e infraestrutura como código não é mais do que a sigla IAC. O uso do Terraform traz muitas vantagens no âmbito de DevOps, eliminando os processos manuais que são realizados dentro do provedor. Assim, a ideia de abrir o provedor, fazer login, abrir o console, buscar o serviço e fazer a criação manual, com a ferramenta, essa parte fica completamente eliminada, não precisamos de todo esse trabalho.
Considerando que reduzimos todas as vezes que precisamos fazer esse processo de login na plataforma, buscar no console o que precisamos, ver o padrão de criação do zero, ao reduzir esse trabalho, o Terraform também reduz os erros e aumenta a eficiência do que nós ou nossa equipe fazemos. O Terraform não é apenas uma ferramenta que faz o provisionamento no provedor, é uma ferramenta que nos traz muitos outros benefícios, especialmente quando trabalhamos em equipe, e mais adiante entenderemos melhor por que é tão importante no contexto de DevOps.
Voltando um pouco ao Terraform, para não nos desviarmos muito do escopo no início da aula, ele traz consistência, é a oportunidade de recriar o mesmo ambiente repetidamente. Imaginemos o cenário real sem o Terraform: precisamos criar uma EC2, por exemplo, vamos ao provedor, fazemos login, buscamos no console e começamos a criação. No dia seguinte, precisamos de outra EC2, voltamos, fazemos login, entramos no console e configuramos do zero. Com o Terraform, podemos gerenciar isso de forma, entre aspas, automática. Digo "automática" para que entendamos que esse trabalho repetitivo não é necessário. Por quê? O Terraform trabalha com módulos; uma vez que criamos esses módulos, podemos reutilizá-los sem necessidade de começar do zero, já temos essa ferramenta pronta para aplicar e replicar quantas vezes quisermos. E, claro, mantém o padrão, porque uma vez que está guardado nesse formato, nós ou qualquer outro usuário poderá replicá-lo exatamente como deve ser.
E o melhor, um ponto muito importante, o Terraform é uma ferramenta multi-cloud, trabalha não apenas com um provedor, mas com vários ao mesmo tempo. Por exemplo, imaginemos que queremos trabalhar com Azure e com AWS, com pequenas configurações já podemos gerenciar recursos em ambos os provedores de forma automática. Assim, eliminamos o trabalho de fazer login em dois provedores, buscar em dois consoles, buscar dois serviços de forma completamente distinta, podemos configurar dentro do Terraform para que esse trabalho seja feito em dois ou três provedores. É multi-cloud, permitindo a gestão de recursos em diferentes nuvens, como AWS e Azure ao mesmo tempo.
Podemos armazenar tudo o que fazemos no Git. Dessa forma, conseguimos acompanhar todo o histórico, reverter alterações realizadas e colaborar com nossa equipe, pois é uma ferramenta que proporciona segurança para o trabalho em equipe, o que é conhecido como versionamento. Tudo o que fazemos com Terraform pode ser enviado e armazenado no Git para garantir essa segurança e também o gerenciamento por parte da equipe, mantendo sempre uma padronização e uma estrutura segura. Isso ocorre porque todos verão o mesmo cenário, o que reduz significativamente os erros de uso, já que todos acabam falando a mesma linguagem e vendo o mesmo código. Assim, temos o famoso versionamento.
Além disso, mencionamos a importância de manter uma padronização, mas há um ponto interessante que devemos ter em mente: realmente proporciona padronização, segurança e governança. Isso é perceptível no dia a dia, no uso, pois é uma ferramenta que, honestamente, não encontramos outra definição: sempre devemos imaginar que, ao usar Terraform, estamos utilizando uma ferramenta que entrega um cenário exatamente igual para todos os colaboradores, seja em casa ou a 200 quilômetros de distância, permitindo que trabalhemos vendo a mesma tela e a mesma linguagem de forma segura. O Terraform também possui um recurso chamado state (estado), que conheceremos em algumas apresentações futuras. Esse state armazena as configurações e faz uma comparação entre o que estamos deixando no provedor de nuvem e o que já existe, identificando o que deve ser destruído e o que deve ser criado. Assim, se executarmos um comando aqui e outro em outro lugar, evitamos duplicidade. Além disso, o Terraform possui uma função que bloqueia conflitos, impedindo que várias pessoas causem problemas ao subir informações que possam comprometer o trabalho. Por isso, o Terraform oferece segurança.
Na próxima apresentação, colocaremos informações sobre a ferramenta e seus benefícios, para que possam ser copiadas ou anotadas. Eu, Carol, prefiro explicar, pois é mais fácil de compreender do que ler fragmentos que, teoricamente, parecem prontos; talvez ouvindo seja mais fácil assimilar. Como mencionamos, o Terraform é uma ferramenta de infraestrutura como código criada pela RESTCorp, utilizada para provisionar e gerenciar infraestruturas na nuvem. Entre os benefícios já mencionados, estão a automação, repetibilidade, consistência, trabalho com módulos, suporte a múltiplas nuvens, versionamento no Git e modularização para reutilizar algo já escrito. Este é um pequeno resumo para anotação, e continuaremos com as explicações.
Por exemplo, no Terraform, escrevemos um trecho de algumas linhas, que veremos na próxima apresentação para ter uma ideia de como funciona antes de praticar. Basicamente, escrevemos um trecho, executamos o que foi escrito, e isso se transforma em infraestrutura, sendo implantado no provedor. Claro que não é tão simples como dizer: "Terraform, quero um load balancer, crie-o na AWS". Existe um formato específico de escrita, e a documentação oficial é fácil de entender. No início, pode parecer estranho, mas com o tempo nos acostumamos a ver esse cenário e percebemos que não é complicado nem um bicho de sete cabeças, é questão de prática.
Na próxima apresentação, serão mostradas sete linhas de um código real. Coloquei "Curso Gonçalves" porque, ao criar um bucket na AWS, o nome deve ser único globalmente. Basicamente, temos o provider (provedor), que é a conexão com o provedor de nuvem, no caso, a AWS. Na segunda linha, declaramos a região onde queremos que os serviços existam. A partir da linha cinco, já estamos criando nosso recurso, indicando que precisamos de um bucket S3. O nome interno no sistema foi deixado como first_bucket, e na linha seis fazemos a declaração do serviço com o nome único que será registrado no provedor. Com essas poucas linhas, já podemos realizar um trabalho que, de outra forma, nos obrigaria a acessar a console, buscar serviços e configurar individualmente. Todos os recursos criados a partir daí estarão associados à AWS e à região indicada, o que representa uma grande otimização de tempo.
Para ilustrar isso, vamos ver como esse código é estruturado:
provider "aws" {
region = "sa-east-1"
}
Aqui, estamos definindo o provedor como AWS e especificando a região onde queremos que nossos serviços sejam criados. Isso estabelece a conexão inicial com a AWS.
Continuando, vamos criar um recurso S3:
resource "aws_s3_bucket" "primeiro_bucket" {
bucket = "primeiro-bucket-curso-goncales"
}
Neste trecho, estamos criando um bucket S3 na AWS. O nome do bucket é único globalmente, e aqui usamos "primeiro-bucket-curso-goncales" para garantir essa unicidade.
Não se preocupem em entender cada fragmento agora, pois neste curso abordaremos em blocos, linha por linha, o que significa. Neste momento, foquem apenas em entender o que foi feito, como foi feito e como funciona. Essa facilidade, que é a opção de criação de recursos, conexão com provedores, criação de módulos e workspaces, faz parte de uma arquitetura. Tudo o que fazemos aqui faz parte de uma arquitetura, e é importante destacar isso. O Terraform pode parecer um pouco confuso, mas confiamos que, mais adiante, tudo ficará claro.
O Terraform não cria a arquitetura, ele a materializa. Ou seja, pedimos que ele defina a arquitetura necessária no código, seja uma VPC, uma subnet, um security group, EC2, um bucket S3, entre outros, e ele construirá exatamente isso, sem inventar algo. Ele seguirá o que pedimos e o que entendemos por arquitetura no mundo real. Imagine como o plano de uma casa: tem medidas, paredes, os cômodos que serão criados, todos os detalhes. Aqui, basicamente, é um desenho de como o sistema se conectará, qual é a melhor forma de gerar segurança, valor, escalabilidade e eficiência no cenário tecnológico.
Em resumo, o Terraform é uma ferramenta que faz essa conexão, essa ponte para criar recursos de toda a infraestrutura na nuvem por meio de algumas linhas que usam uma sintaxe declarativa. Na próxima aula, faremos a instalação do Terraform e todas as configurações necessárias para criar nosso primeiro projeto.
Agora, vamos continuar com a instalação do Terraform e criar nosso primeiro projeto. Diferente da aula anterior, não há slides explicativos ou descritivos para anotarmos. Esta etapa será mais prática, para que possamos seguir com as instalações de acordo com nosso sistema operacional e aprender alguns comandos do Terraform.
Na apresentação, há um link útil para quem prefere visualizá-lo, mas se buscarmos no Google "install Terraform" ou "instalação VS Code", chegaremos ao mesmo link que está sendo utilizado. O link aparece com VS Code porque é o que será usado durante este projeto, então recomendamos seguir o mesmo modelo. Se não quisermos, não há problema. O segundo link, que é a instalação do Chocolatey para Windows, está dentro da documentação do Terraform, então não precisamos nos preocupar em perder esses links.
Antes de começar, vale a pena dar uma olhada para termos uma ideia dos comandos que vamos aplicar e replicar ao longo deste curso. Não precisamos nos preocupar em memorizar o que significam, pois os utilizaremos tanto que acabaremos memorizando-os naturalmente. Estes são os quatro primeiros comandos que temos dentro do Terraform.
O comando init inicializa o projeto, baixa os providers (provedores), configura o back-end caso exista, e prepara uma pasta chamada .terraform. Esse é o primeiro comando que utilizamos para inicializar o projeto.
O comando plan mostra exatamente o que será feito: compara o código .tf com o estado atual. Ele indicará a quantidade de itens que serão criados, modificados ou destruídos. A quantidade de recursos que serão criados, alterados ou destruídos. Não executa nada, apenas mostra na tela quais modificações fizemos, quais adições, exclusões ou atualizações estamos indicando dentro desse código.
apply e destroyO terceiro comando é apply: cria, modifica e elimina os recursos. Ele tem uma diferença em relação ao plan, que muitas pessoas confundem. O plan apenas mostra na tela o que será adicionado, alterado ou destruído. O apply também mostrará o mesmo resumo na tela, mas pedirá uma confirmação: realmente vamos aplicar o que está sendo mostrado. Se fizermos uma adição, por exemplo, e quisermos criar um novo recurso, aparecerá a informação de uma adição, zero atualizações, zero destruições. Queremos realmente fazer essa adição? Se respondermos sim, o recurso será adicionado ao nosso provedor de cloud. Essa informação de que permitimos destruir, atualizar ou criar fica atualizada no arquivo terraform.tfstate, que é um dos dois "segredos" do Terraform que comentamos; é onde toda a informação fica registrada e armazenada, para sempre termos um mapeamento. A informação fica registrada e, a partir daí, sabe-se o que já existe no provedor, o que precisa ser criado, destruído ou adicionado, ou seja, é realmente um registro da configuração do nosso código. Assim, uma vez que dizemos sim no apply, não apenas mostra como o plan, mas também adiciona o recurso no provedor cloud e fica registrado no state, que é a pasta que, quando trabalhamos em equipe, registra todas as configurações. Junto com isso, o segundo "segredo" é o que permite que nós ou nossos colegas trabalhemos simultaneamente, sem que haja conflitos de informação que quebrem nosso código. O tfstate é um dos segredos que comentamos na aula anterior.
O último comando é destroy, que elimina tudo o que foi criado e apaga todos os recursos geridos, além de atualizar o estado. Novamente, se estivermos apagando alguma informação, adicionando ou atualizando, aparecerá o plan, apenas um resumo do que se sugere fazer, mas para realmente executar, devemos rodar o comando apply e dar a confirmação de sim ou não. Esses são os quatro comandos principais.
Antes de seguir com a instalação do Terraform, estamos usando macOS, mas podemos instalá-lo tanto no macOS, quanto no Linux ou no Windows. Se usarmos Windows, recomendamos instalar um subsistema chamado WSL, que permite ter uma experiência Linux dentro da máquina Windows. A instalação do WSL é muito simples; será mostrada aqui no terminal. Claro que não executaremos os comandos porque não usamos Windows, mas eles serão escritos no terminal para que seja mais fácil executá-los no PowerShell.
Para verificar se já temos algum subsistema instalado na máquina, utilizamos o seguinte comando:
wsl -l
Se não tivermos, aparecerá uma mensagem dizendo que não foi localizado nenhum subsistema Linux. Se aparecer essa mensagem, temos duas opções. Podemos pressionar qualquer tecla para instalar ou forçar a instalação com:
wsl.exe --install
Esse segundo comando forçará a instalação do WSL na máquina Windows para que tenhamos a experiência com Ubuntu. Nesse momento, ao pressionar Enter, começará a busca por subsistemas, identificará o Ubuntu, aparecerão várias linhas na tela e, ao final, haverá uma mensagem de sucesso. Após a mensagem de sucesso, será solicitado criar nosso usuário, nosso nome de usuário.
Se, por exemplo, criássemos um usuário, poderíamos usar algo como carolg ou carolp, que são abreviações do nosso sobrenome, mas podemos escolher o nome que preferirmos. Esse usuário será utilizado para autenticação no terminal do Ubuntu. Portanto, é importante criar um usuário real, que será efetivamente utilizado. Na tela de instalação, é isso: executamos a instalação e criamos nosso usuário.
Além disso, dentro do PowerShell, não é obrigatório, mas é interessante que façamos isso. Após concluir toda a instalação, devemos executar um comando para atualizar todos os pacotes e instalar as atualizações. Não é uma regra, mas é aconselhável. Qual é esse comando? Vamos executar:
sudo apt update && sudo apt upgrade -y
Assim que executarmos esse comando, o sistema atualizará todos os pacotes, instalará as atualizações e estaremos prontos para instalar o Terraform.
A instalação do Terraform será seguida a partir da documentação oficial em seu site, mas aqui explicamos a instalação do subsistema WSL no Windows para obter experiência com Linux. Após essa instalação, podemos buscar no Google, abrir o Ubuntu, e um novo terminal diferente do PowerShell será aberto. Nesse terminal, já estaremos conectados com nosso usuário e será solicitado que criemos uma senha. Criamos a senha e, a partir daí, estaremos conectados a esse novo terminal.
Vamos remover um comando que não será utilizado, pois era apenas para usuários de Windows, e agora abriremos o site oficial com a documentação do Terraform. Ao buscar no Google "install terraform", chegaremos à mesma tela que estamos. No início, já temos um vídeo explicativo sobre como realizar as instalações nos diferentes sistemas operacionais, mas o que nos interessa está mais abaixo. O que temos aqui? Instruções para instalar o Terraform no Linux. Ao clicar, basta seguir copiando e colando, é como uma instalação de "próximo, próximo, próximo, aceito, finalizar". É basicamente o mesmo, muito intuitivo e com todas as informações necessárias. Como é a primeira vez que fazemos isso, é importante ler para entender o que está sendo feito, mas basicamente só precisamos copiar e colar os comandos indicados no guia.
Para instalar o Terraform no Linux, começamos atualizando os pacotes e instalando algumas dependências necessárias:
sudo apt-get update && sudo apt-get install -y gnupg software-properties-common
Em seguida, adicionamos a chave GPG do repositório oficial do HashiCorp:
wget -O- https://apt.releases.hashicorp.com/gpg | \
gpg --dearmor | \
sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg >/dev/null
Verificamos a chave GPG:
gpg --no-default-keyring \
--keyring /usr/share/keyrings/hashicorp-archive-keyring.gpg \
--fingerprint
Adicionamos o repositório do HashiCorp à lista de fontes do APT:
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | \
sudo tee /etc/apt/sources.list.d/hashicorp.list
Atualizamos novamente os pacotes e instalamos o Terraform:
sudo apt update
sudo apt-get install terraform
Os sistemas que possuem mais particularidades são Windows e macOS. Para Windows, é obrigatório ter um gerenciador de pacotes antes de instalar o Terraform. Se não instalamos o WSL e decidimos continuar com o Windows, não há problema, mas antes devemos abrir o site do Chocolatey. No site do Chocolatey, aparecerá à direita a opção de instalação. Clicamos em "install". Ao descer um pouco a página, veremos as instruções de tudo o que precisamos fazer. Executaremos um primeiro comando de get; se ele retornar que está restrito, executaremos um segundo comando, pois precisamos habilitar a execução de scripts. Uma vez que alcançamos o resultado esperado, teremos instalado o Chocolatey sem problemas. Então, copiamos esse novo comando, colamos em nosso terminal e, assim, o Chocolatey será instalado. Quando o Chocolatey terminar, voltamos ao site do Terraform e, a partir daí, seguimos com os comandos de instalação. Instalamos o Chocolatey, copiamos e colamos o primeiro comando, colocamos em nosso terminal para instalar o Terraform no Windows.
choco install terraform
No macOS, já temos o Homebrew instalado. Se não o tivermos, é o mesmo que com o Chocolatey: clicamos, somos redirecionados para outra página com as instruções de instalação, apenas copiamos e colamos, e quando terminar, voltamos a esta tela. Qual é o primeiro comando que vamos colar em nosso terminal? Será este primeiro. Com este primeiro comando, estamos adicionando o repositório oficial de pacotes, então copiamos, vamos ao terminal e colamos essa instrução. Executamos, ele fará as instalações e, em seguida, passamos para o segundo comando para instalar. É importante notar que essas instalações podem variar muito dependendo do equipamento, tanto no Windows quanto no macOS: pode ser que o processo seja rápido ou demore um pouco, mas o importante é que ele fará toda a instalação necessária, será executado em nossa tela e, ao final, haverá uma mensagem de sucesso.
brew tap hashicorp/tap
brew install hashicorp/tap/terraform
Uma vez que executamos, sempre podemos verificar as versões do que instalamos. Já tínhamos o Homebrew instalado, mas poderíamos executar brew --version e ver qual é a versão instalada para validar. Então, feita a instalação, sempre executamos a verificação de versão. No nosso caso, como já tínhamos, acabamos de instalar o Terraform e faremos a confirmação de que tudo saiu bem. Executamos os dois comandos indicados na documentação, executamos terraform version, e já apareceu que temos a versão v1.14.7. Assim, o Terraform já está instalado em nossa máquina.
terraform --version
Se interrompemos ou ainda estamos instalando, pode ser que nosso equipamento, especialmente se for Windows, nos peça para reiniciar a máquina. Se isso acontecer, não há problema: reiniciamos o equipamento e depois voltamos para continuar com a instalação, não há problema.
Uma vez que o Terraform está instalado, vamos criar nosso primeiro projeto no VS Code. Como fazemos isso? Primeiro, criaremos um diretório, vamos usar mkdir terraform, chamaremos de Terraform Alura, mas podemos colocar o nome que quisermos. Criamos o diretório com:
mkdir terraform-alura
Uma vez criado, acessaremos esse diretório para poder criar nosso arquivo, então usamos:
cd terraform-alura
Entramos nesse diretório, e o que faremos agora? Vamos criar um arquivo dentro do nosso projeto no VS Code. Criaremos um arquivo chamado main.tf. Criado esse arquivo, abriremos nosso VS Code. Como fazemos isso? Com o comando:
touch main.tf
code .
Executamos e o VS Code se abre automaticamente em nossa tela. À esquerda, já aparece o nome que acabamos de criar e nosso primeiro arquivo chamado main.tf. A partir daqui, podemos considerar que temos um projeto criado.
Agora passaremos aos próximos temas, módulo por módulo, pasta por pasta, ponto por ponto, para entender como funciona. Com isso, já conseguimos instalar o Terraform. Para quem usa Windows e optou pela experiência com Linux, instalou o WSL, instalou o Terraform, fez as configurações, criou um diretório e o primeiro arquivo do nosso projeto.
HCl, o que seria HCl? Lembrando que o Terraform utiliza uma sintaxe declarativa, e HCl nada mais é do que seu próprio idioma. Com esse idioma de forma declarativa, informamos o que queremos, sem especificar como será feito, apenas informamos o que desejamos, de acordo com a configuração. Claro que conheceremos mais sobre isso adiante, mas, basicamente, informamos o que queremos e ele constrói.
Vamos passar para o próximo slide para continuar com algumas explicações, para que fique mais claro. Esta é uma síntese básica: as três primeiras linhas são uma simulação, e abaixo já temos um recurso real. Na primeira linha, temos um bloco, o tipo, o nome, abre chaves, argumento igual a valor. Essa é a síntese que veremos sempre. Temos um bloco que se refere, neste caso, ao recurso que vamos criar.
Para ilustrar essa estrutura, veja o exemplo de um bloco básico:
bloco "tipo" "nome" {
argumento = valor
}
Faço a substituição dos nomes, o tipo é realmente o recurso que queremos criar em nosso provedor na nuvem, neste exemplo é a AWS. Declaramos nosso tipo aqui dentro, queremos criar um S3 bucket, e ao lado fazemos a criação do nome. Esse nome é interno em nosso sistema, então podemos atribuir o nome que considerarmos relevante para nosso projeto. Aqui deixamos como my_bucket, mais adiante veremos isso com mais frequência, mas, por enquanto, apenas como exemplo, deixamos como my_bucket. Abrimos chaves e então começamos a declaração de nosso bloco com os argumentos. A parte do argumento foi substituída por bucket e é igual ao valor, nome do nosso bucket. Aqui temos uma síntese básica criando um recurso.
Agora, vamos ver como isso se aplica na prática com um recurso real:
resource "aws_s3_bucket" "meu_bucket" {
bucket = "nome-do-bucket"
}
Vamos passar para o próximo slide, onde temos os quatro blocos principais deste idioma HCL. Qual é o primeiro bloco? É o provider. No bloco provider, declaramos os provedores na nuvem, é aí que indicamos com quem queremos nos conectar, com quem queremos construir nossa infraestrutura. Lembrando que o Terraform é uma ferramenta multinuvem, então podemos ter mais de um bloco provider, não necessariamente precisamos usar apenas AWS, ou apenas Azure, ou apenas Google Cloud, por exemplo. Podemos ter esses blocos dentro do mesmo código para trabalhar no mesmo projeto. E esse é um dos benefícios da ferramenta, precisamente por ser multinuvem.
Reforçando, no decorrer do curso veremos essas particularidades, pois cada provedor na nuvem tem seu próprio formato de declaração. Por exemplo, na AWS, só precisamos colocar provider, indicar que é AWS, abrir nosso bloco e, abaixo, colocar nosso argumento, que é region, e indicar a região que queremos. Azure já funciona um pouco diferente: abrimos o bloco provider, abrimos as chaves e, na linha de baixo, precisamos colocar features. Não é obrigatório colocar nada, mas é necessário declará-lo.
Vale esclarecer que cada provider (provedor) possui sua própria maneira de configuração dentro do Terraform. O bloco provider é onde estabelecemos a conexão com o provedor na nuvem.
O segundo elemento, conforme mostrado na apresentação, são os recursos. Nesse bloco, informamos os recursos desejados, lembrando que cada bloco resource deve ser adaptado ao provedor de nuvem que estamos utilizando. No exemplo anterior, mencionamos a AWS, pois é o que seguiremos no curso. No bloco de resources, declaramos o que queremos criar, atribuímos um nome e, em seguida, especificamos argumentos e valores.
As variáveis são elementos que parametrizam nosso projeto ou estudo, podendo ser aplicadas em um ambiente real. Já o output refere-se às saídas de informação após a aplicação. Existem alguns comandos no Terraform que podemos analisar antes de realizar o deploy, e temos o apply, que efetivamente aplica as informações no provedor. O output é o resultado desse processo. Em cenários reais, podemos usar o output para obter um ID ou um IP público. Dentro do nosso projeto, trabalharemos com output, mas é importante destacar que, em um ambiente real, ele pode ser utilizado para diversas informações úteis. Com essas informações extraídas e exibidas na tela, podemos levá-las para outra parte do projeto, para outro projeto, ou utilizá-las em um formato diferente.
O output é apresentado como o último elemento, mas ele combina esses quatro blocos principais desse linguagem. Sempre que abrimos chaves, iniciamos um bloco. Pense assim: ao ver chaves, iniciamos um bloco. Sempre que há o sinal de igual, estamos tratando de um argumento.
Voltando ao exemplo anterior, no resource declaramos o que queremos criar, que é nosso AWS S3 bucket, atribuímos um nome e abrimos chaves. Nesse momento, estamos no bloco. Abaixo, definimos nosso argumento. Entre as chaves, temos um argumento, que é bucket = valor. Essa é a síntese básica que veremos ao longo do curso muitas vezes. Os nomes utilizados são apenas títulos explicativos. Podemos, e isso nos ajudará a entender melhor, criar nomes que façam sentido. Seja em um exercício de aprendizado ou em um projeto real, adapte os nomes de forma que façam sentido para nós. Assim, o panorama ficará mais claro. A explicação permitirá assimilar uma tela com a outra, e sempre lembraremos que criamos um recurso específico, como um bucket. Para o próximo recurso que vamos criar, basta seguir a mesma lógica. Claro que cada recurso terá suas particularidades, que veremos na documentação, mas a base já conhecemos.
Isso é tudo. Até a próxima aula!
O curso Terraform: gerenciar infraestrutura como código e modularizar recursos possui 276 minutos de vídeos, em um total de 99 atividades. Gostou? Conheça nossos outros cursos de Infraestrutura como Código em DevOps, ou leia nossos artigos de DevOps.
Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:
Todos os cursos, trilhas e certificados para evoluir.
7 dias para cancelar com reembolso
Aprenda mais rápido com IA, idiomas e imersões.
7 dias para cancelar com reembolso
TUDO DO PLUS, MAIS:
Aceleração de carreira: mentoria, vagas e prática guiada.
7 dias para cancelar com reembolso
TUDO DO PRO, MAIS: