Exploitation du module Terraform EKS pour créer un cluster EKS

Tutoriels
Terraform

Si vous devez configurer le cluster AWS Elastic Kubernetes Service (Amazon EKS) avec Terraform, vous avez de la chance. En utilisant le module EKS Terraform et toutes les autres ressources nécessaires, vous pouvez créer une configuration Terraform et créer un cluster AKS avec du code.

Amazon EKS est un service géré pour exécuter Kubernetes sur AWS sans installer, exploiter et maintenir votre propre cluster Kubernetes. Construire un cluster EKS avec Terraform vous permet de créer des ressources rapidement, efficacement et de manière automatisée.

Dans ce tutoriel, vous apprendrez comment construire et exécuter une configuration Terraform pour construire un cluster EKS avec Terraform étape par étape. Commençons!

Prérequis

Cet article sera un tutoriel pas à pas. Si vous souhaitez suivre, assurez-vous d’avoir les éléments suivants en place:

  • Un compte Amazon Web Service (AWS).
  • A code editor – Even though you can use any text editor to work with Terraform configuration files, you should consider Visual Studio (VS) Code as it understands the HCL Terraform language well.
  • Terraform – Ce tutoriel utilisera Terraform v0.14.9 fonctionnant sur Ubuntu 18.04.5 LTS, mais tout système d’exploitation avec Terraform devrait fonctionner.

Connexe:Comment installer Terraform sur Windows

Construction de la configuration Terraform pour un cluster AWS EKS

Terraform est un outil d’infrastructure en tant que code qui vous permet de construire, modifier et versionner l’infrastructure de manière sûre et efficace. Terraform utilise différents types de fichiers de configuration. Chaque fichier est écrit soit en format texte brut (.tf) ou en format JSON (.tfjson).

Commençons d’abord par créer une configuration Terraform qui créera un cluster AKS à partir de zéro lorsqu’elle sera appliquée.

1. Ouvrez un terminal.

2. Créez un dossier nommé ~/terraform-eks-cluster-demo, puis changez (cd) le répertoire de travail vers ce dossier. Ce dossier contiendra tous les fichiers de configuration avec lesquels vous travaillerez. 

mkdir ~/terraform-eks-cluster-demo
cd ~/terraform-eks-cluster-demo

3. Ensuite, ouvrez votre éditeur de code favori et copiez/collez la configuration suivante, et enregistrez-la dans un fichier main.tf à l’intérieur de ~/terraform-eks-cluster-demo. Ce fichier main.tf est la configuration Terraform pour le cluster AKS.

Le fichier main.tf contient toutes les ressources nécessaires pour provisionner un cluster EKS:

  • Un rôle AWS Identity and Access Management (IAM) (terraformekscluster) – Cette ressource sera gérée par Amazon EKS et effectuera des appels à d’autres services AWS tels que AWS S3, CloudWatch, etc., en votre nom pour gérer les ressources que vous utilisez avec le service.
  • Un groupe de sécurité AWS EC2 (resource "aws_security_group" "eks-cluster") – Permet le trafic réseau entrant et sortant depuis le cluster AWS EKS. Vous lancerez un groupe de sécurité nommé SG-eks-cluster attaché via un ID VPC, permettant à tout le trafic de circuler entrant/sortant du cluster. 0.0.0.0/0 est l’adresse IP d’Internet.
  • Cluster EKS (terraformEKScluster) – Ce cluster EKS sera en version 1.19.
  • Un rôle IAM pour les nœuds EKS pour effectuer des appels à d’autres services AWS (eks-node-group). Ce rôle est attaché à une stratégie qui permet de supposer les informations d’identification de sécurité temporaires sur l’instance pour accéder à d’autres ressources AWS.
  • Groupe de nœuds de cluster EKS (node_group1) – Cette ressource définit le nombre de nœuds qu’un cluster aura via l’attribut scaling_config.
# Création du rôle IAM pour les clusters Kubernetes afin d'effectuer des appels à d'autres services AWS en votre nom pour gérer les ressources que vous utilisez avec le service.

resource "aws_iam_role" "iam-role-eks-cluster" {
  name = "terraformekscluster"
  assume_role_policy = <<POLICY
{
 "Version": "2012-10-17",
 "Statement": [
   {
   "Effect": "Allow",
   "Principal": {
    "Service": "eks.amazonaws.com"
   },
   "Action": "sts:AssumeRole"
   }
  ]
 }
POLICY
}

# Attachement des politiques EKS-Cluster au rôle terraformekscluster.

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


# Groupe de sécurité pour le trafic réseau vers et depuis le cluster AWS EKS.

