HowtoForge

Tutoriels Linux

Créer un Cloud privé virtuel (VPC) sur AWS en utilisant Terraform

Dans cet article, je vais te montrer comment créer un VPC avec des sous-réseaux, une passerelle Internet, des passerelles NAT et des tables de routage. Nous allons créer 1 VPC avec 4 sous-réseaux : 2 privés et 2 publics, 2 passerelles NAT, 1 passerelle Internet et 4 tables de routage.

Avant de poursuivre, je suppose que tu as une compréhension de base de Terraform et des VPC sur AWS. Pour apprendre le VPC et sa création à partir de la console AWS, tu peux cliquerici et pour apprendre les bases de Terraform, tu peux rechercher « Qu’est-ce que Terraform et comment l’installer sur l’Instance AWS EC2 ? ».

Pré-requis

  1. Compréhension de base de Terraform.
  2. Terraform installé sur ton système.
  3. Compte AWS (crée-le si tu n’en as pas).
  4. Clé d’accès et clé secrète d’un utilisateur AWS IAM. (Clique ici pour apprendre à créer un utilisateur IAM avec ‘access_key’ et ‘secret_key’ sur AWS).

Ce que nous allons faire

  1. Rédige les fichiers de configuration Terraform pour créer un VPC et d’autres ressources dépendantes.
  2. Créer un VPC et d’autres ressources dépendantes à l’aide des fichiers de configuration Terraform
  3. Supprimer le VPC créé et les autres ressources dépendantes à l’aide de Terraform

Écris les fichiers de configuration Terraform pour créer un VPC avec d’autres ressources dépendantes.

Crée un répertoire dédié dans lequel tu peux créer des fichiers de configuration Terraform.

Utilise la commande suivante pour créer un répertoire et y changer ton répertoire de travail actuel.

mkdir terraform
cd terraform/

J’utilise « vim » comme éditeur pour écrire dans les fichiers. Tu peux utiliser l’éditeur de ton choix et copier-coller les configurations suivantes pour créer variables.tf, terraform.tfvars et main.tf

Crée ‘main.tf’, qui est responsable de la création du VPC sur AWS avec les ressources dépendantes. Ce main.tf lira les valeurs des variables de variables.tf et terraform.tfvars.

vim main.tf
provider "aws" {
      region     = "${var.region}"
      access_key = "${var.access_key}"
      secret_key = "${var.secret_key}"
}


# VPC resources: This will create 1 VPC with 4 Subnets, 1 Internet Gateway, 4 Route Tables. 

resource "aws_vpc" "default" {
  cidr_block           = var.cidr_block
  enable_dns_support   = true
  enable_dns_hostnames = true
}

resource "aws_internet_gateway" "default" {
  vpc_id = aws_vpc.default.id
}

resource "aws_route_table" "private" {
  count = length(var.private_subnet_cidr_blocks)

  vpc_id = aws_vpc.default.id
}

resource "aws_route" "private" {
  count = length(var.private_subnet_cidr_blocks)

  route_table_id         = aws_route_table.private[count.index].id
  destination_cidr_block = "0.0.0.0/0"
  nat_gateway_id         = aws_nat_gateway.default[count.index].id
}

resource "aws_route_table" "public" {
  vpc_id = aws_vpc.default.id
}

resource "aws_route" "public" {
  route_table_id         = aws_route_table.public.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_internet_gateway.default.id
}

resource "aws_subnet" "private" {
  count = length(var.private_subnet_cidr_blocks)

  vpc_id            = aws_vpc.default.id
  cidr_block        = var.private_subnet_cidr_blocks[count.index]
  availability_zone = var.availability_zones[count.index]
}

resource "aws_subnet" "public" {
  count = length(var.public_subnet_cidr_blocks)

  vpc_id                  = aws_vpc.default.id
  cidr_block              = var.public_subnet_cidr_blocks[count.index]
  availability_zone       = var.availability_zones[count.index]
  map_public_ip_on_launch = true
}

resource "aws_route_table_association" "private" {
  count = length(var.private_subnet_cidr_blocks)

  subnet_id      = aws_subnet.private[count.index].id
  route_table_id = aws_route_table.private[count.index].id
}

