Utilisation de Terragrunt pour gérer plusieurs environnements

Terraform est un outil logiciel d'infrastructure en tant que code populaire développé par HashiCorp. Vous l'utilisez pour provisionner toutes sortes d' infrastructure et de services, y compris New Relic et les alertes.

Terragrunt est une fine enveloppe autour de Terraform qui fournit des outils supplémentaires pour :

Réduire la répétition
Travailler avec plusieurs modules Terraform
Gestion de l'état distant

Dans ce guide, vous utilisez Terragrunt pour :

Générez votre configuration Terraform
Créer des fichiers
Gérer plusieurs environnements

Avant de commencer

Pour utiliser ce guide, vous devez avoir des connaissances de base sur New Relic et Terraform.

Si vous ne l'avez pas déjà fait :

Installez l'agent New Relic Infrastructure sur votre hôte
Installer la CLI Terraform
Installer Terragrunt

Pour suivre les exemples de ce guide, vous pouvez trouver un exemple de code sur GitHub.

Créer une configuration

Terragrunt fournit des outils supplémentaires pour votre configuration Terraform. Ici, vous créez une configuration à l'aide de Terragrunt, Terraform et New Relic.

Initialiser un espace de travail :

bash

$mkdir terragrunt-config && cd terragrunt-config

Dans votre nouveau dossier, créez un fichier terragrunt.hcl :

bash

$touch terragrunt.hcl

Ensuite, créez un dossier d’environnements avec un sous-dossier appelé dev:

bash

$mkdir -p environments/dev

Ensuite, créez un dossier src avec les fichiers main.tf et supplier.tf :

bash

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

Vous configurez les ressources Terraform dans main.tf et les fournisseurs dans supplier.tf.

Dans src/provider.tf, configurer un fournisseur New Relic.

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

Dans src/main.tf, ajoutez une règle d'alerte New Relic nommée DemoPolicy:

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

Dans environnements/dev, créez un fichier nommé terragrunt.hcl:

bash

$touch environments/dev/terragrunt.hcl

Ajoutez-y l’instruction include suivante :

include {
    path = find_in_parent_folders()
}

Cela indique à Terragrunt d'utiliser n'importe quel fichier .hcl fichiers de configuration qu'il trouve dans les dossiers parents.

Ajoutez un bloc terraform pour donner à Terragrunt une référence source :

include {
    path = find_in_parent_folders()
}

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

Dans src/provider.tf, configurer le fournisseur New Relic avec une clé API, un ID de compte et une région :

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
}

Vous utilisez des variables pour garder votre configuration dynamique.

Dans les environnements/dev, initialisez terragrunt :

bash

$terragrunt init

Cela définit un peu de contexte, y compris des variables d'environnement, puis exécute 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

Dans les environnements/dev/terragrunt.hcl, ajoutez un bloc inputs pour fournir des valeurs pour vos variables de compte New Relic :

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

Maintenant, exécutez 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 fournit les valeurs du bloc inputs .

Exécutez terragrunt apply:

bash

$terragrunt apply

Votre politique de démonstration est désormais dans votre compte New Relic.

Ajoutez à votre configuration

Maintenant que vous avez créé une configuration New Relic de base, ajoutez la configuration de nos guides de démarrage avec New Relic et Terraform et des modules Terraform .

Conseil

Si vous n'avez pas encore réalisé ces guides, vous pouvez copier leur configuration depuis le référentiel Github d'intro de Terragrunt.

Dans src/main.tf, mettez à jour l'adresse e-mail dans le canal d'alerte avec votre adresse e-mail préférée :

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
}

Ici, vous avez ajouté un canal d’alerte New Relic, abonné la politique de démonstration au canal d’alerte et ajouté un module hébergé sur Github.

Exécutez terragrunt init puis exécutez terragrunt apply:

bash

$terragrunt init
$terragrunt apply

Une fois le traitement terminé par Terraform, votre règle d'alerte comporte deux conditions et un canal d'alerte.

Utilisez votre environnement comme une variable Terragrunt

Avec Terragrunt, vous pouvez ajouter le nom de l'environnement que vous exécutez au nom des données que vous créez, rendant votre ressource plus identifiable dans New Relic.

Dans le fichier racine terragrunt.hcl , créez une entrée pour env_name:

inputs = {
    env_name = "develop"
}

Dans le fichier src/main.tf, fichier ajouter une nouvelle variable appelée env_name:

variable "env_name" {}

Ajoutez la nouvelle variable env_name aux blocs de ressources règle d'alerte et canal d'alerte :

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"
    }
}

Exécutez terragrunt plan pour voir la variable d’environnement ajoutée au nom de votre politique :

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)
 }

Ici, vous avez codé en dur l'environnement dans terragrunt.hcl. Pour rendre cela plus dynamique, utilisez une fonction intégrée de terragrunt pour obtenir l'environnement à votre place.

Dans le fichier racine terragrunt.hcl , mettez à jour l'entrée pour utiliser path_relative_to_include() et transmettez la valeur en tant que variable env_name :

