Usando Terragrunt para gerenciar vários ambientes

Terraform é uma ferramenta popular de software de infraestrutura como código desenvolvida pela HashiCorp. Você o usa para provisionar todos os tipos de infraestrutura e serviços, incluindo New Relic e alerta.

Terragrunt é um wrapper fino em torno do Terraform que fornece ferramentas extras para:

Reduzindo a repetição
Trabalhando com vários módulos Terraform
Gerenciando estado remoto

Neste guia, você usa o Terragrunt para:

Gere sua configuração do Terraform
Criar arquivos
Gerenciar vários ambientes

Antes de você começar

Para usar este guia, você deve ter algum conhecimento básico do New Relic e do Terraform.

Se você ainda não o fez:

Para seguir os exemplos neste guia, você pode encontrar código de exemplo no GitHub.

Crie uma configuração

Terragrunt fornece ferramentas extras para sua configuração do Terraform. Aqui, você cria uma configuração usando Terragrunt, Terraform e New Relic.

Inicialize um espaço de trabalho:

bash

$mkdir terragrunt-config && cd terragrunt-config

Na sua nova pasta, crie um arquivo terragrunt.hcl :

bash

$touch terragrunt.hcl

A seguir, crie uma pasta de ambientes com uma subpasta chamada dev:

bash

$mkdir -p environments/dev

Em seguida, crie uma pasta src com os arquivos main.tf e provider.tf :

bash

$mkdir src
$touch src/main.tf
$touch src/provider.tf

Você configura recursos do Terraform em main.tf e provedores em provider.tf.

Em src/provider.tf, configurar um provedor New Relic.

terraform {
    required_version = "~> 0.14.3"
    required_providers {
        newrelic = {
            source = "newrelic/newrelic"
            version = "~> 2.14.0"
        }
    }
}

Em src/main.tf, adicione uma política de alertas da New Relic chamada DemoPolicy:

resource "newrelic_alert_policy" "DemoPolicy" {
    name = "My Demo Policy"
}

Em ambientes/dev, crie um arquivo chamado terragrunt.hcl:

bash

$touch environments/dev/terragrunt.hcl

Nele, adicione a seguinte instrução include :

include {
    path = find_in_parent_folders()
}

Isso instrui o Terragrunt a usar qualquer .hcl arquivos de configuração encontrados nas pastas pai.

Adicione um bloco terraform para fornecer ao Terragrunt uma referência de origem:

include {
    path = find_in_parent_folders()
}

terraform {
    source = "../../src"
}

Em src/provider.tf, configure o provedor New Relic com uma chave de API, ID de conta e região:

terraform {
    required_version = "~> 0.14.3"
    required_providers {
        newrelic = {
            source = "newrelic/newrelic"
            version = "~> 2.14.0"
        }
    }
}

variable "newrelic_personal_apikey" {}
variable "newrelic_account_id" {}
variable "newrelic_region" {}

provider "newrelic" {
    account_id = var.newrelic_account_id
    api_key = var.newrelic_personal_apikey
    region = var.newrelic_region
}

Você usa variáveis para manter sua configuração dinâmica.

Em ambientes/dev, inicialize o terragrunt:

bash

$terragrunt init

Isso configura um pouco de contexto, incluindo variáveis de ambiente, e então executa terraform init:

bash

Terraform has created a lock file .terraform.lock.hcl to record the provider
selections it made above. Include this file in your version control repository
so that Terraform can guarantee to make the same selections by default when
you run "terraform init" in the future.
Terraform has been successfully initialized!
You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.
If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.
[terragrunt] [/workspace/terragrunt-config/environments/dev] 2021/02/02 13:30:31 Copying lock file [output] from /workspace/terragrunt-config/environments/dev/.terragrunt-cache/e-PoBgWhdv3v8QGOtDQxS_WeYu4/
69zjIFUfApJiUt8gFmi-6-dcPe8/.terraform.lock.hcl to /workspace/terragrunt-config/environments/dev

