Gerenciar clusters provisionados do Amazon Redshift com o Terraform


Amazon Redshift é um knowledge warehouse em nuvem rápido, escalável, seguro e totalmente gerenciado que torna simples e econômico analisar todos os seus dados usando SQL padrão e suas ferramentas existentes de extração, transformação e carga (ETL); inteligência empresarial (BI); e relatórios. Dezenas de milhares de clientes usam o Amazon Redshift para processar exabytes de dados por dia e cargas de trabalho de análise de energia, como BI, análise preditiva e análise de streaming em tempo actual.

HashiCorp Terraform é uma ferramenta de infraestrutura como código (IaC) que permite que você defina recursos de nuvem em arquivos de configuração legíveis por humanos que você pode versionar, reutilizar e compartilhar. Você pode então usar um fluxo de trabalho consistente para provisionar e gerenciar sua infraestrutura durante todo o seu ciclo de vida.

Nesta postagem, demonstramos como usar o Terraform para gerenciar operações comuns de cluster Redshift, como:

  • Criando um novo cluster Redshift provisionado usando o código Terraform e adicionando um Gerenciamento de identidade e acesso da AWS (IAM) papel para isso
  • Agendamento de operações de pausa, retomada e redimensionamento para o cluster Redshift

Visão geral da solução

O diagrama a seguir ilustra a arquitetura da solução para provisionar um cluster Redshift usando o Terraform.

Gerenciar clusters provisionados do Amazon Redshift com o Terraform

Além do Amazon Redshift, a solução utiliza os seguintes serviços da AWS:

  • Nuvem de computação elástica da Amazon (Amazon EC2) oferece a plataforma de computação mais ampla e profunda, com mais de 750 instâncias e escolha dos mais recentes processadores, armazenamento, rede, sistema operacional (SO) e modelo de compra para ajudar você a atender melhor às necessidades da sua carga de trabalho. Para esta publicação, usamos uma instância m5.xlarge com o Home windows Server 2022 Datacenter Version. A escolha do tipo de instância e do SO Home windows é flexível; você pode escolher uma configuração que se adapte ao seu caso de uso.
  • O IAM permite que você gerencie identidades e acessos com segurança a serviços e recursos da AWS. Usamos funções e políticas do IAM para acessar serviços com segurança e executar operações relevantes. Uma função do IAM é uma identidade da AWS que você pode assumir para obter acesso temporário a serviços e recursos da AWS. Cada função do IAM tem um conjunto de permissões definidas por políticas do IAM. Essas políticas determinam as ações e os recursos que a função pode acessar.
  • Gerenciador de segredos da AWS permite que você armazene com segurança o nome de usuário e a senha necessários para efetuar login no Amazon Redshift.

Nesta postagem, demonstramos como configurar um ambiente que conecta AWS e Terraform. A seguir estão as tarefas de alto nível envolvidas:

  1. Configurar uma instância EC2 com sistema operacional Home windows na AWS.
  2. Instale o Terraform na instância.
  3. Configure suas variáveis ​​de ambiente (sistema operacional Home windows).
  4. Definir uma política de IAM ter acesso mínimo para executar atividades em um cluster Redshift, incluindo pausar, retomar e redimensionar.
  5. Estabelecer uma função IAM usando a política que você criou.
  6. Crie um cluster Redshift provisionado usando o código Terraform.
  7. Anexe a função do IAM que você criou ao cluster Redshift.
  8. Escreva o código do Terraform para agendar operações de cluster, como pausar, retomar e redimensionar.

Pré-requisitos

Para concluir as atividades descritas neste publish, você precisa de uma AWS conta e privilégios de administrador na conta para usar os principais serviços da AWS e criar as funções do IAM necessárias.

Criar uma instância EC2

Começamos criando uma instância EC2. Conclua as seguintes etapas para criar uma instância EC2 do Home windows OS:

  1. No console do Amazon EC2, escolha Instância de lançamento.
  2. Escolha uma Amazon Machine Picture (AMI) do Home windows Server que atenda às suas necessidades.
  3. Selecione um tipo de instância apropriado para seu caso de uso.
  4. Configure os detalhes da instância:
    1. Escolha a VPC e a sub-rede onde você deseja iniciar a instância.
    2. Habilitar Atribuição automática de IP público.
    3. Para Adicionar armazenamentoconfigure as opções de armazenamento desejadas para sua instância.
    4. Adicione quaisquer tags necessárias à instância.
  5. Para Configurar grupo de segurançaselecione ou crie um grupo de segurança que permita o tráfego de entrada e saída necessário para sua instância.
  6. Revise a configuração da instância e escolha Lançar para iniciar o processo de criação da instância.
  7. Para Selecione um par de chaves existente ou crie um novo par de chavesescolha um par de chaves existente ou crie um novo.
  8. Escolher Instância de lançamento.
  9. Quando a instância estiver em execução, você poderá se conectar a ela usando o Protocolo de Área de Trabalho Remota (RDP) e a senha do administrador obtida no Obter senha do Home windows

