Detalhes do projeto
- Link do projeto no Github: https://github.com/cerqueiralex/iac-ec2-terraform-docker
- Tecnologias: Docker, Terraform, AWS EC2
- Categorias: Data Engineering, IaC
Este artigo explora a implementação prática da integração entre DevOps e Infraestrutura como Código (IaC), com foco na automação da infraestrutura AWS EC2 utilizando a ferramenta Terraform. Destaco aqui a importância da IaC, tratando a infraestrutura como código de software demonstrando os benefícios dessa abordagem na agilidade, rastreabilidade e escalabilidade da infraestrutura em nuvem.
IaC (Infraestrutura como código) é um método para gerenciar e provisionar infraestrutura de TI utilizando código de programação, em vez de fazê-lo manualmente através de interfaces web ou de linha de comando. Isso permite que a infraestrutura seja tratada como qualquer outra parte do código de aplicativo, o que facilita a automação, a reprodução e o controle de versão.
IaC é usado para automatizar o provisionamento de recursos de infraestrutura, como máquinas virtuais, containers, armazenamento, rede e outros, além de automatizar a configuração deles. IaC também pode ser usado para automatizar o escalonamento horizontal e vertical, assim como a implantação de aplicações.
IaC é especialmente útil em ambientes de nuvem, onde os recursos podem ser provisionados e escalados rapidamente e é amplamente utilizado em conjunto com DevOps e práticas de desenvolvimento ágil para tornar mais fácil e rápido para equipes de desenvolvimento implementar e gerenciar suas aplicações.
1. Acessar o AWS IAM e criar as chaves de autenticação
O AWS Identity and Access Management (IAM) é um serviço da Amazon Web Services (AWS) que oferece controle seguro de acesso aos recursos e serviços da AWS.
O IAM desempenha um papel fundamental na segurança da AWS, permitindo que os usuários concedam ou neguem acesso a recursos, implementem a autenticação de fatores múltiplos e integrem políticas de segurança personalizadas, mas principalmente, o AWS IAM serve para controlar e proteger o acesso aos serviços e recursos da AWS, contribuindo para a implementação de práticas robustas de segurança na nuvem.
Nesse sentido, para poder gerenciar os recursos AWS via IaC, é essencial possuirmos uma chave de acesso IAM para se conectar como administrador e gerenciar todos os recursos. Essas chaves de autenticação permitem que o Terraform e os scripts de automação acessem sua conta.
É importante destacar que por questões de segurança, não é indicado gerar essas chaves de acesso no usuário root ou superadmin, pois ela será utilizada na configuração do IaC e qualquer um que tiver acesso terá controle total à infraestrutura, podendo fazer quaisquer alterações e gerar custos indevidos, assim como notifica a AWS na hora da criação das chaves.
A Chave é composta de 2 estruturas, é recomendado baixar o .csv pois a segunda estrutura só pode ser visualizada uma única vez.
2. Criando imagem e container Docker
A estrutura de diretórios padrão para a criação do projeto deve conter o diretório raíz e dentro o dockerfile junto com o conector “main.tf” que será utilizado para passar os atributos da máquina EC2 para a AWS.
- diretório “terraformiac”
- Dockerfile
- main.tf
2.1 Dockerfile
Em seguida é necessário montar o Dockerfile que irá criar a imagem docker para rodar o Terraform e o AWS CLI
# Usando a imagem oficial do Ubuntu como base (última versão)
FROM ubuntu:latest
# Atualizando os pacotes do sistema e instalar dependências necessárias
RUN apt-get update && \
apt-get install -y wget unzip curl
# Definir a versão do Terraform
ENV TERRAFORM_VERSION=1.6.2
# Baixar e instalar Terraform
RUN wget https://releases.hashicorp.com/terraform/${TERRAFORM_VERSION}/terraform_${TERRAFORM_VERSION}_linux_amd64.zip && \
unzip terraform_${TERRAFORM_VERSION}_linux_amd64.zip && \
mv terraform /usr/local/bin/ && \
rm terraform_${TERRAFORM_VERSION}_linux_amd64.zip
# Criar a pasta /terraformiac dentro do container
RUN mkdir /terraformiac
# Copiar main.tf para a pasta /terraformiac no container
COPY main.tf /terraformiac/
# Criar a pasta Downloads e instalar o AWS CLI (para acessar a AWS)
RUN mkdir Downloads && \
cd Downloads && \
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" && \
unzip awscliv2.zip && \
./aws/install
# Definir o comando padrão para execução quando o container for iniciado
CMD ["/bin/bash"]
2.2 Arquivo terraform “main.tf”
Montando o arquivo terraform com os atributos da instância EC2. Estamos utilizando a imagem e instância t2.micro que está presente na camada gratuita da AWS.
É necessário também configurar a região de acordo com o projeto. Aqui está sendo utilizada a “us-east-2” que fica localizada em Ohio.
provider "aws" {
region = "us-east-2"
}
#alterar imagem e instância de acordo com necessidade do projeto
resource "aws_instance" "tarefa1" {
ami = "ami-0a0d9cf81c479446a" # AMI na AWS
instance_type = "t2.micro"
#alterar tag de acordo com nome do projeto
tags = {
Name = "terraformiac"
}
}
2.3 Criando a imagem no Docker
No terminal linux/mac, execute o comando abaixo para criar a imagem Docker
docker build -t terraform-image:terraformiac .docker build: Este comando é utilizado para construir uma imagem Docker a partir de um Dockerfile.
-t terraform-image:terraformiac : Esta parte etiqueta a imagem com um nome e uma tag opcional. Neste caso, a imagem será etiquetada como terraform-image com a tag terraformiac . Os dois pontos (:) separam o nome da imagem da tag.
. : O ponto no final especifica o contexto de construção. O contexto de construção é o conjunto de arquivos em uma localização específica mencionada no Dockerfile. Neste caso, espera-se que o Dockerfile esteja no diretório atual (.).
Portanto, quando você executa este comando, o Docker procura por um Dockerfile no diretório atual e o utiliza para construir uma imagem chamada terraform-image com a tag terraformiac .
2.4 Criando o container Docker
Execute o comando abaixo para criar o container Docker
docker run -dit --name terraformiac terraform-image:terraformiac /bin/bashdocker run -dit --name terraformiac terraform-image:terraformiac /bin/bash
docker run: Este comando é utilizado para executar um contêiner a partir de uma imagem especificada.
-dit:
-d: Modo destacado. Ele executa o contêiner em segundo plano, permitindo que você use o terminal para outros comandos.-i: Modo interativo. Mantém o STDIN aberto mesmo se não estiver conectado, permitindo interação com o contêiner.-t: Aloca um pseudo-TTY. Isso é frequentemente usado em conjunto com-ipara simular um terminal real.
--name terraformiac : Atribui um nome ao contêiner em execução. Neste caso, o nome é definido como terraformiac .
terraform-image:terraformiac : Especifica a imagem a ser usada para criar o contêiner. Refere-se à imagem terraform-image com a tag terraformiac .
/bin/bash: Substitui o comando padrão especificado no Dockerfile e inicia um shell Bash interativo dentro do contêiner. Isso é útil para interagir com o contêiner quando estiver em execução.
Portanto, quando você executa este comando, o Docker criará um novo contêiner com base na imagem terraform-image com a tag terraformiac . O contêiner será executado em modo destacado e interativo, e você pode acessar seu shell usando /bin/bash. O contêiner é nomeado como terraformiac .
2.5 Verficando as versões
Para confirmar se tudo correu cde acordo, agora acessando o terminal docker, verifique as versões do Terraform e do AWS CLI com os comandos abaixo:
terraform version
aws --version3. AWS CLI
O AWS Command Line Interface (AWS CLI) é uma ferramenta de linha de comando que permite aos usuários interagir e gerenciar recursos na Amazon Web Services (AWS) diretamente por meio do terminal.
Com suporte para uma ampla gama de operações, o AWS CLI simplifica tarefas como a criação de instâncias EC2, a configuração de buckets no Amazon S3 e a administração de serviços relacionados à nuvem.
Utilizando comandos intuitivos, os usuários podem automatizar processos, criar scripts e integrar operações da AWS em pipelines de desenvolvimento, proporcionando uma interface eficiente e flexível para a gestão de recursos na nuvem da AWS.
Por questões de segurança, é preferível configurar o AWS CLI manualmente, pois caso contrário você precisará colocar sua chave de segurança no arquivo Dockerfile, o que irá expor sua chave para qualquer um que tiver acesso à automação.
3.1 Configurar o aws CLI via docker terminal
- Acessar o diretório do projeto com “cd”
- usar o comando “aws configure” no terminal na pasta onde está o aws cli
- digitar a primeira chave de acesso da instância
- digitar a segunda chave de acesso
- colocar o id da região ex: “us-east-2”
- enter = padrão none
3.2 Testando conexão entre terraform e AWS
Através do comando abaixo, ele deverá retornar por exemplo todos os buckets no terminal:
aws ec2 ls | awk ‘{print $NF}’aws ec2 ls: Isso chama o AWS CLI para listar as instâncias EC2.
|: O pipe | é usado para redirecionar a saída do comando anterior para o próximo comando.
awk ‘{print $NF}’: É um comando awk usado para extrair e imprimir a última coluna (campo) de cada linha da saída anterior. O $NF representa o último campo de cada linha.
Então, o comando completo nos lista as instâncias EC2 e extrai o valor da última coluna para cada linha da saída.
4. Iniciar o Terraform
Uma vez feita a conexão corretamente, basta iniciar o terraform através do comando
terraform init
Isso vai fazer com que ele crie todos os arquivos do terraform no diretório
por último, aplicar as configurações através do comando:
terraform applyCom esse comando você irá executar as configurações definidas no arquivo “main.tf”. Basicamente aqui ele irá mostrar todas as configurações de criação de uma nova instância de EC2
Uma vez aplicadas as alterações, ele terá criado com sucesso as instâncias EC2 no painel AWS.
Referências:
- https://docs.aws.amazon.com/cli/
- https://www.datascienceacademy.com.br/
- https://docs.docker.com/
- https://developer.hashicorp.com/terraform/docs