Em environments/dev/terragrunt.hcl, adicione um bloco inputs para fornecer valores para as variáveis da sua conta New Relic:

inputs = {
    newrelic_personal_apikey = "NRAK-*<DoNotTranslate>**" # Your New Relic account ID
    newrelic_account_id = "12345" # Your New Relic account ID
    newrelic_region = "US" # US or EU (defaults to US)
}

Agora, execute terragrunt plan:

bash

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
 + create
Terraform will perform the following actions:
 # newrelic_alert_policy.DemoPolicy will be created
 + resource "newrelic_alert_policy" "DemoPolicy" {
   + account_id     = (known after apply)
   + id         = (known after apply)
   + incident_preference = "PER_POLICY"
   + name        = "My Demo Policy"
  }
Plan: 1 to add, 0 to change, 0 to destroy.
------------------------------------------------------------------------
Note: You didn't specify an "-out" parameter to save this plan, so Terraform
can't guarantee that exactly these actions will be performed if
"terraform apply" is subsequently run.

Terragrunt fornece os valores do bloco inputs .

Execute terragrunt apply:

bash

$terragrunt apply

Agora sua Política de Demonstração está em sua conta New Relic.

Adicione à sua configuração

Agora que você criou uma configuração básica do New Relic, adicione as configurações de nossos guias de introdução ao New Relic e aos módulos Terraform e Terraform .

Dica

Se você ainda não seguiu esses guias, pode copiar a configuração do repositório Github de introdução do Terragrunt.

Em src/main.tf, atualize o endereço de e-mail no canal de alerta para o endereço de e-mail de sua preferência:

resource "newrelic_alert_policy" "DemoPolicy" {
    name = "My Demo Policy"
}

resource "newrelic_alert_channel" "DemoChannel" {
    name = "My Demo Channel"
    type = "email"

    config {
        recipients = "your@email_address.com"
        include_json_attachment = "1"
    }
}

resource "newrelic_alert_policy_channel" "ChannelSubs" {
    policy_id = newrelic_alert_policy.DemoPolicy.id
    channel_ids = [
        newrelic_alert_channel.DemoChannel.id
    ]
}

module "HostConditions" {
    source = "git::https://github.com/jsbnr/demo-terraform.git"
    policyId = newrelic_alert_policy.DemoPolicy.id
    cpu_critical = 88
    cpu_warning = 78
    diskPercent = 68
}

Aqui, você adicionou um canal de alerta New Relic, inscreveu a política de demonstração no canal de alerta e adicionou um módulo hospedado no Github.

Execute terragrunt init e depois execute terragrunt apply:

bash

$terragrunt init
$terragrunt apply

Após a conclusão do processamento do Terraform, sua política de alertas terá duas condições e um canal de alerta.

Use seu ambiente como uma variável Terragrunt

Com o Terragrunt, você pode adicionar o nome do ambiente que está executando ao nome dos dados que está criando, tornando seu recurso mais identificável no New Relic.

No arquivo raiz terragrunt.hcl , crie uma entrada para env_name:

inputs = {
    env_name = "develop"
}

No src/main.tf, file adicione uma nova variável chamada env_name:

variable "env_name" {}

Adicione a nova variável env_name à política de alertas e aos blocos de recursos do canal de alerta:

resource "newrelic_alert_policy" "DemoPolicy" {
    name = "${var.env_name}: My Demo Policy"
}

resource "newrelic_alert_channel" "DemoChannel" {
    name = "${env_name}: My Demo Channel"
    type = "email"

    config {
        recipients = "your@email_address.com"
        include_json_attachment = "1"
    }
}

Execute terragrunt plan para ver a variável de ambiente adicionada ao nome da sua política:

bash

# newrelic_alert_policy.DemoPolicy will be updated in-place
~ resource "newrelic_alert_policy" "DemoPolicy" {
   id         = "1216533"
  ~ name        = "My Demo Policy" -> "develop: My Demo Policy"
   # (2 unchanged attributes hidden)
 }
