nous utilisons Terraform lourdement et notre configuration recommandée est la suivante:

Fichier de mise en page

nous vous recommandons fortement de stocker le code Terraform pour chacun de vos environnements (par exemple stage, prod, qa) dans des ensembles séparés de gabarits (et donc des fichiers séparés .tfstate ). C'est important pour que vos environnements séparés soient réellement isolés les uns des autres tout en apportant des changements. Autrement, tout en jouant avec un peu de code dans la mise en scène, c'est trop facile de faire exploser quelque chose dans prod aussi. Voir Terraform, VPC, et pourquoi vous voulez un fichier tfstate par env pour une discussion colorée de pourquoi.

par conséquent, notre disposition de fichier typique ressemble à ceci:

stage
  └ main.tf
  └ vars.tf
  └ outputs.tf
prod
  └ main.tf
  └ vars.tf
  └ outputs.tf
global
  └ main.tf
  └ vars.tf
  └ outputs.tf

tout le code Terraform pour la CPV de l'étape va dans le dossier stage , tout le code pour la CPV prod va dans le dossier prod , et tout le code qui vit en dehors d'une CPV (par ex. IAM users, SNS topics, S3 buckets) va dans le dossier global .

notez que, par convention, nous divisons Généralement notre code Terraform en 3 fichiers:

• vars.tf : variables D'entrée.
• outputs.tf : variables de sortie.
• main.tf : les ressources réelles.

Modules

typiquement, nous définissons notre infrastructure En deux dossiers:

1. infrastructure-modules : ce dossier contient de petits modules réutilisables suivis en versions. Pensez à chaque module comme un plan directeur pour la création d'un seul élément d'infrastructure, comme une VPC ou une base de données.
2. infrastructure-live : ce dossier contient l'infrastructure réelle en cours d'exécution, qu'il crée en combinant les modules dans infrastructure-modules . Pensez au code dans ce dossier comme les maisons que vous avez construites à partir de vos plans.

a module Terraform est juste n'importe quel ensemble de gabarits Terraform dans un dossier. Par exemple, nous pourrions avoir un dossier appelé vpc dans infrastructure-modules qui définit toutes les tables de routes, sous-réseaux, passerelles, ACLs, etc pour un seul VPC:

infrastructure-modules
  └ vpc
    └ main.tf
    └ vars.tf
    └ outputs.tf

nous pouvons alors utiliser ce module dans infrastructure-live/stage et infrastructure-live/prod pour créer la scène et prod VPCs. Pour exemple, voici ce que infrastructure-live/stage/main.tf pourrait ressembler à:

module "stage_vpc" {
  source = "git::git@github.com:gruntwork-io/module-vpc.git//modules/vpc-app?ref=v0.0.4"

  vpc_name = "stage"
  aws_region = "us-east-1"
  num_nat_gateways = 3
  cidr_block = "10.2.0.0/18"
}

pour utiliser un module, vous utilisez la ressource module et pointez son champ source vers un chemin local sur votre disque dur (par exemple source = "../infrastructure-modules/vpc" ) ou, comme dans l'exemple ci-dessus, une URL Git (voir module sources ). L'avantage de L'URL Git est que nous pouvons spécifier un git sha1 ou une balise ( ref=v0.0.4 ). Maintenant, non seulement nous définir notre infrastructure comme un tas de petits modules, mais nous pouvons modifiez ces modules et mettez-les à jour ou faites-les reculer au besoin.

nous avons créé un certain nombre de paquets D'Infrastructure réutilisables, testés et documentés" 1519710920 pour créer des VPC, des clusters de dockers, des bases de données, et ainsi de suite, et sous le capot, la plupart d'entre eux ne sont que des modules terraformés suivis en versions.

État

lorsque vous utilisez Terraform pour créer des ressources (par exemple EC2 instances, bases de données, VPCs), il enregistre information sur ce qu'il a créé dans un fichier .tfstate . Pour apporter des changements à ces ressources, tout le monde dans votre équipe a besoin d'accéder à ce même fichier .tfstate , mais vous ne devriez pas le vérifier dans Git (voir ici pour une explication pourquoi ).

au lieu de cela, nous vous recommandons de stocker les fichiers .tfstate dans S3 en activant État à distance Terraform , qui poussera/tirera automatiquement les derniers fichiers à chaque fois que vous exécutez Terraform. Faire sûr de activer la versioning dans votre seau S3 de sorte que vous pouvez retourner aux fichiers plus anciens .tfstate au cas où vous quelque peu corrompre la dernière version. Cependant, une note importante: Terraform ne fournit pas de verrouillage . Ainsi, si deux membres de l'équipe exécutent terraform apply en même temps sur le même fichier .tfstate , ils peuvent finir par s'écraser mutuellement.

Pour résoudre ce problème, nous avons créé un outil open source appelé Terragrunt , qui est un emballage mince pour Terraform qui utilise Amazon DynamoDB pour fournir le verrouillage (qui devrait être complètement libre pour la plupart des équipes). Cliquez sur ajoutez le verrouillage Automatique À Distance et la Configuration à Terraform avec Terragrunt pour plus d'informations.

Lire la suite