Instalar o Terraform na instância EC2

Instale o Terraform na instância do Home windows EC2 usando as seguintes etapas:

  1. RDP na instância EC2 que você criou.
  2. Instalar Terraform na instância EC2.

Você precisa atualizar as variáveis ​​de ambiente para apontar para o diretório onde o executável do Terraform está disponível.

  1. Sob Propriedades do sistemano Avançado aba, escolha variáveis ​​ambientais.

variáveis ​​ambientais

  1. Escolha a variável de caminho.

Variáveis ​​de caminho

  1. Escolher Novo e insira o caminho onde o Terraform está instalado. Para este publish, está no C: diretório.

Adicionar Terraform à variável de caminho

  1. Confirme se o Terraform está instalado digitando o seguinte comando:

terraform -v

Verifique a versão do Terraform

Opcionalmente, você pode usar um editor como o Visible Studio Code (VS Code) e adicionar a extensão Terraform a ele.

Crie um usuário para acessar a AWS por meio de código (AWS CLI e Terraform)

Em seguida, criamos um usuário administrador no IAM, que realiza as operações na AWS por meio do Terraform e do Interface de linha de comando da AWS (AWS CLI). Conclua as seguintes etapas:

  1. Criar um novo usuário do IAM.
  2. No console do IAM, baixe e salve a chave de acesso e a chave de usuário.

Criar novo usuário IAM

  1. Instalar a AWS CLI.
  2. Inicie a AWS CLI e execute aws configure e passe o ID da chave de acesso, a chave de acesso secreta e a região padrão da AWS.

Isso evita que o nome de usuário e a senha da AWS fiquem visíveis em texto simples no código do Terraform e evita o compartilhamento acidental quando o código é confirmado em um repositório de código.

Configurar AWS

Crie um usuário para acessar o Redshift por meio de código (Terraform)

Como estamos criando um cluster Redshift e operações subsequentes, o nome de usuário e a senha do administrador necessários para esses processos (diferente da função de administrador que criamos anteriormente para efetuar login no Console de gerenciamento da AWS) precisa ser invocado no código. Para fazer isso com segurança, usamos o Secrets and techniques Supervisor para armazenar o nome de usuário e a senha. Escrevemos código no Terraform para acessar essas credenciais durante a operação de criação do cluster. Conclua as seguintes etapas:

  1. No console do Secrets and techniques Supervisor, escolha Segredos no painel de navegação.
  2. Escolher Armazene um novo segredo.

Armazene um novo segredo

  1. Para Tipo secretoselecione Credenciais para o knowledge warehouse do Amazon Redshift.
  2. Insira suas credenciais.

Escolha o tipo secreto

Configurar Terraform

Conclua as seguintes etapas para configurar o Terraform:

  1. Crie uma pasta ou diretório para armazenar todo o seu código do Terraform.
  2. Abra o editor do VS Code e navegue até sua pasta.
  3. Escolher Novo arquivo e digite um nome para o arquivo usando a extensão .tf

Agora estamos prontos para começar a escrever nosso código começando com a definição de provedores. A definição de provedores é uma maneira do Terraform obter as APIs necessárias para interagir com a AWS.

  1. Configurar um provedor para o Terraform:
terraform {
required_providers {
aws = {
supply  = "hashicorp/aws"
model = "5.53.0"
}
}
}

# Configure the AWS Supplier
supplier "aws" {
area = "us-east-1"
}

  1. Acesse as credenciais de administrador do usuário administrador do Amazon Redshift:
knowledge "aws_secretsmanager_secret_version" "creds" {
# Fill within the title you gave to your secret
secret_id = "terraform-creds"
}
/*json decode to parse the key*/
locals {
terraform-creds = jsondecode(
knowledge.aws_secretsmanager_secret_version.creds.secret_string
)
}

Criar um cluster Redshift

Para criar um cluster Redshift, use o aws_redshift_cluster recurso:

# Create an encrypted Amazon Redshift cluster

useful resource "aws_redshift_cluster" "dw_cluster" {
cluster_identifier = "tf-example-redshift-cluster"
database_name      = "dev"
master_username    = native.terraform-creds.username
master_password    = native.terraform-creds.password
node_type          = "ra3.xlplus"
cluster_type       = "multi-node"
publicly_accessible = "false"
number_of_nodes    = 2
encrypted         = true
kms_key_id        = native.RedshiftClusterEncryptionKeySecret.arn
enhanced_vpc_routing = true
cluster_subnet_group_name="<>"
}