# newrelic_alert_policy_channel.ChannelSubs must be replaced
-/+ resource "newrelic_alert_policy_channel" "ChannelSubs" {
  ~ channel_ids = [
    - 4737437,
   ] -> (known after apply) # forces replacement
  ~ id     = "1216533:4737437" -> (known after apply)
   # (1 unchanged attribute hidden)
 }

Aqui, você codificou o ambiente em terragrunt.hcl. Para tornar isso mais dinâmico, use uma função integrada do terragrunt para obter o ambiente para você.

No arquivo raiz terragrunt.hcl , atualize a entrada para usar path_relative_to_include() e passe o valor como a variável env_name :

inputs = {
    env_name = path_relative_to_include()
}

Execute terragrunt plan:

bash

# newrelic_alert_policy.DemoPolicy will be updated in-place
~ resource "newrelic_alert_policy" "DemoPolicy" {
   id         = "1216533"
  ~ name        = "My Demo Policy" -> "environments/dev: My Demo Policy"
   # (2 unchanged attributes hidden)
 }
# newrelic_alert_policy_channel.ChannelSubs must be replaced
-/+ resource "newrelic_alert_policy_channel" "ChannelSubs" {
  ~ channel_ids = [
    - 4737437,
   ] -> (known after apply) # forces replacement
  ~ id     = "1216533:4737437" -> (known after apply)
   # (1 unchanged attribute hidden)
 }
Plan: 2 to add, 1 to change, 2 to destroy.

Observe que a variável env_name possui todo o caminho ./environments/dev/ . Em vez disso, você deseja incluir apenas a parte “dev”.

Atualize o terragrunt.hcl para remover "environements/" de env_name:

locals {
    env_name = replace(path_relative_to_include(), "environments/", "")
}

inputs = {
    env_name = local.env_name
}

Aqui, você adicionou um bloco locals para criar uma variável local e usou a função replace integrada para remover as partes indesejadas do caminho relativo. Em seguida, você atualizou o bloco inputs para usar a variável local.

Execute terragrunt plan:

bash

 # newrelic_alert_policy.DemoPolicy will be updated in-place
 ~ resource "newrelic_alert_policy" "DemoPolicy" {
    id         = "1216533"
   ~ name        = "My Demo Policy" -> "dev: My Demo Policy"
    # (2 unchanged attributes hidden)
  }
 # newrelic_alert_policy_channel.ChannelSubs must be replaced
-/+ resource "newrelic_alert_policy_channel" "ChannelSubs" {
   ~ channel_ids = [
     - 4737437,
    ] -> (known after apply) # forces replacement
   ~ id     = "1216533:4737437" -> (known after apply)
    # (1 unchanged attribute hidden)
  }
Plan: 2 to add, 1 to change, 2 to destroy.

O nome da sua nova política é "dev: My Demo Policy".

Execute terragrunt apply para atualizar sua configuração:

bash

$terragrunt apply

Mova seu estado para armazenamento remoto

No momento, seu arquivo de estado é local. Agora, você atualiza sua configuração do Terraform para armazená-la no Amazon S3.

Dica

Como o Terragrunt permite configurar vários ambientes, você deve armazenar arquivos de estado em seus próprios buckets S3 para que não se sobrescrevam.

Crie um bucket S3 para seu arquivo de estado de desenvolvimento.

Crie um usuário IAM com permissões para armazenar arquivos em seu bucket.

Na sua raiz terragrunt.hcl, adicione um bloco remote_state que informa ao Terragrunt onde colocar seu arquivo no S3:

remote_state {
    backend = "s3"
    generate = {
        path = "backend.tf"
        if_exists = "overwrite_terragrunt"
    }
    config = {
        bucket = "YOUR_S3_BUCKET_NAME" # Amazon S3 bucket required

        key     = "envs/${local.env_name}/terraform.tfstate"
        region  = "us-east-1"
        encrypt = true
        profile = "YOUR_PROFILE_NAME" # Profile name required
    }
}

