Comment déployer un cluster EKS à l’aide de Terraform

Pourquoi choisir Terraform

L’infrastructure as code (IaC) consiste à gérer et à approvisionner l’infrastructure par le biais du code plutôt que par des processus manuels. Cette méthode présente divers avantages, dont :

• une infrastructure reproductible et évolutive ;
• des temps de déploiement plus courts ;
• des coûts réduits.

Il existe aujourd’hui plusieurs outils de gestion des configurations et d’IaC. Chaque outil a ses avantages et ses inconvénients.

Même s’il ne fait pas exception à cette règle, Terraform gagne en popularité auprès des professionnels de l’infrastructure, des développeurs, et dans différents corps de métier de l’ingénierie logicielle. Les points forts de Terraform sont les suivants :

• Il fonctionne sur toutes les plateformes ;
• il est lisible par l’homme et ne nécessite pas de compétences avancées ;
• il s’agit d’un logiciel libre, ce qui signifie que les ingénieurs peuvent créer leurs propres fournisseurs Terraform pour des fonctionnalités spécifiques ; et
• il existe une version gratuite – Terraform – et une version d’entreprise – Terraform Cloud – sans perte de fonctionnalité entre les deux versions.

Déployer un cluster EKS avec Terraform

Avant de commencer à créer, vous aurez besoin :

• d’un compte AWS ;
• des informations d’identification et de gestion des accès (IAM) et un accès programmatique ;
• des informations d’identification AWS configurées localement avec aws configure ;
• d’un VPC configuré pour EKS ; et
• un éditeur de code ou de texte, comme VS Code.

Les étapes suivantes montrent comment configurer le fichier main.tf pour créer un cluster EKS et les fichiers variables afin de garantir la reproductibilité du cluster dans n’importe quel environnement.

Créer le fichier main.tf

Pour les besoins de cette procédure, nous utilisons VS Code. Cependant, n’importe quel éditeur de texte peut être utilisé.

Étape 1. Ouvrez votre éditeur de texte et créez un nouveau répertoire. Créez un nouveau fichier appelé main.tf. Lorsque vous configurez le fichier main.tf, utilisez et créez les éléments suivants :

• le fournisseur AWS Terraform ;
• un nouveau rôle IAM pour EKS ;
• la stratégie EKS pour le rôle IAM ; et
• le cluster EKS lui-même, dont les nœuds de travail.

Étape 2. Dans le fichier main.tf, ajoutez le code du fournisseur. Cela vous permettra d’utiliser le fournisseur AWS.

terraform {
 required_providers {
  aws = {
   source = "hashicorp/aws"
  }
 }
}

Étape 3. Configurez la première ressource pour le rôle IAM. Cela garantit que le rôle a accès à l’EKS.

resource "aws_iam_role" "eks-iam-role" {
 name = "devopsthehardway-eks-iam-role"

 path = "/"

 assume_role_policy = <<EOF
{
 "Version" : "2012-10-17",
 "Statement" : [
  {
   "Effect" : "Allow",
   "Principal" : {
    "Service" : "eks.amazonaws.com"
   },
   "Action": "sts:AssumeRole"
  }
 ]
}
EOF

}

Étape 4. Une fois le rôle créé, attachez-lui ces deux politiques :

• AmazonEKSClusterPolicy
• AmazonEC2ContainerRegistryReadOnly-EKS

Ces deux politiques vous permettent d’accéder correctement aux instances EC2 (où s’exécutent les nœuds de travail) et à EKS.

resource "aws_iam_role_policy_attachment" "AmazonEKSClusterPolicy" {
 policy_arn = "arn:aws:iam::aws:policy/AmazonEKSClusterPolicy"
 role    = aws_iam_role.eks-iam-role.name
}
resource "aws_iam_role_policy_attachment" "AmazonEC2ContainerRegistryReadOnly-EKS" {
 policy_arn = "arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly"
 role    = aws_iam_role.eks-iam-role.name
}

Étape 5. Une fois les stratégies attachées, créez le cluster EKS.

resource "aws_eks_cluster" "devopsthehardway-eks" {
 name = "devopsthehardway-cluster"
 role_arn = aws_iam_role.eks-iam-role.arn

 vpc_config {
  subnet_ids = [var.subnet_id_1, var.subnet_id_2]
 }

 depends_on = [
  aws_iam_role.eks-iam-role,
 ]
}