Neste exemplo, criamos um cluster Redshift chamado tf-example-redshift-clusterusando o cluster de nó tipo 2 do nó ra3.xlplus. Usamos as credenciais do Secrets and techniques Supervisor e jsondecode para acessar esses valores. Isso garante que o nome de usuário e a senha não sejam passados ​​em texto simples.

Adicionar uma função do IAM ao cluster

Como não tínhamos a opção de associar uma função do IAM durante a criação do cluster, fazemos isso agora com o seguinte código:

useful resource "aws_redshift_cluster_iam_roles" "cluster_iam_role" {
cluster_identifier = aws_redshift_cluster.dw_cluster.cluster_identifier
iam_role_arns      = ("arn:aws:iam::yourawsaccountId:function/service-role/yourIAMrolename")
}

Habilitar operações de cluster Redshift

Executar operações no cluster Redshift, como redimensionar, pausar e retomar em um cronograma, oferece um uso mais prático dessas operações. Portanto, criamos duas políticas: uma que permite o serviço do planejador do Amazon Redshift e uma que permite as operações de pausa, retomada e redimensionamento do cluster. Em seguida, criamos uma função que tem ambas as políticas anexadas a ela.

Você pode executar essas etapas diretamente do console e, em seguida, referenciadas no código do Terraform. O exemplo a seguir demonstra os snippets de código para criar políticas e uma função e, em seguida, anexar a política à função.

  1. Crie o documento de política do agendador do Amazon Redshift e crie a função que assume esta política:
#outline coverage doc to ascertain the Belief Relationship between the function and the entity (Redshift scheduler)

knowledge "aws_iam_policy_document" "assume_role_scheduling" {
assertion {
impact = "Permit"
principals {
kind        = "Service"
identifiers = ("scheduler.redshift.amazonaws.com")
}
actions = ("sts:AssumeRole")
}
}

#create a task that has the above belief relationship hooked up to it, in order that it might probably invoke the redshift scheduling service
useful resource "aws_iam_role" "scheduling_role" {
title               = "redshift_scheduled_action_role"
assume_role_policy = knowledge.aws_iam_policy_document.assume_role_scheduling.json
}

  1. Crie um documento de política e uma política para operações do Amazon Redshift:
/*outline the coverage doc for different redshift operations*/

knowledge "aws_iam_policy_document" "redshift_operations_policy_definition" {
assertion {
impact = "Permit"
actions = (
"redshift:PauseCluster",
"redshift:ResumeCluster",
"redshift:ResizeCluster",
)
assets = ("arn:aws:redshift:*:youraccountid:cluster:*")
}
}

/*create the coverage and add the above knowledge (json) to the coverage*/
useful resource "aws_iam_policy" "scheduling_actions_policy" {
title   = "redshift_scheduled_action_policy"
coverage = knowledge.aws_iam_policy_document.redshift_operations_policy_definition.json
}

  1. Anexe a política à função do IAM:
/*join the coverage and the function*/
useful resource "aws_iam_role_policy_attachment" "role_policy_attach" {
policy_arn = aws_iam_policy.scheduling_actions_policy.arn
function       = aws_iam_role.scheduling_role.title
}

  1. Pausar o cluster Redshift:
#pause a cluster
useful resource "aws_redshift_scheduled_action" "pause_operation" {
title     = "tf-redshift-scheduled-action-pause"
schedule = "cron(00 22 * * ? *)"
iam_role = aws_iam_role.scheduling_role.arn
target_action {
pause_cluster {
cluster_identifier = aws_redshift_cluster.dw_cluster.cluster_identifier
}
}
}

No exemplo anterior, criamos uma ação agendada chamada tf-redshift-scheduled-action-pause que pausa o cluster às 22h todos os dias como uma ação de economia de custos.

  1. Retomar o cluster Redshift:
title     = "tf-redshift-scheduled-action-resume"
schedule = "cron(15 07 * * ? *)"
iam_role = aws_iam_role.scheduling_role.arn
target_action {
resume_cluster {
cluster_identifier = aws_redshift_cluster.dw_cluster.cluster_identifier
}
}
}

No exemplo anterior, criamos uma ação agendada chamada tf-redshift-scheduled-action-resume que retoma o cluster às 7h15 todos os dias, a tempo para que as operações comerciais comecem a usar o cluster Redshift.

  1. Redimensione o cluster Redshift:
#resize a cluster
useful resource "aws_redshift_scheduled_action" "resize_operation" {
title     = "tf-redshift-scheduled-action-resize"
schedule = "cron(15 14 * * ? *)"
iam_role = aws_iam_role.scheduling_role.arn
target_action {
resize_cluster {
cluster_identifier = aws_redshift_cluster.dw_cluster.cluster_identifier
cluster_type = "multi-node"
node_type = "ra3.xlplus"
number_of_nodes = 4 /*improve the variety of nodes utilizing resize operation*/
basic = true /*default conduct is to make use of elastic resizeboolean worth if we wish to use basic resize*/
}
}
}

No exemplo anterior, criamos uma ação agendada chamada tf-redshift-scheduled-action-resize que aumenta os nós de 2 para 4. Você pode fazer outras operações como alterar o tipo de nó também. Por padrão, o redimensionamento elástico será usado, mas se você quiser usar o redimensionamento clássico, você tem que passar o parâmetro basic = true conforme mostrado no código anterior. Esta pode ser uma ação programada para antecipar as necessidades de períodos de pico e redimensionar apropriadamente para essa duração. Você pode então reduzir o tamanho usando código semelhante durante os períodos de menor movimento.

Teste a solução

Aplicamos o seguinte código para testar a solução. Altere os detalhes do recurso de acordo, como ID da conta e nome da região.

terraform {
  required_providers {
    aws = {
      supply  = "hashicorp/aws"
      model = "5.53.0"
    }
  }
}

# Configure the AWS Supplier
supplier "aws" {
  area = "us-east-1"
}

# entry secrets and techniques saved in secret supervisor
knowledge "aws_secretsmanager_secret_version" "creds" {
  # Fill within the title you gave to your secret
  secret_id = "terraform-creds"
}

/*json decode to parse the key*/
locals {
  terraform-creds = jsondecode(
    knowledge.aws_secretsmanager_secret_version.creds.secret_string
  )
}

#Retailer the arn of the KMS key for use for encrypting the redshift cluster

knowledge "aws_secretsmanager_secret_version" "encryptioncreds" {
  secret_id = "RedshiftClusterEncryptionKeySecret"
}
locals {
  RedshiftClusterEncryptionKeySecret = jsondecode(
    knowledge.aws_secretsmanager_secret_version.encryptioncreds.secret_string
  )
}

# Create an encrypted Amazon Redshift cluster
useful resource "aws_redshift_cluster" "dw_cluster" {
  cluster_identifier = "tf-example-redshift-cluster"
  database_name      = "dev"
  master_username    = native.terraform-creds.username
  master_password    = native.terraform-creds.password
  node_type          = "ra3.xlplus"
  cluster_type       = "multi-node"
  publicly_accessible = "false"
  number_of_nodes    = 2
  encrypted         = true
  kms_key_id        = native.RedshiftClusterEncryptionKeySecret.arn
  enhanced_vpc_routing = true
  cluster_subnet_group_name="redshiftclustersubnetgroup-yuu4sywme0bk"
}

#add IAM Function to the Redshift cluster

useful resource "aws_redshift_cluster_iam_roles" "cluster_iam_role" {
  cluster_identifier = aws_redshift_cluster.dw_cluster.cluster_identifier
  iam_role_arns      = ("arn:aws:iam::youraccountid:function/service-role/yourrolename")
}

#for audit logging please create an S3 bucket which has learn write privileges for Redshift service, this instance doesn't embody S3 bucket creation.

useful resource "aws_redshift_logging" "redshiftauditlogging" {
  cluster_identifier   = aws_redshift_cluster.dw_cluster.cluster_identifier
  log_destination_type = "s3"
  bucket_name          = "your-s3-bucket-name"
}

#to do operations like pause, resume, resize on a schedule we have to first create a task that has permissions to carry out these operations on the cluster

#outline coverage doc to ascertain the Belief Relationship between the function and the entity (Redshift scheduler)

knowledge "aws_iam_policy_document" "assume_role_scheduling" {
  assertion {
    impact = "Permit"
    principals {
      kind        = "Service"
      identifiers = ("scheduler.redshift.amazonaws.com")
    }

    actions = ("sts:AssumeRole")
  }
}

#create a task that has the above belief relationship hooked up to it, in order that it might probably invoke the redshift scheduling service
useful resource "aws_iam_role" "scheduling_role" {
  title               = "redshift_scheduled_action_role"
  assume_role_policy = knowledge.aws_iam_policy_document.assume_role_scheduling.json
}

/*outline the coverage doc for different redshift operations*/

