
Hoje daremos início a um tutorial de mão na massa onde iremos utilizar diversos serviços da AWS conectados em uma arquitetura. Com essa atividade você terá uma base em IaC (Infrastructure as code) com Serverless e Terraform, diversos serviços oferecidos pela plataforma, e também como utilizá-los em um código python.
Para começar a nossa arquitetura, utilizaremos o Terraform para subir a fila e os serviços necessários para seu funcionamento, ou seja, estaremos utilizando o conceito de Infrastructure as Code (IaC), que é um modo de provisionar a infraestrutura de forma automatizada.
Este artigo tutorial é auxiliar ao vídeo gravado pelo trainee Guilherme Ferreira Rocha, que está no Youtube do TerraLAB. Veja aqui:
Esta é a parte 1 deste tutorial, então aconselhamos que, continue acompanhando, para entender o que estamos arquitetando por completo. O repositório HandsOn AWS-TerraLAB contém todo o código utilizado nos tutoriais.
Um pouco mais sobre o projeto
A arquitetura que iremos implementar como exemplo, resumidamente, irá armazenar Pokémons de acordo com o tipo dele. O local de armazenamento, será um S3 Bucket da AWS, que é um serviço de armazenamento de objetos da Amazon. Para obter os dados de um pokémon, iremos utilizar a API PokéAPI.
Para que esse fluxo resumido da arquitetura aconteça, teremos funções lambda da AWS, sendo a primeira a que fará a requisição à API do pokémon e a segunda que irá guardar esses dados no S3 de forma particionada pelo tipo dele. A comunicação entre essas duas lambdas será feita por um fila de mensagens Amazon MQ.
Breve descrição dos serviços e ferramentas:
- Serverless Framework: Com ele conseguimos subir nossas funções lambdas como IaC e outros recursos “sem servidor” associados a lambda.
- Terraform: também é uma solução IaC que irá provisionar a infraestrutura e subir recursos com ou sem servidor, no nosso caso que não sejam necessariamente dependentes da existência das lambdas.
- Lambda: é um serviço de computação sem servidor que permite executar código sem provisionar ou gerenciar servidores.
- S3: é um serviço de armazenamento de objetos que oferece escalabilidade, disponibilidade de dados, segurança e performance.
- MQ: O Amazon MQ é um serviço gerenciado de agente de mensagens para o Apache ActiveMQ e RabbitMQ que facilita a configuração e a operação de agentes de mensagens na AWS.
- (BÔNUS) draw.io: é uma ferramenta gratuita que foi utilizada para a construção do desenho da arquitetura. Ela basicamente serve para construir diagramas, fluxos, etc. No contexto de infraestrutura ela já contém uma grande quantidade de objetos que representam diversos serviços e funcionalidades das nuvens e é sempre uma boa dica desenhar sua arquitetura antes de construí-la para te ajudar a obter uma melhor visão de seu projeto.
Outro ponto importante são os valores dos serviços envolvidos. A grande dica é sempre conferir no site da própria AWS o custo para cada serviço. Como arquiteto de infraestrutura, você deve estar sempre preocupado com o preço da sua arquitetura, para que possa tomar as melhores decisões para otimizar esse custo.
Para realizar esse tutorial uma conta com avaliação gratuita da AWS é suficiente, mas lembre-se de deletar a infraestrutura ao final para que você não receba cobranças indesejadas eventualmente.
Implementando a infraestrutura
Primeiramente, vamos listar todos os serviços que devemos provisionar para que a fila funcione da maneira que desejamos.
- Amazon MQ: Serviço de host da nossa fila.
- Secrets Manager: Serviço que irá armazenar as credenciais de login da fila.
- KMS: Serviço que guarda a chave de criptografia das credenciais de login.
- VPC/Security Group/Rules: Aqui liberaremos as portas necessárias para comunicação com a fila.
Para iniciar, iremos armazenar as credenciais de acesso pelo console da AWS. Para isso, é só ir em Secrets Manager > Segredos > Armazenar um novo segredo e seguir os passos do gif abaixo.
No exemplo do gif acima, utilizamos a chave default de criptografia do KMS, caso você queira ter uma chave apenas para esse segredo você pode criar uma (antes de criar o segredo do passo anterior) indo em Key Management Service > Chaves gerenciadas pelo cliente > Criar.
Com as credenciais criadas, podemos partir para o Terraform. Caso você ainda não tenha instalado, você pode baixar e seguir os passos de instalação neste link. Crie um arquivo com a extensão .tf que irá conter nosso código de infraestrutura, no vídeo é explicado com mais detalhes as propriedades do código. Nele, primeiramente, precisamos informar qual o provedor estaremos utilizando, que no caso será o da AWS.
provider "aws"{
region = "us-east-1"
}
Agora iremos acessar as credenciais que já criamos e decodificar em uma variável local.
data "aws_secretsmanager_secret_version" "mq_user" {
secret_id = "tutorial/mq/users"
}
locals {
credentials = jsondecode(
data.aws_secretsmanager_secret_version.mq_user.secret_string
)
}
Agora, para liberarmos as portas de comunicação com a fila, iremos adicionar as regras no grupo de segurança/vpc default. As portas que iremos liberar serão as: 8162, 61614 e 61617.
data "aws_vpc" "default" {
default = true
}
data "aws_security_group" "default" {
name = "default"
vpc_id = data.aws_vpc.default.id
}
resource "aws_security_group_rule" "ingress_rules_web" {
security_group_id = data.aws_security_group.default.id
type = "ingress"
cidr_blocks = ["0.0.0.0/0"]
description = "web console"
from_port = 8162
to_port = 8162
protocol = "tcp"
}
resource "aws_security_group_rule" "ingress_rules_stomp" {
security_group_id = data.aws_security_group.default.id
type = "ingress"
cidr_blocks = ["0.0.0.0/0"]
description = "stomp"
from_port = 61614
to_port = 61614
protocol = "tcp"
}
resource "aws_security_group_rule" "ingress_rules_openwire" {
security_group_id = data.aws_security_group.default.id
type = "ingress"
cidr_blocks = ["0.0.0.0/0"]
description = "open wire"
from_port = 61617
to_port = 61617
protocol = "tcp"
}
Por último, temos a própria fila.
resource "aws_mq_broker" "fila-pokemon" {
broker_name = "fila-pokemon"
engine_type = "ActiveMQ"
engine_version = "5.16.2"
host_instance_type = "mq.t3.micro"
publicly_accessible = true
user {
username = local.credentials.username
password = local.credentials.password
console_access = true
}
}
Todas essas propriedades necessárias para o código de cada serviço você encontra na documentação do terraform. E também sobre os serviços necessários para auxiliar o funcionamento do MQ você encontra na documentação da AWS MQ.
Para fazer o deploy da arquitetura, você precisa ter configurado o AWS CLI em seu PC. Então para iniciarmos o Terraform e realizar o deploy siga os seguintes comandos no seu terminal (no diretório do seu projeto):
terraform init
terraform plan
terraform apply
Esse processo leva cerca de 15 minutos para subir uma fila.
Conclusão
Com esse tutorial, você foi introduzido ao mundo de IaC e tomou conhecimento de alguns serviços disponíveis na AWS. Esses serviços podem ser utilizados em diversos propósitos ao se planejar uma arquitetura cloud. No próximo passo iremos utilizar uma IaC mais voltada para funções e micro serviços, o Serverless Framework.
Vale ressaltar, que ao final de deste projeto, você estará introduzido no mundo de cloud e com um conhecimento básico em diversos serviços oferecidos pela AWS, desta forma, possibilitando que você, ao se deparar com um problema real, já consiga ter ideias para arquitetar uma solução cloud para esse problema.
Se você se interessou pelo assunto, temos mais sobre o tema em nosso blog, e fique ligado para os próximos passos desse tutorial.
Você sabia que este artigo foi escrito por um trainee do TerraLAB? Você sabe como a escassez de profissionais qualificados impacta as empresas de Tecnologia da Informação? Clique aqui para conhecer os desafios desta indústria e como uma parceria com o TerraLAB pode ajudar você e a sua empresa. O TerraLAB é um celeiro de talentos que prepara estudantes para o mercado de trabalho, oferecendo vivências em projetos reais e experiência nos mais modernos processos e ferramentas de desenvolvimento de software. Siga-nos nas redes sociais para saber mais!
Este artigo foi escrito por Guilherme Ferreira Rocha, revisado por Prof. Rodrigo Silva.