resource "aws_security_group" "eks-cluster" {
  name        = "SG-eks-cluster"
  vpc_id      = "vpc-123456789"  

# Egress permet le trafic sortant du cluster EKS vers Internet

  egress {                   # Règle sortante
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
# Ingress permet le trafic entrant vers le cluster EKS depuis Internet

  ingress {                  # Règle entrante
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

}

# Création du cluster EKS

resource "aws_eks_cluster" "eks_cluster" {
  name     = "terraformEKScluster"
  role_arn =  "${aws_iam_role.iam-role-eks-cluster.arn}"
  version  = "1.19"

# Ajout de la configuration VPC

  vpc_config {             # Configuration d'EKS avec les paramètres VPC et réseau
   security_group_ids = ["${aws_security_group.eks-cluster.id}"]
   subnet_ids         = ["subnet-1312586","subnet-8126352"] 
    }

  depends_on = [
    "aws_iam_role_policy_attachment.eks-cluster-AmazonEKSClusterPolicy",
    "aws_iam_role_policy_attachment.eks-cluster-AmazonEKSServicePolicy",
   ]
}

# Création du rôle IAM pour les nœuds EKS pour travailler avec d'autres services AWS.


resource "aws_iam_role" "eks_nodes" {
  name = "eks-node-group"

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

# Attachement des différentes politiques aux membres des nœuds.

resource "aws_iam_role_policy_attachment" "AmazonEKSWorkerNodePolicy" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy"
  role       = aws_iam_role.eks_nodes.name
}

resource "aws_iam_role_policy_attachment" "AmazonEKS_CNI_Policy" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonEKS_CNI_Policy"
  role       = aws_iam_role.eks_nodes.name
}

resource "aws_iam_role_policy_attachment" "AmazonEC2ContainerRegistryReadOnly" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly"
  role       = aws_iam_role.eks_nodes.name
}

# Création du groupe de nœuds du cluster EKS

resource "aws_eks_node_group" "node" {
  cluster_name    = aws_eks_cluster.eks_cluster.name
  node_group_name = "node_group1"
  node_role_arn   = aws_iam_role.eks_nodes.arn
  subnet_ids      = ["subnet-","subnet-"]

  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,
  ]
}

4. Créez un autre fichier dans ~/terraform-eks-cluster-demo, nommez-le provider.tf et collez le contenu ci-dessous. Le fichier du fournisseur définit les fournisseurs tels que AWS, Oracle, ou Azure, etc., afin que Terraform puisse se connecter aux services cloud appropriés.

Le tutoriel créera des ressources dans la région us-east-2. 

provider "aws" {
   region = "us-east-2"
 }

5. Vérifiez que tous les fichiers requis ci-dessous sont présents dans le dossier en exécutant la commande tree.

The folder structure of Terraform files

Création du cluster AWS EKS avec un module Terraform EKS

Maintenant que vous avez le fichier de configuration Terraform et les fichiers de variables prêts, il est temps d’initialiser Terraform et de créer le cluster. Pour provisionner le cluster AKS, comme pour toutes les autres configurations Terraform, Terraform utilise trois commandes (terraform init → terraform plan → terraform apply).

Explorons maintenant chaque étape.

1. Ouvrez un terminal et naviguez vers le répertoire ~/terraform-eks-cluster-demo. cd ~/terraform-eks-cluster-demo

cd ~/terraform-eks-cluster-demo

2. Exécutez la commande terraform init dans le même répertoire. La commande terraform init initialise les plugins et les fournisseurs nécessaires pour travailler avec les ressources.

terraform init

Si tout se passe bien, vous devriez voir le message Terraform a été initialisé avec succès dans la sortie, comme indiqué ci-dessous.

Initializing the terraform

3. Maintenant, exécutez la commande terraform plan. L’exécution de terraform plan n’est pas nécessaire mais recommandée pour s’assurer que la syntaxe de vos fichiers de configuration est correcte et vous donne un plan des ressources qui seront provisionnées dans votre infrastructure. 

terraform plan

Si réussi, vous devriez voir un message tel que Plan : « X » à ajouter, « Y » à modifier, ou « Z » à détruire dans la sortie.

Running the plan command in Terraform

4. Ensuite, exécutez terraform apply pour retirer les stabilisateurs et invoquer Terraform pour créer le cluster AKS. L’invocation de terraform apply lit chaque configuration (*.tf) dans le répertoire courant pour compiler un fichier d’état envoyé à AWS pour construire le cluster EKS et d’autres composants.

AWS facture 0,10 $ par heure pour chaque cluster EKS. Assurez-vous de détruire tous les clusters de test que vous avez créés une fois terminé! 

terraform apply
Running the Terraform apply command

Vérification du cluster AWS EKS

À ce stade, vous devriez avoir un cluster AKS fonctionnel, mais vérifions pour être sûr dans la Console de gestion AWS.

1. Ouvrez votre navigateur web préféré, accédez à la Console de gestion AWS et connectez-vous.

2. Cliquez sur la barre de recherche en haut, recherchez EKS, et cliquez sur l’élément de menu Elastic Kubernetes Service. Vous devriez voir le cluster EKS terraformEKScluster.

Navigating to the EKS service
Checking the terraformEKS Cluster

3. Cliquez sur Configuration, et vous devriez voir chaque composant créé avec succès tel que défini dans la configuration Terraform, comme illustré ci-dessous.

Node Role and EKS cluster role.
Security group applied on EKS Cluster.
Node group node_group1

Conclusion

Dans ce tutoriel, vous avez appris comment utiliser Terraform pour déployer un cluster AWS EKS et ses composants. Vous êtes maintenant prêt(e) à utiliser ce cluster EKS et à déployer des applications !

Quelles applications prévoyez-vous de déployer sur votre nouveau cluster ?

Source:
https://adamtheautomator.com/terraform-eks-module/