knowledge "aws_iam_policy_document" "redshift_operations_policy_definition" {
  assertion {
    impact = "Permit"
    actions = (
      "redshift:PauseCluster",
      "redshift:ResumeCluster",
      "redshift:ResizeCluster",
    )

    assets =  ("arn:aws:redshift:*:youraccountid:cluster:*")
  }
}

/*create the coverage and add the above knowledge (json) to the coverage*/

useful resource "aws_iam_policy" "scheduling_actions_policy" {
  title   = "redshift_scheduled_action_policy"
  coverage = knowledge.aws_iam_policy_document.redshift_operations_policy_definition.json
}

/*join the coverage and the function*/

useful resource "aws_iam_role_policy_attachment" "role_policy_attach" {
  policy_arn = aws_iam_policy.scheduling_actions_policy.arn
  function       = aws_iam_role.scheduling_role.title
}

#pause a cluster

useful resource "aws_redshift_scheduled_action" "pause_operation" {
  title     = "tf-redshift-scheduled-action-pause"
  schedule = "cron(00 14 * * ? *)"
  iam_role = aws_iam_role.scheduling_role.arn
  target_action {
    pause_cluster {
      cluster_identifier = aws_redshift_cluster.dw_cluster.cluster_identifier
    }
  }
}

#resume a cluster

useful resource "aws_redshift_scheduled_action" "resume_operation" {
  title     = "tf-redshift-scheduled-action-resume"
  schedule = "cron(15 14 * * ? *)"
  iam_role = aws_iam_role.scheduling_role.arn
  target_action {
    resume_cluster {
      cluster_identifier = aws_redshift_cluster.dw_cluster.cluster_identifier
    }
  }
}

#resize a cluster

useful resource "aws_redshift_scheduled_action" "resize_operation" {
  title     = "tf-redshift-scheduled-action-resize"
  schedule = "cron(15 14 * * ? *)"
  iam_role = aws_iam_role.scheduling_role.arn
  target_action {
    resize_cluster {
      cluster_identifier = aws_redshift_cluster.dw_cluster.cluster_identifier
      cluster_type = "multi-node"
      node_type = "ra3.xlplus"
      number_of_nodes = 4 /*improve the variety of nodes utilizing resize operation*/
      basic = true /*default conduct is to make use of elastic resizeboolean worth if we wish to use basic resize*/
    }
  }
}

Correr terraform plan para ver uma lista de alterações que serão feitas, conforme mostrado na captura de tela a seguir.

Plano Terraform

Depois de revisar as alterações, use terraform apply para criar os recursos que você definiu.

Aplicar Terraform

Você será solicitado a entrar sure ou no antes que o Terraform comece a criar os recursos.

Confirmação de aplicação

Você pode confirmar que o cluster está sendo criado no console do Amazon Redshift.

criação de cluster redshift

Após a criação do cluster, as funções e programações do IAM para operações de pausa, retomada e redimensionamento são adicionadas, conforme mostrado na captura de tela a seguir.

Ações do Terraform

Você também pode visualizar essas operações agendadas no console do Amazon Redshift.

Ações programadas

Limpar

Se você implantou recursos como o cluster Redshift e as funções do IAM, ou qualquer outro recurso associado executando terraform applypara evitar incorrer em cobranças em sua conta AWS, execute terraform destroy para destruir esses recursos e limpar seu ambiente.

Conclusão

O Terraform oferece uma solução poderosa e flexível para gerenciar sua infraestrutura como código usando uma abordagem declarativa, com uma natureza agnóstica de nuvem, capacidades de orquestração de recursos e forte suporte da comunidade. Esta publicação forneceu um guia abrangente para usar o Terraform para implantar um cluster Redshift e executar operações importantes, como redimensionar, retomar e pausar no cluster. Adotar o IaC e usar as ferramentas certas, como Workflow Studio, VS Code e Terraform, permitirá que você crie aplicativos distribuídos escaláveis ​​e sustentáveis, e automatize processos.


sobre os autores

Amit Ghodke é um Arquiteto de Soluções Especialista em Análise baseado em Austin. Ele trabalhou com bancos de dados, knowledge warehouses e aplicativos analíticos nos últimos 16 anos. Ele adora ajudar os clientes a implementar soluções analíticas em escala para obter o máximo valor comercial.

Ritesh Kumar Sinha é um Arquiteto de Soluções Especialista em Análise baseado em São Francisco. Ele ajudou clientes a construir soluções de knowledge warehousing e huge knowledge escaláveis ​​por mais de 16 anos. Ele adora projetar e construir soluções ponta a ponta eficientes na AWS. Em seu tempo livre, ele adora ler, caminhar e fazer ioga.

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *