Terraform - AWS

Cette expériementation consiste à mettre en place une structure de base sur AWS avec Terraform.

l'infrastructure est composée de :

• un VPC
• Une passerelle internet
• une table de routage
• un groupe de sécurité
• une instance EC2 t3.micro (free tier)
• Une IP elastique
• Un volume EBS (gp3)

Objectif

L'objectif de cette expérimentation étais de monter en compétence sur AWS et Terraform en même temps.

De comprendre comment fonctionne Terraform et comment il interagit avec AWS.

Technique

EC2

Voici un extrait du code Terraform qui ma permis de créer une instance EC2:

resource "aws_instance" "ubuntu" {
  count         = var.nb_instance
  ami           = var.ami
  instance_type = var.instance_type
  key_name      = var.key_name
  subnet_id     = aws_subnet.ubuntu-subnet.id

  vpc_security_group_ids      = [aws_security_group.allow_ssh.id]
  user_data_replace_on_change = true

  root_block_device {
    volume_size = 10
    volume_type = "gp3"
  }

  tags = {
    Name = "Ubuntu-terraform-${count.index}"
  }
}

On peut remarque que l'utilisation des variable est omni présente ce qui vas permettre d'améliorer et changer des paramètre sans toucher au code existant.

root_block_device est une ressource qui permet de configurer le disque dur de l'instance EC2. Dans ce cas précis, il permet de configurer la taille et le type du disque dur de l'instance EC2. Nous pourrions noter la présence d'un disque de type gp3 qui est plus performant que le gp2 et égalemet 20% moins chère avec un volume standard de 10Go.

count définie le nombre d'instance que l'on veut créer. Dans ce cas précis, il permet de créer 1 instance EC2. Mais on pourrait très bien imaginer créer 3 instances EC2 en changeant simplement la valeur de la variable count.

key_name est le nom de la clé SSH qui sera utilisée pour se connecter à l'instance EC2. Dans ce cas précis, il permet de se connecter à l'instance EC2 avec la clé SSH qui sera créée. Il est important de noter que la clé SSH doit être créée au préalable sur AWS.

subnet_id est l'identifiant du sous-réseau dans lequel l'instance EC2 sera créée. Dans ce cas précis, il permet de se connecter à l'instance EC2 avec la clé SSH qui sera créée.

vpc_security_group_ids est l'identifiant du groupe de sécurité qui sera utilisé pour se connecter à l'instance EC2. Dans ce cas précis, il permet de se connecter à l'instance EC2 avec la clé SSH qui sera créée.

user_data_replace_on_change est une variable qui permet de configurer l'instance EC2. Dans ce cas précis, il permet de configurer l'instance EC2 avec la clé SSH qui sera créée.

VPC

Voici un extrait du code Terraform qui ma permis de créer un VPC:

resource "aws_vpc" "ubuntu-vpc" {
  cidr_block = "10.0.0.0/16"

  tags = {
    Name = "ubuntu-vpc"
  }
}

resource "aws_subnet" "ubuntu-subnet" {
  vpc_id     = aws_vpc.ubuntu-vpc.id
  cidr_block = "10.0.0.0/16"
}

resource "aws_internet_gateway" "ubuntu-igw" {
  vpc_id = aws_vpc.ubuntu-vpc.id
}

resource "aws_route_table" "ubuntu-rt" {
  vpc_id = aws_vpc.ubuntu-vpc.id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.ubuntu-igw.id
  }
}

resource "aws_route_table_association" "ubuntu-rta" {
  subnet_id      = aws_subnet.ubuntu-subnet.id
  route_table_id = aws_route_table.ubuntu-rt.id
}

aws_vpc est une ressource qui permet de créer un VPC (Virtual Private Cloud). C'est un réseau privé virtuel qui permet de isoler ses ressources AWS du reste d'Internet.

aws_subnet est une ressource qui permet de créer un sous-réseau. C'est une partie d'un VPC qui permet d'isoler ses ressources AWS du reste d'Internet.

aws_internet_gateway est une ressource qui permet de créer une passerelle Internet. C'est une passerelle qui permet de connecter son VPC au reste d'Internet.

aws_route_table est une ressource qui permet de créer une table de routage. C'est une table qui permet de router le trafic entre son VPC et le reste d'Internet.

aws_route_table_association est une ressource qui permet de créer une association de table de routage. C'est une association qui permet de connecter son VPC au reste d'Internet.

Groupe de sécurité

resource "aws_security_group" "allow_ssh" {
  name        = "allow_ssh"
  description = "Allow SSH inbound traffic"
  vpc_id      = aws_vpc.ubuntu-vpc.id

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["${data.http.my_ip.response_body}/32"]
  }

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

aws_security_group est une ressource qui permet de créer un groupe de sécurité. C'est un groupe de sécurité qui permet de contrôler le trafic entre son VPC et le reste d'Internet.

ingress est une ressource qui permet de créer une règle d'entrée. C'est une règle qui permet de contrôler le trafic entrant dans son VPC.

egress est une ressource qui permet de créer une règle de sortie. C'est une règle qui permet de contrôler le trafic sortant de son VPC.

Voici un exemple

data "http" "my_ip" {
  url = "https://ifconfig.me/ip"
}

IP Elastique

resource "aws_eip" "docker_ip" {
  instance = aws_instance.ubuntu[0].id
  domain   = "vpc"
}

Résultat

Le résultat de cette expérimentation est une infrastructure de base sur AWS avec Terraform. Je suis assez satisfait du résultat, j'ai pu mettre en place une infrastructure de base sur AWS avec Terraform et comprendre comment fonctionne Terraform et comment il interagit avec AWS.

Surtout au niveau du VPC ou j'ai pu comprendre comment fonctionne les VPC, les sous-réseaux, les passerelles Internet et les tables de routage.

Suite

La suite est donc de compléter ce mini projets en ajoutant une partie Ansible pour configurer l'instance EC2. Et déployer une mini application web (caddy + fastapi) sur l'instance EC2.