nous venons de commencer une série de billets de blog appelé un guide complet pour Terraform que décrit en détail toutes les meilleures pratiques que nous avons apprises pour utiliser Terraform dans le monde réel.

mise à Jour: le Guide Complet pour transformer le terrain après le blog de la série a tellement de succès que nous avons développé dans un livre intitulé Terraform: Up & Running !

avec remote config , ceci est devenu beaucoup plus simple:

terraform remote config -backend-config="bucket=<s3_bucket_to_store_tfstate>" -backend-config="key=terraform.tfstate" -backend=s3
terraform remote pull
terraform apply
terraform remote push

voir le docs pour plus de détails.

couvert plus en détail par @Yevgeny Brikman mais répondant spécifiquement aux questions de L'OP:

What's the best practice for actually managing the terraform files and state?

utilisez git pour les fichiers TF. Mais ne Vérifiez pas les fichiers de l'État dans (c.-à-d. tfstate). Utilisez plutôt Terragrunt pour la synchronisation / verrouillage des fichiers d'état vers S3.

but do I commit tfstate as well? 

Pas de.

Should that reside somewhere like S3?

Oui

je sais qu'il y a beaucoup de réponses ici, mais mon approche est assez différente.

⁃   Modules
⁃   Environment management 
⁃   Separation of duties

Modules

1. créer des modules pour les collections logiques de ressources. Exemple: si votre objectif est de déployer une API, qui nécessite un DB, un VMS HA, un autoscaling, un DNS, un PubSub et un stockage objet, alors toutes ces ressources doivent être rassemblées dans un seul module.
2. éviter de créer des modules qui utiliser une seule ressource. Cela peut être fait et cela a déjà été fait, et bon nombre des modules du registre le font, mais c'est une pratique qui aide à l'accessibilité des ressources plutôt qu'à l'orchestration de l'infrastructure. Exemple: un module pour AWS EC2 aide l'utilisateur à accéder à EC2 en rendant les configurations complexes plus simples à invoquer mais un module comme l'exemple en 1. aide l'utilisateur lors de l'orchestration d'une application, d'un composant ou d'une infrastructure axée sur le service.
   3. éviter la ressource déclarations dans votre espace de travail. Il s'agit plutôt de garder votre code bien rangé et organisé. Comme les modules sont facilement versionés, vous avez plus de contrôle sur vos versions.

gestion de l'environnement

IaC a rendu le processus SDLC pertinent pour la gestion de l'infrastructure et il n'est pas normal de s'attendre à avoir une infrastructure de développement ainsi que des environnements d'applications de développement.

1. N'utilisez pas de dossiers pour gérer vos environnements IaC. Cela conduit à dériver car il n'y a pas de modèle commun pour votre infrastructure.
2. utilise un seul espace de travail et des variables pour contrôler les spécifications de l'environnement. Exemple: écrivez vos modules de façon à ce que lorsque vous changez la variable d'environnement (var.la scène est populaire) le plan change pour s'adapter à vos besoins. Généralement, les environnements devraient varier le moins possible avec la quantité, l'exposition et la capacité étant généralement les configurations variables. Dev peut déployer 1 VM avec 1 core et 1 Go de RAM en topologie privée, mais la production peut être de 3 VM avec 2 core et 4 Go de RAM avec une topologie publique supplémentaire. Vous pouvez bien sûr avoir plus de variation: dev peut exécuter le processus de base de données sur le même serveur que l'application pour économiser des coûts, mais la production peut avoir une instance DB dédiée. Tout cela peut être géré en changeant une seule variable, les déclarations ternaires et l'interpolation.

" séparation des fonctions

si vous êtes dans une petite organisation ou si vous exploitez une infrastructure personnelle, cela ne s'applique pas vraiment, mais cela vous aidera à gérer vos opérations.

1. répartissez votre infrastructure par tâches, responsabilités ou équipes. Exemple: contrôle central des TI sous-jacents aux services partagés (réseaux virtuels, sous-réseaux, adresses IP publiques, groupes de logs, ressources de gouvernance, locataires DBs, clés, etc.) tandis que L'équipe API ne contrôle que les ressources nécessaires à leur service (VMs, LBs, PubSub, etc.) et consomme ses Services centraux par le biais de sources de données et de recherches À Distance.
   2. Gouverner l'équipe d'accès. Exemple: L'IT Central peut avoir des droits admin mais L'équipe API n'a accès qu'à un ensemble restreint d'API de cloud public.

cela aide aussi avec les préoccupations de libération que vous trouverez quelques ressources changent rarement, tandis que d'autres changent tout le temps. La séparation élimine le risque et la complexité.

cette stratégie établit des parallèles avec la stratégie multi-comptes D'AWS. À lire pour plus d'info.

CI / CD

C'est un sujet à part, mais Terraform fonctionne très bien dans un bon pipeline. L'erreur la plus courante ici est de traiter L'IC comme une balle en argent. Sur le plan technique, Terraform ne devrait être Infrastructure d'approvisionnement pendant les étapes d'un pipeline d'assemblage. Cela serait distinct de ce qui se produit aux étapes de L'assurance-récolte, où l'on valide et teste habituellement les modèles.

N.B. écrit sur mobile veuillez excuser toute erreur.