Uso de Terragrunt para gestionar múltiples entornos

Terraform es una popular herramienta de software de infraestructura como código creada por HashiCorp. Se utiliza para aprovisionar todo tipo de infraestructura y servicios, incluidos New Relic y alerta.

Terragrunt es una envoltura delgada de Terraform que proporciona herramientas adicionales para:

Reducir la repetición
Trabajar con múltiples módulos Terraform
Gestión del estado remoto

En esta guía, utilizarás Terragrunt para:

Genera tu configuración de Terraform
Crear archivos
Gestionar múltiples entornos

Antes de que empieces

Para utilizar esta guía, debe tener algunos conocimientos básicos tanto de New Relic como de Terraform.

Si aún no lo has hecho:

Para seguir los ejemplos de esta guía, puede encontrar código de ejemplo en GitHub.

Crear una configuración

Terragrunt proporciona herramientas adicionales para su configuración de Terraform. Aquí, crea una configuración usando Terragrunt, Terraform y New Relic.

Inicializar un espacio de trabajo:

bash

$mkdir terragrunt-config && cd terragrunt-config

En su nueva carpeta, cree un archivo terragrunt.hcl :

bash

$touch terragrunt.hcl

A continuación, cree una carpeta de entornos con una subcarpeta llamada dev:

bash

$mkdir -p environments/dev

Luego, cree una carpeta src con los archivos main.tf y provider.tf :

bash

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

Los recursos de Terraform se configuran en main.tf y los proveedores en provider.tf.

En src/provider.tf, configurar un proveedor de New Relic.

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

En src/main.tf, agregue una política de alertas New Relic llamada DemoPolicy:

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

En entornos/dev, cree un archivo llamado terragrunt.hcl:

bash

$touch environments/dev/terragrunt.hcl

En él, agregue la siguiente declaración include :

include {
    path = find_in_parent_folders()
}

Esto le indica a Terragrunt que use cualquier .hcl archivos de configuración que encuentra en las carpetas principales.

Agregue un bloque terraform para darle a Terragrunt una referencia de fuente:

include {
    path = find_in_parent_folders()
}

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

En src/provider.tf, configure el proveedor New Relic con una clave de API, ID de cuenta y región:

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
}

Utiliza variables para mantener su configuración dinámica.

En entornos/dev, inicializa terragrunt:

bash

$terragrunt init

Esto configura un poco de contexto, incluidas las variables de entorno, luego ejecuta 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

En environments/dev/terragrunt.hcl, agregue un bloque inputs para proporcionar valores para las variables de su cuenta 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)
}

Ahora, ejecuta 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 proporciona los valores del bloque inputs .

Ejecute terragrunt apply:

bash

$terragrunt apply

Ahora su Política de demostración está en su cuenta New Relic.

Añadir a tu configuración

Ahora que ha creado una configuración básica de New Relic, agregue las configuraciones de nuestras guías de Introducción a New Relic y Terraform y los módulos Terraform .

Sugerencia

Si aún no ha realizado estas guías, puede copiar su configuración desde el repositorio de introducción de Terragrunt en Github.

En src/main.tf, actualice la dirección de correo electrónico en el canal de alerta a su dirección de correo electrónico preferida:

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
}

Aquí, agregó un canal de alerta New Relic, suscribió la política de demostración al canal de alerta y agregó un módulo alojado en Github.

Ejecute terragrunt init y luego ejecute terragrunt apply:

bash

$terragrunt init
$terragrunt apply

Una vez que Terraform termina de procesarse, su política de alertas tiene dos condiciones y un canal de alerta.

Utilice su entorno como una variable Terragrunt

Con Terragrunt, puedes agregar el nombre del entorno que estás ejecutando al nombre de los datos que estás creando, haciendo que tu recurso sea más identificable en New Relic.

En el archivo raíz terragrunt.hcl , cree una entrada para env_name:

inputs = {
    env_name = "develop"
}

En src/main.tf, archivo agrega una nueva variable llamada env_name:

variable "env_name" {}

Agregue la nueva variable env_name a los bloques de recursos de política de alertas y 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"
    }
}

Ejecute terragrunt plan para ver la variable de entorno agregada al nombre de su 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)
 }

Aquí, codificaste el entorno en terragrunt.hcl. Para hacer esto más dinámico, use una función incorporada de Terragrunt para crear el entorno para usted.

En el archivo raíz terragrunt.hcl , actualice la entrada para usar path_relative_to_include() y pase el valor como la variable env_name :

