[Série][DBRE] Pipeline de IaC para provisionamento de bancos de dados no Azure – Criando Módulo Terraform para Azure Cache for Redis

Fala meu povo e minha pova!

Mais uma manhã com conteúdo top! Continuando nossa série de posts de mão na massa, de construção de pipelines DevOps para entrega de infraestrutura de banco de dados no Azure, neste post veremos como criar uma instancia de banco de dados Redis gerenciado! O Redis é um banco de dados NoSQL, chave-valor que tem o intuito de armazenar dados em cache, ou seja, em memória Ram, o que o torna extremamente mais performático que um banco de dados relacional, principalmente para leitura.

O Redis é uma tecnologia que utilizamos para retirar carga de leitura estática dos bancos de dados relacionais e até alguns NoSQL que ficam no backend das nossas aplicações, os tipos de sistemas que mais se beneficiam desta tecnologia são: Login, configurações estáticas, armazenamento de estado, entre outros.

Vamos iniciar nosso módulo, para quem ainda não viu os posts anteriores sobre o projeto e a criação dos repositórios git, aconselho ver os seguintes posts:

Crie o repositório pipeline_iac_azure_cache_redis e dentro dele crie os seguintes arquivos:

1 – Vamos criar o arquivo rg.tf que será responsável por provisionar nosso resource group:

resource "azurerm_resource_group""rg"{  
name     = var.rg  
location = var.regiao
}

2 – Agora crie o arquivo variables.tf aonde iremos declarar nossas variáveis dinâmicas que serão utilizadas posteriormente para criar os recursos de bancos de dados e o próprio resource group:

variable "rg" {
    description = "Resource Group que será criado|utilizado na criação dos recursos de banco de dados"
}

variable "regiao" {
    description = "Região ao qual os recursos serão criados"
}

variable "ambiente" {
    type = map
    default = {
        d = "dev",
        h = "hml",
        p = "prd"
    }
}

variable "env" {
    default = "d"

    validation {
        condition = contains(["d","h","p"],var.env)
        error_message = "Argument 'env' must be either 'd' (dev), 'h' (hml) or 'p' (prd)"
    }
}

variable "nome_sistema" {
    description = "Nome do sistema ao qual os recursos serão destinados"
}

variable "tamanho_servidor" {
    description = "Especifica o tipo de perfil do servidor de cache Redis que será criado. Valores possíveis: Basic, Standard e Premium"
    default = {
        d = "Basic",
        h = "Standard",
        p = "Premium"
    }
}

variable "capacidade_servidor" {
    description = "Tamanho do servidor cache Redis. Valores validos baseado na variavel tamanho_servidor: C (Basic/Standard) are 0, 1, 2, 3, 4, 5, 6, and for P (Premium) family are 1, 2, 3, 4, 5."
    default = 1
}

variable "versao_redis" {
    description = "Versão do Redis que será utilizado, por padrão será a mais recente disponivel neste momento: 6"
    default = "6"
}

3 – Depois disso vamos criar o arquivo locals.tf onde algumas variáveis serão trabalhadas com base em tomadas de decisão, principalmente focada no ambiente produtivo, aonde precisamos ter ambientes mais robustos e redundantes:

locals {
    ambiente                = lookup(var.ambiente,var.env)
    server_sku_name         = lookup(var.tamanho_servidor,var.env)
    server_family           = local.server_sku_name == "Premium" ? "P" : "C"
    
    tags = {
        env         = var.env
        ambiente    = local.ambiente
        sistema     = var.nome_sistema
    }
}

4 – Agora vamos criar nossos recursos de cache de bancos de dados, crie um arquivo redis.tf aonde iremos criar um servidor de Redis:

resource "azurerm_redis_cache" "redis_cache_db" {
  name                = "rediscachedb-${var.nome_sistema}-${local.ambiente}"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  redis_version       = var.versao_redis  
  capacity            = var.capacidade_servidor
  family              = local.server_family
  sku_name            = local.server_sku_name
  enable_non_ssl_port = false
  minimum_tls_version = "1.2"

  redis_configuration {
  }

  tags = merge(local.tags)
}

Alguns pontos importantes que podemos verificar acima são: configurações de tls habilitadas para garantir a criptografia de dados que estão trafegando do Redis para aplicação e vice-versa (Podemos ver isso na imagem abaixo) e o campo redis_configuration, neste campo podemos configurar o Redis internamente setando configurações especificas desta tecnologia. Para mais informações sobre essas configurações, olhar: https://learn.microsoft.com/en-us/azure/azure-cache-for-redis/cache-configure#default-redis-server-configuration

5 – Quase acabando, vamos criar um arquivo output.tf para sabermos qual é o ID e hostname do banco de dados que estamos provisionando:

output "azure_cache_redis_id" {
    value = azurerm_redis_cache.redis_cache_db.id
}

output "azure_cache_redis_hostname" {
    value = azurerm_redis_cache.redis_cache_db.hostname
}

6 – Por fim, vamos declarar os valores das nossas variáveis no arquivo terraform.tfvars:

rg              = "TerraformAzurCacheRedis"
regiao          = "eastus"
env             = "p"
nome_sistema    = "login"

Uma vez criado todos os componentes do nosso módulo Terraform, vamos agora executa-lo para verificar se esta tudo funcionando como esperado:

terraform init
terraform validate
terraform plan
terraform apply --auto-approve

Podemos seguir agora para destruição desses recursos que não utilizaremos agora, executando:

terraform destroy

Vamos agora subir nossos códigos para o Github:

git add .
git commit -m "Modulo Terraform Azure Cache for Redis"
git push

É isso gente! Terminamos de criar nossos módulo Terraform para provisionamento de nossas infras de banco de dados, nos próximos capítulos iremos construir nossas pipelines de provisionamento dessas infraestruturas de forma totalmente automatizada!

Fiquem ligades! Até a próxima!