Artigos > Criando instância RDS Postgres efêmero na AWS via Terraform

O artigo de hoje um pouco extenso. Tentarei ser breve aqui na explicação. Vou demonstrar como criar uma instância AWS RDS Postgres a partir do Terraform. Para isso publiquei um projeto no Github. Basicamente, uma instância efêmera pode ser necessária em diversas situações. Por exemplo, quando queries muito pesadas precisam ser executadas no banco de dados e em horário comercial gerariam degradação de performance quando somadas com as demandas de clientes. Esse é um caso clássico, mas há outros cenários.

No caso do projeto em questão, ele cria uma instância efêmera com automações que recriarão a instância diariamente com base em um snapshot gerado a partir do banco de dados de produção. No final de cada dia a instância efêmera é excluída. Para isso utilizei Event Bridge (Scheduler) e Lambda Function.

O código deste artigo está disponível no meu Github. Aqui neste artigo vou explicar as edições necessárias.

Arquivo terraform.tfvars

Vamos começar criando o arquivo terraform.tfvars. Nele teremos os dados da instância de origem (produção), as configurações da instância efêmera que será criada e os agendamentos que faremos para disparar as Lambda Functions.

Nas vars a seguir é preciso informar o nome da instância RDS que será clonada e o nome que o snapshot diário que será criado.

# Instrucoes do banco de dados de origem:
production_database_identifier = "src-rds-instance-name"
production_database_snapshot   = "src_rds_instance_snapshot"

Observe que esse snapshot é criado apenas para criar a instância efêmera. Em seguida ele será removido, então não precisa se preocupar em rotacionar datas no nome do snapshot.

A seguir no arquivo terraform.tfvars, especificamos configurações que serão utilizadas na instância efêmera. É autoexplicativo.

# Configuracoes do RDS efêmero:
ephemeral_database_identifier  = "ephemeral_instance_name"
ephemeral_database_name        = "ephemeral_database_name"
db_engine                      = "postgres"
db_engine_version              = "16.2"
db_class                       = "db.t3.micro"
ephemeral_database_storage     = "gp2"

Por fim, temos os horários de execução das Lambda Functions. Aqui estou utilizando os nomes das funções nos nomes das variáveis.

# Agendamentos para execucao as funcoes lambda: 
cronjob_snapshot_creation      = "cron(30 6 ? * MON-FRI *)"
cronjob_snapshot_remotion      = "cron(00 8 ? * MON-FRI *)"
cronjob_database_creation      = "cron(00 7 ? * MON-FRI *)"
cronjob_database_remotion      = "cron(30 23 ? * MON-FRI *)"

Deixando mais claro: todas as funções só são executadas de segunda à sexta.

• A função cronjob_snapshot_creation é executada as 6:30.
• A função cronjob_database_creation é executada as 7:00.
• A função cronjob_snapshot_remotion é executada as 8:00.
• A função cronjob_database_remotion é executada as 23:30.

Arquivo main.tf

No arquivo main.tf vamos habilitar todos os recursos, configurações, funções lambda, etc. Tudo isso proporcionará a automação de criação e deleção da instância efêmera.

A primeira edição deve ser feita no trecho a seguir. Observe que estou usando uma variável de ambiente onde está armazenada a região com a qual estou trabalhando. Certifique-se de possuir essa var ou de editar esse trecho e chumbar a região na mão.

provider "aws" {
  region = var.REGION
}

O mesmo vale para o arquivo tfstate que, no meu caso, está armazenado em um bucket S3:

terraform {
  backend "s3" {
    region         = "us-east-1"
    bucket         = "bucket-name"
    key            = "path/to/terraform.tfstate"
    dynamodb_table = "terraform-state-lock"
  }
}

Também é interessante utilizar tags apropriadas às suas necessidades:

# Tags a serem usadas em todos os recursos
locals {
  common_tags = {
    Env       = "Ephemeral"
    Service   = "Postgres"
    Terraform = true
    Workspace = "Ephemeral"
  }
}

As edições necessárias de código terminam por aqui. Existem padrões que você pode alterar se desejar, mas o código já funcionará adequadamente. Nesse ponto, basta rodar o terraform plan para analisar as mudanças que serão feitas, e depois terraform apply quando estiver seguro o suficiente para deployar os recursos e configurações.

Importante: a primeira execução do código já provisionará o banco efêmero. Ou seja, durante a execução do código terraform será criado um snapshot do banco de produção seguido da criação do banco efêmero.

Lambda Functions

Serão criadas 4 Lambda Functions:

• cronjob_snapshot_creation: cria snapshot do banco de produção;
• cronjob_database_creation: cria a instância efêmera;
• cronjob_snapshot_remotion: remove o snapshot criado;
• cronjob_database_remotion: remove a instância efêmera.

As fiz usando Python e os scripts estão disponíveis no projeto do Github. Contudo, para fazer deploy das functions, é necessário comprimir em arquivo ZIP. Por isso o main.tf possui o recurso de zipar os scripts antes do deploy, conforme destaque a seguir:

data "archive_file" "rdsCreateDbEphemeral_zip" {
  type        = "zip"
  source_dir  = "./src_lambda_function/rdsCreateDbEphemeral"
  output_path = "./zip_lambda_function/rdsCreateDbEphemeral.zip"
}

Quando as functions são criadas, cria-se no Lambda as variáveis de ambiente que os scripts necessitam para realizar suas ações.

Event Bridge

O Event Bridge é um ambiente da AWS que nos permite agendar gatilhos, como no Crontab do Linux ou Scheduler Tasks do Windows. Toda a parte de disparo das functions fica nele.

Resumo

A automação salva vidas. Bancos efêmeros são ótimos para delegar acessos muito específicos como auditorias, benchmarks de produtos e serviços, análises e troubleshootings, entre outros. Se a demanda for grande, o banco efêmero pode ser uma solução inteligente.

Lembre-se, teste tudo o tempo todo antes de fazer deploy em seus ambientes. O terraform plan está aí para isso.

Grande abraço e até a próxima.