inputs = {
    env_name = path_relative_to_include()
}

Exécutez 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.

Notez que la variable env_name contient l'intégralité du chemin ./environments/dev/ . Au lieu de cela, vous souhaitez inclure uniquement la partie « dev ».

Mettre à jour le fichier terragrunt.hcl pour supprimer « environements/ » de env_name:

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

inputs = {
    env_name = local.env_name
}

Ici, vous avez ajouté un bloc locals pour créer une variable locale et utilisé la fonction replace intégrée pour supprimer les parties indésirables du chemin relatif. Ensuite, vous avez mis à jour le bloc inputs pour utiliser la variable locale.

Exécutez 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.

Le nom de votre nouvelle politique est « dev : Ma politique de démonstration ».

Exécutez terragrunt apply pour mettre à jour votre configuration :

bash

$terragrunt apply

Déplacez votre état vers un stockage distant

Pour le moment, votre fichier d'état est local. Maintenant, vous mettez à jour votre configuration Terraform pour la stocker dans Amazon S3.

Conseil

Étant donné que Terragrunt vous permet de configurer plusieurs environnements, vous devez stocker les fichiers d'état dans leurs propres compartiments S3 afin qu'ils ne s'écrasent pas les uns les autres.

Créez un bucket S3 pour votre fichier d’état de développement.

Créez un utilisateur IAM avec des autorisations pour stocker des fichiers dans votre bucket.

Dans votre racine terragrunt.hcl, ajoutez un bloc remote_state qui indique à Terragrunt où placer votre fichier dans 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
    }
}

Ici, vous avez défini une configuration d’état distant qui spécifie un nom de bucket, une région, un chiffrement et un profil. Assurez-vous de remplacer les valeurs d'espace réservé par des valeurs réelles. Pour key, vous avez utilisé le env_name local que vous avez créé précédemment pour définir dynamiquement l'environnement du fichier d'état. Enfin, vous avez demandé à Terragrunt de générer un nouveau fichier appelé backend.tf dans votre bucket.

Exécutez terragrunt plan:

bash

$terragrunt plan

Dans votre bucket, vous voyez un dossier nommé envs. À l'intérieur se trouve un dossier appelé devs contenant un fichier terraform.tfstate .

Conseil

À l'intérieur envs/dev, il y a un dossier caché nommé terragrunt-cache. Il contient le fichier backend.tf généré par Terragrunt.

Créer un nouvel environnement

Maintenant que vous avez configuré votre environnement de développement, créez-en un autre qui réutilise la plupart de votre travail.

Sous environnements, créez un dossier nommé nonprod. Créez-y un fichier appelé terragrunt.hcl:

bash

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

Dans les environnements/nonprod/terragrunt.hcl, copiez la configuration depuis les environnements/dev/terragrunt.hcl:

include {
    path= find_in_parent_folders()
}

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

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

Conseil

Si vous utilisez un compte différent pour votre environnement non productif, mettez à jour inputs avec un nouvel ID de compte, une nouvelle clé API et une nouvelle région.

Dans nonprod, exécutez terragrunt init et terragrunt apply:

bash

$terragrunt init
$terragrunt apply

Terraform crée un nouvel ensemble de ressources préfixées par « nonprod : ».

Vous avez maintenant créé deux environnements, dev et nonprod, mais ils sont identiques, à part leur nom.

Dans src/main.tf, ajouter de nouvelles variables pour le module Conditions Hôte :

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

L'utilisation de variables comme celles-ci rend votre configuration plus dynamique.

Mettez à jour HostConditions pour utiliser les variables cpu_critical, cpu_warning et 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
}

Exécutez terragrunt plan:

bash

$terragrunt plan

Les valeurs HostConditions incluent désormais les valeurs par défaut des variables.

Dans nonprod/terragrunt.hcl, ajoutez des valeurs pour vos 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
}

Cela transmet les valeurs à la configuration de votre environnement.

Exécutez terragrunt apply:

bash

$terragrunt apply

Dans votre compte New Relic, vous disposez d'une nouvelle politique avec une configuration non spécifique à la production.

Conclusion

Félicitations ! Vous avez utilisé Terragrunt pour générer une configuration New Relic et gérer plusieurs environnements. Consultez l’ exemple d’introduction de Terragrunt, la documentation du fournisseur New Relic Terraform et le démarrage rapide de Terragrunt pour découvrir comment vous pouvez faire passer votre configuration au niveau supérieur.

Cette traduction automatique est fournie pour votre commodité.

Utilisation de Terragrunt pour gérer plusieurs environnements

Avant de commencer.css-21sua1{background:none;border:none;width:0;padding:0;}

Créer une configuration

Ajoutez à votre configuration

Conseil

Utilisez votre environnement comme une variable Terragrunt

Déplacez votre état vers un stockage distant

Conseil

Conseil

Créer un nouvel environnement

Conseil

Conclusion

Avant de commencer