resource "aws_route_table_association" "public" {
  count = length(var.public_subnet_cidr_blocks)

  subnet_id      = aws_subnet.public[count.index].id
  route_table_id = aws_route_table.public.id
}


# NAT resources: This will create 2 NAT gateways in 2 Public Subnets for 2 different Private Subnets.

resource "aws_eip" "nat" {
  count = length(var.public_subnet_cidr_blocks)

  vpc = true
}

resource "aws_nat_gateway" "default" {
  depends_on = ["aws_internet_gateway.default"]

  count = length(var.public_subnet_cidr_blocks)

  allocation_id = aws_eip.nat[count.index].id
  subnet_id     = aws_subnet.public[count.index].id
}
 

Crée ‘variables.tf’ qui contient la déclaration et la définition des variables.

vim variables.tf
variable "access_key" {
     description = "Access key to AWS console"
     
}
variable "secret_key" {
     description = "Secret key to AWS console"
     
}

variable "region" {
  default     = "eu-west-3"
  type        = string
  description = "Region of the VPC"
}


variable "cidr_block" {
  default     = "10.0.0.0/16"
  type        = string
  description = "CIDR block for the VPC"
}

variable "public_subnet_cidr_blocks" {
  default     = ["10.0.0.0/24", "10.0.2.0/24"]
  type        = list
  description = "List of public subnet CIDR blocks"
}

variable "private_subnet_cidr_blocks" {
  default     = ["10.0.1.0/24", "10.0.3.0/24"]
  type        = list
  description = "List of private subnet CIDR blocks"
}

variable "availability_zones" {
  default     = ["eu-west-3a", "eu-west-3b"]
  type        = list
  description = "List of availability zones"
}
 

Crée ‘terraform.tfvars’ qui contient la définition des variables access_key et secret_key définies dans le fichier ci-dessus. Nous avons conservé la déclaration de ces deux variables dans le fichier ‘terraform.tfvars’.

Les clés suivantes doivent être modifiées avec les clés de ton utilisateur IAM.

vim terraform.tfvars
access_key = "AKIAQ6GAIA5XIHHM2GJM"
secret_key = "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"

Tu devrais maintenant avoir 3 fichiers, à savoir variables.tf, terraform.tfvars et main.tf.

Crée un VPC et d’autres ressources dépendantes à l’aide des fichiers de configuration Terraform

Avant d’exécuter les commandes suivantes, assure-toi d’avoir configuré la clé d’accès et la clé secrète valides.

La première commande à utiliser est ‘terraform init’. Cette commande télécharge et installe les plugins pour les fournisseurs utilisés dans la configuration. Dans notre cas, il s’agit d’AWS.

terraform init

La deuxième commande à utiliser est ‘terraform plan’. Cette commande est utilisée pour voir les changements qui auront lieu sur l’infrastructure.

terraform plan

La commande ‘terraform apply’ créera les ressources sur l’AWS mentionné dans le fichier main.tf. Tu seras invité à fournir tes entrées pour créer les ressources.

terraform apply

Lorsque tu exécutes la commande ci-dessus, tu peux voir que 20 nouvelles ressources ont été ajoutées et que 0 a été détruite dans la sortie.

Tu peux te rendre dans la console AWS VPC pour vérifier si le VPC est créé avec les sous-réseaux, les tables de routes, les passerelles NAT et une passerelle Internet.

Supprime le VPC créé et les autres ressources dépendantes à l’aide de Terraform

Si tu n’as plus besoin des ressources que tu as créées à l’aide de la configuration mentionnée dans le fichier main.tf, tu peux utiliser la commande « terraform destroy » pour supprimer toutes ces ressources.

terraform destroy

Lorsque tu exécutes la commande ci-dessus, tu peux voir que 20 ressources qui ont été créées sont détruites dans la sortie. Tu peux vérifier la même chose en visitant AWS dans le tableau de bord VPC.

Conclusion

Dans cet article, nous avons vu les étapes pour créer un VPC avec 4 sous-réseaux, 4 tables de routes, 2 passerelles NAT et 1 passerelle Internet. Nous avons également vu comment les ressources créées peuvent être détruites.

Vous aimerez aussi...