Aqui, você definiu uma configuração de estado remoto que especifica um nome de bucket, região, criptografia e perfil. Certifique-se de substituir os valores do espaço reservado por valores reais. Para key, você usou o env_name local criado anteriormente para definir dinamicamente o ambiente para o arquivo de estado. Finalmente, você disse ao Terragrunt para gerar um novo arquivo chamado backend.tf em seu bucket.

Execute terragrunt plan:

bash

$terragrunt plan

No seu bucket, você verá uma pasta chamada envs. Dentro dela há uma pasta chamada devs contendo um arquivo terraform.tfstate .

Dica

Dentro de envs/dev, existe uma pasta oculta chamada terragrunt-cache. Nele está o arquivo backend.tf que o Terragrunt gerou.

Crie um novo ambiente

Agora que você configurou seu ambiente de desenvolvimento, crie outro que reutilize a maior parte do seu trabalho.

Em ambientes, crie uma pasta chamada nonprod. Nele, crie um arquivo chamado terragrunt.hcl:

bash

$mkdir nonprod && cd nonprod
$touch terragrunt.hcl

Em environments/nonprod/terragrunt.hcl, copie a configuração de environments/dev/terragrunt.hcl:

include {
    path= find_in_parent_folders()
}

terraform {
    source = "../../src"
}

inputs = {
    newrelic_personal_apikey = "NRAK-**</DoNotTranslate>*" # Your New Relic account ID
    newrelic_account_id = "12345" # Your New Relic account ID
    newrelic_region = "US" # US or EU (defaults to US)
}

Dica

Se você estiver usando uma conta diferente para seu ambiente que não seja de produção, atualize inputs com um novo ID de conta, chave de API e região.

Dentro de nonprod, execute terragrunt init e terragrunt apply:

bash

$terragrunt init
$terragrunt apply

O Terraform cria um novo conjunto de recursos prefixados com "nonprod:".

Agora, você criou dois ambientes, dev e nonprod, mas eles são iguais, exceto pelo nome.

Em src/main.tf, adicione novas variáveis para o módulo Host Conditions:

variable "cpu_critical" {default = 89}
variable "cpu_warningl" {default = 79}
variable "diskPercentage" {default = 69}

Usar variáveis como essas torna sua configuração mais dinâmica.

Atualize HostConditions para usar as variáveis cpu_critical, cpu_warning e diskPercentage :

module "HostConditions" {
    source = "git::https://github.com/jsbnr/demo-terraform.git"
    policyId = newrelic_alert_policy.DemoPolicy.id
    cpu_critical = var.cpu_critical
    cpu_warning = var.cpu_warninig
    diskPercent = var.dskPercentage
}

Execute terragrunt plan:

bash

$terragrunt plan

Os valores HostConditions agora incluem os padrões de variáveis.

Em nonprod/terragrunt.hcl, adicione valores para suas variáveis:

inputs = {
    newrelic_personal_apikey = "NRAK-***" # Your New Relic account ID
    newrelic_account_id = "12345" # Your New Relic account ID
    newrelic_region = "US" # US or EU (defaults to US)

    cpu_critical = 50
    cpu_warninig = 40
    diskPercentage = 98
}

Isso passa os valores para a configuração do seu ambiente.

Execute terragrunt apply:

bash

$terragrunt apply

Na sua conta New Relic, você tem uma nova política com configuração não específica do produto.

Conclusão

Parabéns! Você usou o Terragrunt para gerar a configuração do New Relic e gerenciar vários ambientes. Revise o exemplo de introdução do Terragrunt, a documentação do provedor New Relic Terraform e o início rápido do Terragrunt para saber como você pode levar sua configuração para o próximo nível.

Esta tradução de máquina é fornecida para sua comodidade.

Usando Terragrunt para gerenciar vários ambientes

Antes de você começar.css-21sua1{background:none;border:none;width:0;padding:0;}

Crie uma configuração

Adicione à sua configuração

Dica

Use seu ambiente como uma variável Terragrunt

Mova seu estado para armazenamento remoto

Dica

Dica

Crie um novo ambiente

Dica

Conclusão

Antes de você começar