Implementando monitoramento em aplicações N-Tier na AWS

A arquitetura N-Tier é um modelo de design de software que divide uma aplicação em camadas lógicas distintas, também conhecidas como “camadas” ou “níveis”, onde cada camada desempenha funções específicas e se comunica com as outras camadas por meio de interfaces bem definidas. O “N” em N-Tier representa o número de camadas que podem variar de acordo com a complexidade e os requisitos da aplicação.

Para implementar a automação de monitoramento para a aplicação N-Tier utilizando o Terraform e os serviços da Amazon Web Services (AWS) mencionados (Amazon Route53, Amazon S3, Amazon EC2 e Amazon RDS), podemos criar um cenário básico de infraestrutura com um Load Balancer, instâncias EC2 em um Auto Scaling Group, um banco de dados RDS e configurar o monitoramento usando o serviço Amazon CloudWatch. Vou guiar você pelo processo de implementação desse cenário com o Terraform.

Antes de começar, certifique-se de que você tenha o Terraform instalado em sua máquina e tenha configurado as credenciais da AWS. Agora, vamos criar o código Terraform para essa automação:

Crie um arquivo chamado main.tf com o seguinte conteúdo inicial:

provider "aws" {
  region = "us-east-1" # Defina a região desejada da AWS
}

# Defina suas variáveis de ambiente aqui, como nome do projeto, tags, etc.

Crie uma zona DNS no Amazon Route53 para seu domínio. Substitua “seu-dominio.com” pelo seu domínio real.

resource "aws_route53_zone" "main" {
  name = "seu-dominio.com"
}
resource "aws_route53_record" "www" {
  zone_id = aws_route53_zone.main.zone_id
  name    = "www.seu-dominio.com"
  type    = "A"
  alias {
    name                   = "seu-load-balancer-dns" # Substitua pelo DNS do Load Balancer posteriormente criado
    zone_id                = aws_lb.front_end.zone_id
    evaluate_target_health = true
  }
}
resource "aws_route53_record" "root" {
  zone_id = aws_route53_zone.main.zone_id
  name    = "seu-dominio.com"
  type    = "A"
  alias {
    name                   = "seu-load-balancer-dns" # Substitua pelo DNS do Load Balancer posteriormente criado
    zone_id                = aws_lb.front_end.zone_id
    evaluate_target_health = true
  }
}

Crie um bucket no Amazon S3 para armazenar os logs do Load Balancer:

resource "aws_s3_bucket" "lb_logs" {
  bucket = "seu-nome-do-bucket-logs" # Substitua pelo nome do bucket que você deseja
  acl    = "log-delivery-write"
}
resource "aws_lb" "front_end" {
  name               = "seu-nome-do-load-balancer" # Substitua pelo nome do load balancer
  internal           = false
  load_balancer_type = "application"
  subnets = ["subnet-1", "subnet-2", "subnet-3"] # Substitua pelas IDs das suas subnets públicas
  access_logs {
    bucket = aws_s3_bucket.lb_logs.bucket
  }
}
resource "aws_lb_target_group" "front_end" {
  name     = "seu-nome-do-target-group" # Substitua pelo nome do target group
  port     = 80
  protocol = "HTTP"
  vpc_id   = "sua-vpc-id" # Substitua pela ID da sua VPC
  health_check {
    path                = "/"
    protocol            = "HTTP"
    matcher             = "200-299"
    interval            = 30
    timeout             = 5
    healthy_threshold   = 2
    unhealthy_threshold = 2
  }
}

Crie uma instância EC2 utilizando Auto Scaling Group:

resource "aws_launch_configuration" "app_launch_config" {
  name_prefix   = "app-launch-config"
  image_id      = "ami-xxxxxxxxxxxxxxxxx" # Substitua pelo ID da imagem EC2 que você deseja usar
  instance_type = "t2.micro"
  security_groups = [
    "seu-security-group-id", # Substitua pelo ID do security group permitindo tráfego HTTP
  ]
  user_data = <<-EOF
              #!/bin/bash
              echo "Hello from EC2 instance!"
              EOF
}
resource "aws_autoscaling_group" "app_asg" {
  name                 = "seu-auto-scaling-group"
  max_size             = 2
  min_size             = 1
  desired_capacity     = 1
  launch_configuration = aws_launch_configuration.app_launch_config.name
  target_group_arns    = [aws_lb_target_group.front_end.arn]
  vpc_zone_identifier  = ["subnet-1", "subnet-2", "subnet-3"] # Substitua pelas IDs das suas subnets públicas
}

Crie uma instância RDS (banco de dados) com o Amazon RDS:

resource "aws_db_subnet_group" "rds_subnet_group" {
  name       = "seu-rds-subnet-group"
  subnet_ids = ["subnet-4", "subnet-5", "subnet-6"] # Substitua pelas IDs das suas subnets privadas
}
resource "aws_db_instance" "rds_instance" {
  identifier           = "seu-nome-do-banco-de-dados"
  allocated_storage    = 20
  engine               = "mysql" # Substitua pelo banco de dados que deseja utilizar (ex: "mysql", "postgres", etc.)
  instance_class       = "db.t2.micro"
  name                 = "seu-nome-do-banco-de-dados"
  username             = "seu-usuario-do-banco"
  password             = "sua-senha-do-banco"
  db_subnet_group_name = aws_db_subnet_group.rds_subnet_group.name
}

Configurando o monitoramento usando o Amazon CloudWatch:

resource "aws_cloudwatch_metric_alarm" "high_cpu_utilization" {
  alarm_name          = "high-cpu-utilization"
  comparison_operator = "GreaterThanOrEqualToThreshold"
  evaluation_periods  = "2"
  metric_name         = "CPUUtilization"
  namespace           = "AWS/EC2"
  period              = "60"
  statistic           = "Average"
  threshold           = "70"
  alarm_description   = "This metric checks for high CPU utilization"
  alarm_actions       = ["arn:aws:sns:us-east-1:123456789012:your-sns-topic"]
  dimensions = {
    InstanceId = aws_instance.ec2_instance.id
  }
}
resource "aws_cloudwatch_metric_alarm" "rds_high_cpu_utilization" {
  alarm_name          = "rds-high-cpu-utilization"
  comparison_operator = "GreaterThanOrEqualToThreshold"
  evaluation_periods  = "2"
  metric_name         = "CPUUtilization"
  namespace           = "AWS/RDS"
  period              = "60"
  statistic           = "Average"
  threshold           = "70"
  alarm_description   = "This metric checks for

Até o próximo post! =)