Étape 6. Configurez un rôle IAM pour les nœuds de travail. Le processus est similaire à la création du rôle IAM pour le cluster EKS. Cette fois-ci, les politiques que vous attacherez seront celles du nœud de travail EKS. Les politiques en question sont :

• AmazonEKSWorkerNodePolicy
• AmazonEKS_CNI_Policy
• EC2InstanceProfileForImageBuilderECRContainerBuilds
• AmazonEC2ContainerRegistryReadOnly

resource "aws_iam_role" "workernodes" {
  name = "eks-node-group-example"
 
  assume_role_policy = jsonencode({
   Statement = [{
    Action = "sts:AssumeRole"
    Effect = "Allow"
    Principal = {
     Service = "ec2.amazonaws.com"
    }
   }]
   Version = "2012-10-17"
  })
 }
 
 resource "aws_iam_role_policy_attachment" "AmazonEKSWorkerNodePolicy" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy"
  role    = aws_iam_role.workernodes.name
 }
 
 resource "aws_iam_role_policy_attachment" "AmazonEKS_CNI_Policy" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonEKS_CNI_Policy"
  role    = aws_iam_role.workernodes.name
 }
 
 resource "aws_iam_role_policy_attachment" "EC2InstanceProfileForImageBuilderECRContainerBuilds" {
  policy_arn = "arn:aws:iam::aws:policy/EC2InstanceProfileForImageBuilderECRContainerBuilds"
  role    = aws_iam_role.workernodes.name
 }
 
 resource "aws_iam_role_policy_attachment" "AmazonEC2ContainerRegistryReadOnly" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly"
  role    = aws_iam_role.workernodes.name
 }

Étape 7. La dernière portion de code sert à créer les nœuds de travail. À des fins de test, utilisez un seul nœud de travail dans la configuration scaling_config. En production, suivez les meilleures pratiques et utilisez au moins trois nœuds de travail.

 resource "aws_eks_node_group" "worker-node-group" {
  cluster_name  = aws_eks_cluster.devopsthehardway-eks.name
  node_group_name = "devopsthehardway-workernodes"
  node_role_arn  = aws_iam_role.workernodes.arn
  subnet_ids   = [var.subnet_id_1, var.subnet_id_2]
  instance_types = ["t3.xlarge"]
 
  scaling_config {
   desired_size = 1
   max_size   = 1
   min_size   = 1
  }
 
  depends_on = [
   aws_iam_role_policy_attachment.AmazonEKSWorkerNodePolicy,
   aws_iam_role_policy_attachment.AmazonEKS_CNI_Policy,
   #aws_iam_role_policy_attachment.AmazonEC2ContainerRegistryReadOnly,
  ]
 }

  ]
 }

Créer le fichier variables.tf

Une fois le fichier main.tf créé, il est temps de configurer les variables. Les variables vous permettent de transmettre des valeurs et de rendre votre code répétable. Vous pouvez utiliser ce code pour n’importe quel environnement EKS.

Première étape. Créez un nouveau fichier appelé variables.tf. Lorsque vous configurez le fichier variables.tf, vous devez créer les deux variables suivantes :

• Subnet_id_1
• Subnet_id_2

Les deux ID de sous-réseau peuvent être utilisés à partir du VPC que vous avez créé via CloudFormation dans la section des conditions préalables. Vous pouvez utiliser un sous-réseau public et un sous-réseau privé à des fins de développement.

Étape 2. Dans le fichier variables.tf, créez les variables suivantes :

 variable "subnet_id_1" {
  type = string
  default = "subnet-your_first_subnet_id"
 }
 
 variable "subnet_id_2" {
  type = string
  default = "subnet-your_second_subnet_id"
 }

Créer l’environnement EKS

Pour créer l’environnement, assurez-vous que vous êtes dans le répertoire et le module Terraform que vous avez utilisés pour écrire le mode Terraform. Exécutez les commandes suivantes :

• terraform init. Initialise l’environnement et récupère le fournisseur AWS.
• terraform plan. Planifie l’environnement et s’assure de l’absence de bug.
• terraform apply --auto-approve. Créez l’environnement avec la commande apply, combinée avec auto-approve, pour éviter les invites.

Lorsque vous êtes prêt à détruire tous les environnements Terraform, assurez-vous que vous êtes dans le module/répertoire Terraform que vous avez utilisé, pour créer le cluster EKS. Exécutez ensuite la commande terraform destroy.