inputs = {
    env_name = path_relative_to_include()
}

Ejecute 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.

Tenga en cuenta que la variable env_name tiene la ruta ./environments/dev/ completa. En su lugar, desea incluir sólo la parte "dev".

Actualice terragrunt.hcl para eliminar "entornos/" de env_name:

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

inputs = {
    env_name = local.env_name
}

Aquí, agregó un bloque locals para crear una variable local y utilizó la función incorporada replace para eliminar las partes no deseadas de la ruta relativa. Luego, actualizó el bloque inputs para usar la variable local.

Ejecute 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.

El nombre de su nueva política es "dev: Mi política de demostración".

Ejecute terragrunt apply para actualizar su configuración:

bash

$terragrunt apply

Mueva su estado al almacenamiento remoto

Por el momento, su expediente estatal es local. Ahora, actualiza su configuración de Terraform para almacenarla en Amazon S3.

Sugerencia

Dado que Terragrunt le permite configurar múltiples entornos, debe almacenar los archivos de estado en sus propios depósitos S3 para que no se sobrescriban entre sí.

Cree un depósito S3 para su archivo de estado de desarrollo.

Cree un usuario de IAM con permisos para almacenar archivos en su depósito.

En tu raíz terragrunt.hcl, agregue un bloque remote_state que le indique a Terragrunt dónde colocar su archivo en 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
    }
}

Aquí, definió una configuración de estado remoto que especifica un nombre de depósito, una región, un cifrado y un perfil. Asegúrese de reemplazar los valores del marcador de posición por valores reales. Para key, utilizó el env_name local que creó anteriormente para configurar dinámicamente el entorno para el archivo de estado. Finalmente, le dijiste a Terragrunt que generara un nuevo archivo llamado backend.tf en tu depósito.

Ejecute terragrunt plan:

bash

$terragrunt plan

En su depósito, ve una carpeta llamada envs. Dentro hay una carpeta llamada devs que contiene un archivo terraform.tfstate .

Sugerencia

Dentro de envs/dev, hay una carpeta oculta llamada terragrunt-cache. En él, está el archivo backend.tf que generó Terragrunt.

Crear un nuevo entorno

Ahora que ha configurado su entorno de desarrollo, cree otro que reutilice la mayor parte de su trabajo.

En entornos, cree una carpeta denominada nonprod. En él, crea un archivo llamado terragrunt.hcl:

bash

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

En environments/nonprod/terragrunt.hcl, copie la configuración 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)
}

Sugerencia

Si está utilizando una cuenta diferente para su entorno no de producción, actualice inputs con un nuevo ID de cuenta, clave de API y región.

Dentro de nonprod, ejecute terragrunt init y terragrunt apply:

bash

$terragrunt init
$terragrunt apply

Terraform crea un nuevo conjunto de recursos con el prefijo "nonprod:".

Ahora, ha creado dos entornos, dev y nonprod, pero son iguales, excepto por su nombre.

En src/main.tf, agregue nuevas variables para el módulo Condiciones del host:

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

El uso de variables como estas hace que tu configuración sea más dinámica.

Actualice HostConditions para usar las variables cpu_critical, cpu_warning y 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
}

Ejecute terragrunt plan:

bash

$terragrunt plan

Los valores HostConditions ahora incluyen los valores predeterminados de las variables.

En nonprod/terragrunt.hcl, agregue valores para sus variables:

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
}

Esto pasa los valores a la configuración de su entorno.

Ejecute terragrunt apply:

bash

$terragrunt apply

En su cuenta New Relic, tiene una nueva política con una configuración no específica de producto.

Conclusión

¡Felicidades! Ha utilizado Terragrunt para generar la configuración de New Relic y administrar múltiples entornos. Revise el ejemplo de introducción de Terragrunt, la documentación del proveedor New Relic Terraform y el inicio rápido de Terragrunt para aprender cómo puede llevar su configuración al siguiente nivel.

Te ofrecemos esta traducción automática para facilitar la lectura.

Uso de Terragrunt para gestionar múltiples entornos

Antes de que empieces.css-21sua1{background:none;border:none;width:0;padding:0;}

Crear una configuración

Añadir a tu configuración

Sugerencia

Utilice su entorno como una variable Terragrunt

Mueva su estado al almacenamiento remoto

Sugerencia

Sugerencia

Crear un nuevo entorno

Sugerencia

Conclusión

Antes de que empieces