Terraform - Infra as Code
O que é o Terraform?
O Terraform é uma poderosa ferramenta de código aberto que permite definir e gerenciar sua infraestrutura como código. É uma ferramenta popular de infraestrutura como código (IaC) usada por desenvolvedores e administradores de sistema em todo o mundo para automatizar a criação, implantação e gerenciamento de recursos de infraestrutura na nuvem e no local. O Terraform fornece uma maneira de definir e gerenciar sua infraestrutura de forma declarativa, o que significa que você descreve o estado desejado de sua infraestrutura, e o Terraform lida com os detalhes de criação e gerenciamento dos recursos para atingir esse estado.
Um dos principais benefícios de usar o Terraform é que ele permite que você gerencie sua infraestrutura de maneira escalável, repetível e auditável. Ao definir sua infraestrutura como código, você pode controlar a versão de suas configurações de infraestrutura e reproduzi-las facilmente em vários ambientes. Isso facilita o gerenciamento de implantações de infraestrutura complexas e reduz o risco de erros que podem ocorrer ao configurar manualmente os recursos de infraestrutura.
Outro benefício de usar o Terraform é que ele oferece suporte a uma ampla gama de provedores e serviços de nuvem, incluindo Amazon Web Services, Microsoft Azure, Google Cloud Platform e muitos mais. Isso o torna uma ferramenta versátil que pode ser usada em uma variedade de ambientes e situações diferentes.
Para começar a usar o Terraform, você precisará de alguns pré-requisitos:
Depois de atender a esses pré-requisitos, você pode começar a usar o Terraform para definir e gerenciar sua infraestrutura como código. A primeira etapa é criar um arquivo de configuração do Terraform, que descreve os recursos que você deseja gerenciar usando o Terraform. Os arquivos de configuração do Terraform usam uma sintaxe simples e declarativa que é fácil de entender e escrever.
A sintaxe de um arquivo de configuração do Terraform é baseada na HashiCorp Configuration Language (HCL), que foi projetada para ser fácil de ler e escrever. A HCL usa uma sintaxe semelhante a JSON e YAML, mas é especificamente adaptada para gerenciamento de infraestrutura. Aqui está um exemplo de um arquivo de configuração simples do Terraform:
provider "aws" {
region = "us-east-1"
}
resource "aws_instance" "example" {
ami = "ami-0c55b159cbfafe1f0"
instance_type = "t2.micro"
}
Nesse exemplo, o provedor AWS é especificado usando a declaração provider, que define a região da infraestrutura em que os recursos serão provisionados.
Em seguida, um recurso EC2 é definido usando a declaração resource, que especifica a AMI (Amazon Machine Image) e o tipo de instância desejado.
A sintaxe da HCL torna a configuração do Terraform fácil de ler e escrever, permitindo que os usuários criem e gerenciem infraestrutura de maneira rápida e eficiente.
Conceitos fundamentais
Existem vários conceitos-chave no Terraform que são essenciais para entender como ele funciona. Esses conceitos incluem recursos, provedores, módulos e arquivos de estado.
Recursos: no Terraform, um recurso é uma parte da infraestrutura que você deseja gerenciar. Isso pode ser qualquer coisa, desde uma instância do AWS EC2 até um bucket do Google Cloud Storage. Cada recurso tem um tipo, como aws_instance ou google_storage_bucket, e um conjunto de parâmetros que definem sua configuração, como o tamanho da instância ou o nome do bucket.
Provedores: um provedor é um plug-in que permite que o Terraform se comunique com um provedor de nuvem específico ou infraestrutura local. Os provedores são responsáveis por traduzir as configurações do Terraform em chamadas de API que criam e gerenciam recursos no ambiente do provedor. Exemplos de provedores incluem AWS, Azure e Google Cloud Platform.
Módulos: um módulo é um conjunto independente de recursos que pode ser usado como bloco de construção para configurações de infraestrutura maiores. Os módulos permitem criar componentes reutilizáveis que podem ser compartilhados em diferentes configurações do Terraform. Por exemplo, você pode criar um módulo que defina uma pilha de servidor web completa, incluindo uma instância EC2, balanceador de carga e banco de dados.
Arquivos de estado: o Terraform usa arquivos de estado para acompanhar o estado atual de sua infraestrutura. O arquivo de estado contém informações sobre os recursos que o Terraform criou, sua configuração atual e quaisquer dependências entre eles. Isso permite que o Terraform determine quais alterações são necessárias para colocar sua infraestrutura no estado desejado e fazer essas alterações automaticamente.
Esses conceitos trabalham juntos para fornecer uma maneira poderosa e flexível de gerenciar sua infraestrutura como código. Você define a configuração de infraestrutura desejada usando a sintaxe declarativa do Terraform e o Terraform usa provedores para traduzir essa configuração em chamadas de API que criam e gerenciam recursos. Você pode usar módulos para criar componentes reutilizáveis e arquivos de estado para rastrear o estado atual de sua infraestrutura e gerenciar alterações ao longo do tempo. No geral, esses conceitos facilitam o gerenciamento de implantações complexas de infraestrutura, reduzem erros e melhoram a eficiência de seus fluxos de trabalho de gerenciamento de infraestrutura.
provider "aws" {
region = "us-west-2"
}
resource "aws_instance" "example" {
ami = "ami-0c55b159cbfafe1f0"
instance_type = "t2.micro"
tags = {
Name = "example-instance"
}
}
Neste exemplo, estamos usando o provedor AWS com a região definida como us-west-2. O tipo de recurso aws_instance cria uma instância do EC2 com a AMI e o tipo de instância especificados. Também estamos usando o atributo tags para dar à instância um nome de "example-instance". Depois de criar esse arquivo, você pode executar 'terraform apply' para criar a instância do EC2 em sua conta da AWS.
Por fim, definiremos um script para ser executado na instância que que instalará nossa aplicação web e iniciará o servidor web:
resource "aws_instance" "web"
ami = "ami-0c55b159cbfafe1f0"
instance_type = "t2.micro"
user_data = <<-EOF
#!/bin/bash
sudo apt-get update
sudo apt-get install -y apache2
sudo echo "<html><body><h1>Hello, World!</h1></body></html>" > /var/www/html/index.html
sudo systemctl restart apache2
EOF
tags = {
Name = "web-vm"
}
}
Neste exemplo, estamos instalando o Apache e criando um simples "Hello, World!" página da Internet.
Recomendados pelo LinkedIn
Depois de definir nossos recursos, podemos executar o terraform init para inicializar o Terraform e baixar os plug-ins do provedor necessários.
Em seguida, podemos executar o 'terraform plan' para ver quais alterações o Terraform fará em nossa infraestrutura.
Provisioners
Os 'provisionadores' no Terraform são usados para executar scripts ou comandos em um recurso depois que ele foi criado ou atualizado. Provisionadores são normalmente usados para executar tarefas como instalação de software, configuração de serviços ou cópia de arquivos para um recurso. Existem dois tipos de provisionadores no Terraform: local-exec e remote-exec. Os provisionadores de execução local executam scripts ou comandos na máquina que executa o Terraform, enquanto os provisionadores de execução remota executam scripts ou comandos no recurso que está sendo provisionado.
Aqui está um exemplo de um provisionador, local-exec que executa um script na máquina local após criar uma instância da AWS:
resource "aws_instance" "example"
ami = "ami-12345678"
instance_type = "t2.micro"
provisioner "local-exec" {
command = "echo 'Instance created!'"
}
}
Neste exemplo, o provisionador local-exec executa o echo 'Instância criada!' comando na máquina que executa o Terraform após a criação do recurso aws_instance.
Aqui está um exemplo de um provisionador de execução remota que executa um script na instância da AWS após sua criação:
resource "aws_instance" "example"
ami = "ami-12345678"
instance_type = "t2.micro"
provisioner "remote-exec" {
inline = [
"sudo yum update -y",
"sudo yum install -y nginx",
"sudo systemctl start nginx",
"sudo systemctl enable nginx",
]
}
}
Para concluir, vamos ao nosso primeiro tutorial.
HANDS-ON Terraform apply & destroy.
vamos criar um tutorial para implantar uma instância EC2 com Terraform e usá-la para executar uma busca de API do Twitter para obter os tópicos mais populares.
Primeiro, você precisará configurar uma conta de desenvolvedor do Twitter e criar chaves de API. Siga as instruções no site do desenvolvedor do Twitter para criar uma conta e gerar chaves de API.
2. Criar um arquivo de configuração do Terraform
Crie um novo diretório para seus arquivos de configuração do Terraform e crie um novo arquivo denominado main.tf. Adicione o seguinte código para criar uma instância do EC2 e um provisionador de execução remota para executar o script:
provider "aws"
region = "us-east-1"
}
resource "aws_instance" "example" {
ami = "ami-0c55b159cbfafe1f0"
instance_type = "t2.micro"
key_name = "example_key"
security_groups = ["example_security_group"]
tags = {
Name = "Example Instance"
}
provisioner "file" {
source = "fetch.py"
destination = "/home/ec2-user/fetch.py"
}
provisioner "remote-exec" {
inline = [
"sudo yum update -y",
"sudo yum install -y python3",
"sudo pip3 install tweepy",
"sudo python3 /home/ec2-user/fetch.py > /home/ec2-user/fetch.log",
"sudo systemctl enable crond",
"sudo systemctl start crond",
]
}
}
Esse código cria uma instância do EC2 com o ID de AMI, tipo de instância, par de chaves e grupo de segurança especificados. O provisionador de arquivo copia o script fetch.py do diretório local para a instância do EC2. O provisionador de execução remota instala o Python 3 e a biblioteca Tweepy, executa o script fetch.py, agenda o script para ser executado a cada minuto usando cron e inicia o serviço cron.
cron é um agendador de tarefas baseado em tempo, um scheduler, similar ao Airflow porém para tarefas simples em sistemas operacionais baseados em Unix. Ele permite agendar tarefas (ou seja, comandos ou scripts) para execução em horários ou intervalos específicos. Você pode usar o cron para automatizar tarefas de rotina, como backups, atualizações do sistema e processamento de dados.
No arquivo de configuração atualizado do Terraform que forneci, o provisionador de execução remota inclui as duas linhas a seguir para agendar o script fetch.py para ser executado a cada minuto usando o cron:
import tweep
consumer_key = "YOUR_CONSUMER_KEY"
consumer_secret = "YOUR_CONSUMER_SECRET"
access_token = "YOUR_ACCESS_TOKEN"
access_token_secret = "YOUR_ACCESS_TOKEN_SECRET"
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)
trends = api.trends_place(1)
with open("/home/ec2-user/fetch.log", "a") as f:
for trend in trends[0]["trends"]:
f.write(trend["name"] + "\n")
Substitua os espaços reservados YOUR_CONSUMER_KEY, YOUR_CONSUMER_SECRET, YOUR_ACCESS_TOKEN e YOUR_ACCESS_TOKEN_SECRET no script Python por suas chaves de API reais.
Quando você executa o terraform apply, o Terraform cria a instância do EC2, copia o script fetch.py para a instância, instala o Python 3 e o Tweepy, executa o script para buscar os tópicos mais populares da API do Twitter e agenda o script para ser executado a cada minuto usando o cron. A saída incluirá o endereço IP público da instância EC2, que você pode usar para SSH na instância e visualizar o arquivo fetch.log para ver os tópicos mais populares.