AWSCloud

Terraform + AWS + Python

bochi
bochi
22 juin 2023
10 Mins Read
372 Views
0 Comments

Introduction

Bienvenue dans mon exploration approfondie d’une application réelle de l’automatisation de l’infrastructure cloud en utilisant Amazon Web Services (AWS) et Terraform de HashiCorp. Dans ce projet, j’ai conçu et mis en œuvre un équilibreur de charge haute disponibilité pour des instances EC2 dans un réseau VPC.

Amazon Web Services (AWS) est une plateforme de services de cloud computing offrant des services de calcul, de stockage, de mise en réseau, de bases de données et bien plus encore. J’ai choisi AWS pour ce projet en raison de sa robustesse, de sa fiabilité et de sa flexibilité. Que vous soyez un développeur individuel ou une grande entreprise, AWS a des services qui peuvent répondre à vos besoins.

Terraform, d’autre part, est un outil open-source qui permet de définir et de fournir une infrastructure de manière déclarative en utilisant la syntaxe de configuration HashiCorp (HCL). Il prend en charge une multitude de fournisseurs de services, dont AWS. Grâce à Terraform, j’ai pu décrire l’ensemble de mon infrastructure comme du code (IaC – Infrastructure as Code), ce qui permet une gestion et une évolution plus faciles de l’infrastructure.

Dans ce projet, j’ai utilisé Terraform pour configurer une infrastructure AWS comprenant plusieurs services, dont EC2, Load Balancer, et VPC. Le code Terraform crée une infrastructure qui comprend des instances EC2 réparties sur différentes zones de disponibilité, un équilibreur de charge pour répartir le trafic entre ces instances, et un réseau VPC pour les héberger.

J’ai également créé un bastion, ou serveur saut, qui offre une couche de sécurité supplémentaire pour l’accès aux instances EC2. Les instances EC2 sont réparties en sous-réseaux publics et privés, avec une passerelle NAT pour permettre aux instances EC2 dans le sous-réseau privé d’accéder à internet pour les mises à jour et les téléchargements, sans être directement exposées à internet.

Dans les sections suivantes, je vais détailler chacune de ces parties, expliquer comment elles fonctionnent et pourquoi j’ai choisi cette configuration particulière. Alors, sans plus tarder, commençons notre exploration de ce projet passionnant.

Voici un petit extrait de code pour vous donner une idée du genre de configurations que j’ai utilisées dans ce projet :

resource "aws_vpc" "VPC_Projet" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
}

resource "aws_subnet" "az_subnet_1a" {
  vpc_id                  = aws_vpc.VPC_Projet.id
  cidr_block              = "10.0.1.0/24"
  availability_zone       = "eu-west-1a"
  tags = {
    Name = "private-subnet-1a"
  }
}

Cette configuration crée une VPC (Virtual Private Cloud) avec un bloc CIDR de “10.0.0.0/16”, ce qui signifie que nous avons environ 65 536 adresses IP privées à notre disposition. Ensuite, nous créons un sous-réseau dans cette VPC avec un bloc CIDR de “10.0.1.0/24”, nous donnant 256 adresses IP privées dans ce sous-réseau. La VPC et le sous-réseau sont créés dans la région “eu-west-1a” de AWS.

Terraform et AWS : Deux outils puissants pour automatiser votre infrastructure

Avant de plonger dans le code lui-même, permettez-moi de partager quelques mots sur les outils que j’ai utilisés dans ce projet : Terraform et AWS.

Terraform est un outil d’Infrastructure as Code (IaC) qui permet aux utilisateurs de définir et de fournir une infrastructure de manière déclarative en utilisant la syntaxe de configuration HashiCorp (HCL). Terraform est capable de gérer une multitude de fournisseurs de services, dont AWS, ce qui en fait un choix flexible et polyvalent pour gérer l’infrastructure.

Terraform permet une approche modulaire et réutilisable pour la gestion de l’infrastructure. Au lieu de cliquer manuellement à travers la console AWS (ou tout autre fournisseur de services cloud) pour configurer des ressources, avec Terraform, j’ai pu écrire du code qui décrit exactement ce que je veux. Ce code peut ensuite être exécuté pour créer, modifier ou supprimer des ressources.

Terraform offre plusieurs avantages, notamment :

  1. Reproductibilité : La capacité de reproduire l’infrastructure à l’identique est un énorme avantage. Cela signifie que je peux déployer la même infrastructure à plusieurs reprises avec la certitude qu’elle sera exactement la même à chaque fois.
  2. Gestion des versions : Comme pour tout autre code, le code Terraform peut être mis en version. Cela signifie que je peux facilement suivre les modifications, voir qui a fait quoi et quand, et même revenir à une version précédente si nécessaire.
  3. Collaboration : Avec le code Terraform stocké dans un dépôt de contrôle de version comme Git, plusieurs personnes peuvent travailler sur la même infrastructure. Cela facilite le travail en équipe et garantit que tout le monde est sur la même longueur d’onde.

Pour illustrer comment Terraform interagit avec AWS, voici un exemple de code Terraform que j’ai utilisé pour créer une instance EC2 :

resource "aws_instance" "BASTION" {
  ami           = "ami-09fd16644beea3565"
  instance_type = "t2.micro"
  key_name      = aws_key_pair.alb_keypair.key_name
  subnet_id     = aws_subnet.az_subnet_2b.id
  vpc_security_group_ids = [aws_security_group.SG_BASTION_Projet.id]

  tags = {
    Name = "BASTION"
  }
}

Dans cet exemple, j’ai déclaré une ressource de type aws_instance nommée BASTION. Cette ressource utilise l’AMI (Amazon Machine Image) spécifiée par ami-09fd16644beea3565, qui est une image de serveur pré-configurée pour lancer des instances EC2. L’instance est de type t2.micro, qui est une taille d’instance EC2 offrant un bon équilibre entre les coûts de calcul, de mémoire et de réseau. J’ai associé la clé SSH alb_keypair à l’instance pour permettre une connexion SSH sécurisée. Enfin, j’ai spécifié que l’instance doit être lancée dans le sous-réseau az_subnet_2b et associée au groupe de sécurité SG_BASTION_Projet pour contrôler le trafic entrant et sortant.

Amazon Web Services (AWS) est l’un des fournisseurs de services cloud les plus populaires et les plus largement utilisés aujourd’hui. AWS offre une gamme incroyablement large de services qui couvrent pratiquement tous les aspects de l’informatique dans le cloud, du calcul et du stockage à la base de données, en passant par le réseau et la sécurité. Dans ce projet, j’ai utilisé plusieurs services AWS, y compris EC2, VPC, ELB, et plus encore.

Plongée dans le code Terraform : Définir l’infrastructure AWS

Maintenant que nous avons une bonne compréhension des outils utilisés, passons à la partie la plus intéressante : le code Terraform lui-même. Dans ce projet, j’ai utilisé Terraform pour définir une infrastructure AWS complète, y compris les réseaux, les instances EC2, les load balancers, etc. Tout cela est orchestré de manière modulaire et flexible, grâce à la puissance de Terraform.

Commençons par le réseau. Dans ce projet, j’ai défini un réseau AWS VPC (Virtual Private Cloud) en utilisant le module VPC de Terraform. Voici comment j’ai défini le VPC et les sous-réseaux :

resource "aws_vpc" "Projet_VPC" {
  cidr_block = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support = true

  tags = {
    Name = "Projet_VPC"
  }
}

resource "aws_subnet" "az_subnet_2b" {
  vpc_id     = aws_vpc.Projet_VPC.id
  cidr_block = "10.0.4.0/24"
  availability_zone = "eu-west-3b"

  tags = {
    Name = "az_subnet_2b"
  }
}

Dans cet exemple, j’ai créé un VPC avec un bloc CIDR de 10.0.0.0/16, ce qui signifie que le VPC dispose d’un grand espace d’adressage privé pour les instances EC2 et autres ressources. J’ai également activé le support DNS pour le VPC, ce qui est nécessaire pour que les instances EC2 puissent communiquer entre elles en utilisant des noms de domaine DNS. Ensuite, j’ai défini un sous-réseau dans le VPC avec un bloc CIDR de 10.0.4.0/24. Ce sous-réseau est situé dans la zone de disponibilité eu-west-3b.

Maintenant, passons aux instances EC2. J’ai utilisé le module aws_instance de Terraform pour définir les instances EC2. Par exemple, voici comment j’ai défini l’instance de bastion :

resource "aws_instance" "BASTION" {
  ami           = "ami-09fd16644beea3565"
  instance_type = "t2.micro"
  key_name      = aws_key_pair.alb_keypair.key_name
  subnet_id     = aws_subnet.az_subnet_2b.id
  vpc_security_group_ids = [aws_security_group.SG_BASTION_Projet.id]

  tags = {
    Name = "BASTION"
  }
}

Dans cet exemple, l’instance BASTION est créée avec l’AMI ami-09fd16644beea3565, qui est une image de serveur pré-configurée pour les instances EC2. J’ai également défini le type d’instance comme t2.micro, qui offre un bon équilibre entre la puissance de calcul, la mémoire et le réseau. J’ai spécifié la clé SSH à utiliser pour se connecter à l’instance, et j’ai associé l’instance au groupe de sécurité SG_BASTION_Projet.

Enfin, discutons du load balancer. J’ai utilisé le module aws_elb de Terraform pour définir un load balancer. Voici comment j’ai défini le load balancer :

resource "aws_elb" "Projet_ELB" {
  name               = "Projet_ELB"
  subnets            = [aws_subnet.az_subnet_2a.id, aws_subnet.az_subnet_2b.id]
  security_groups    = [aws_security_group.SG_WEB_Projet.id]
  listener {
    instance_port     = 80
    instance_protocol = "http"
    lb_port           = 80
    lb_protocol       = "http"
  }
  
  health_check {
    target              = "HTTP:80/"
    interval            = 30
    healthy_threshold   = 2
    unhealthy_threshold = 2
    timeout             = 3
  }

  tags = {
    Name = "Projet_ELB"
  }
}

Dans cet exemple, le load balancer est associé aux sous-réseaux az_subnet_2a et az_subnet_2b. Il est également associé au groupe de sécurité SG_WEB_Projet. J’ai défini une règle d’écoute pour le port 80 en utilisant le protocole HTTP. Enfin, j’ai défini une vérification de santé pour vérifier que les instances EC2 sont en bonne santé et capables de répondre aux requêtes.

Comme vous pouvez le voir, Terraform est un outil puissant pour définir et gérer l’infrastructure dans le cloud. Il offre une grande flexibilité et permet de gérer les ressources de manière déclarative, ce qui facilite la compréhension et la maintenance de l’infrastructure.

Approfondissement du réseau : sous-réseaux, NAT et bastion

Comprendre le réseau dans le cloud est crucial, car il forme la base de la connectivité pour toutes nos applications et services. Dans cette partie, je vais expliquer comment j’ai conçu le réseau dans ce projet, en mettant l’accent sur les concepts de sous-réseaux, de NAT et de bastion.

Sous-réseaux

Les sous-réseaux sont des divisions d’un réseau IP. Dans le cloud AWS, nous pouvons diviser un VPC en plusieurs sous-réseaux. Dans ce projet, j’ai créé deux sous-réseaux (az_subnet_2a et az_subnet_2b) dans différentes zones de disponibilité pour assurer une haute disponibilité. Les instances dans ces sous-réseaux peuvent communiquer entre elles et avec d’autres instances dans le même VPC. Voici à quoi ressemble la définition du sous-réseau dans Terraform :

resource "aws_subnet" "az_subnet_2b" {
  vpc_id     = aws_vpc.Projet_VPC.id
  cidr_block = "10.0.4.0/24"
  availability_zone = "eu-west-3b"

  tags = {
    Name = "az_subnet_2b"
  }
}

NAT (Network Address Translation)

NAT est un mécanisme qui permet aux instances dans un sous-réseau privé d’accéder à internet ou à d’autres services AWS, tout en empêchant le trafic internet entrant d’atteindre ces instances. Pour ce faire, j’ai déployé une instance NAT dans un sous-réseau public, qui fait le relais entre les instances privées et internet. La définition d’une NAT Gateway dans Terraform est assez simple :

resource "aws_nat_gateway" "nat_gw" {
  allocation_id = aws_eip.eip_nat.id
  subnet_id     = aws_subnet.az_subnet_2a.id
  depends_on    = [aws_internet_gateway.Projet_IGW]
  
  tags = {
    Name = "Projet_NAT_GW"
  }
}

Bastion Host

Un bastion est une instance spéciale qui sert de point d’entrée sécurisé dans un réseau. Les administrateurs utilisent le bastion pour se connecter aux instances privées. Dans ce projet, j’ai déployé un bastion dans un sous-réseau public, accessible via SSH. La sécurité est renforcée en n’autorisant que le trafic SSH vers le bastion. Voici comment le bastion est défini dans Terraform :

resource "aws_instance" "BASTION" {
  ami           = "ami-09fd16644beea3565"
  instance_type = "t2.micro"
  key_name      = aws_key_pair.alb_keypair.key_name
  subnet_id     = aws_subnet.az_subnet_2b.id
  vpc_security_group_ids = [aws_security_group.SG_BASTION_Projet.id]

  tags = {
    Name = "BASTION"
  }
}

En combinant ces éléments, nous avons un réseau cloud solide et sécurisé, prêt à soutenir nos applications.

Aspects de sécurité : Groupe de sécurité, ports et SSH

Dans ce projet, j’ai prêté une attention particulière à la sécurité, en particulier en ce qui concerne le groupe de sécurité, le contrôle des ports et l’utilisation de SSH pour les connexions sécurisées. J’expliquerai chacun de ces aspects dans cette section.

Groupes de sécurité

Les groupes de sécurité agissent comme un pare-feu virtuel pour contrôler le trafic entrant et sortant de nos instances. Pour ce projet, j’ai créé des groupes de sécurité spécifiques pour le Load Balancer (SG_LB_Projet) et les instances EC2 (SG_EC2_Projet). Chaque groupe de sécurité définit des règles qui contrôlent le trafic autorisé.

Voici à quoi ressemble la définition d’un groupe de sécurité dans Terraform :

resource "aws_security_group" "SG_LB_Projet" {
  name        = "SG-LB_Projet"
  description = "SG-LB_Projet"
  vpc_id      = aws_vpc.VPC_Projet.id

  ingress {
    from_port   = 80
    to_port     = 80
    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"]
  }
}

Contrôle des ports

Une autre partie importante de la sécurisation de notre infrastructure est le contrôle des ports. Dans ce projet, j’ai utilisé le port 80 pour le trafic HTTP entrant vers le Load Balancer et le port 22 pour les connexions SSH. En limitant les ports ouverts, nous réduisons la surface d’attaque potentielle.

SSH et clés

SSH est utilisé pour se connecter en toute sécurité à nos instances. Dans ce projet, j’utilise une clé SSH pour les connexions à mes instances, y compris le bastion. La clé publique est ajoutée à l’instance lors de sa création, ce qui me permet de me connecter en utilisant ma clé privée correspondante.

Voici comment la clé SSH est utilisée dans Terraform :

resource "aws_key_pair" "alb_keypair" {
  key_name   = "bochiKey"
  public_key = file("~/.ssh/id_rsa.pub")
}

Introduction à boto3 et le script Python

Après avoir expliqué le fonctionnement du réseau et les aspects de sécurité de notre infrastructure AWS, j’aimerais maintenant présenter la bibliothèque boto3 de Python et le script que j’ai utilisé pour interagir avec mon infrastructure AWS.

Présentation de boto3

Boto3 est le nom du kit SDK Amazon Web Services (AWS) pour Python. Il permet aux développeurs Python de rédiger un logiciel qui effectue des actions sur les services AWS comme Amazon S3, Amazon EC2, etc. Pour ce projet, j’ai utilisé boto3 pour interagir avec les services AWS directement depuis mon script Python.

Boto3 facilite l’intégration de vos applications Python, bibliothèques et scripts avec les services AWS, y compris AWS Identity and Access Management (IAM), Amazon S3, Amazon EC2, etc. Il vous permet de créer, configurer et gérer les services AWS de manière programmatique.

Exemple de script Python avec boto3

Je n’ai pas inclus de script Python spécifique dans le code Terraform que j’ai partagé précédemment, mais voici un exemple simple de script qui utilise boto3 pour lister toutes vos instances EC2 dans une région spécifique :

import boto3

def list_instances(region):
    ec2 = boto3.resource('ec2', region_name=region)

    print(f"Listing instances in region {region}:")
    for instance in ec2.instances.all():
        print(f"- {instance.id}, state: {instance.state['Name']}, type: {instance.instance_type}")

list_instances('eu-west-1')

Boto3 offre une grande flexibilité pour gérer et automatiser vos ressources AWS directement depuis un script Python. Cela le rend particulièrement utile pour des tâches comme le scripting de maintenance, la gestion de l’infrastructure, et bien plus encore.

Pour aller plus loin

Pour approfondir vos connaissances sur boto3, je vous recommande la documentation officielle de boto3. Elle offre une vue d’ensemble détaillée de la bibliothèque, ainsi que des tutoriels et des guides de référence pour chaque service AWS pris en charge.

C’est la fin de notre parcours pour ce projet. J’espère que cela vous a donné une bonne compréhension de comment utiliser Terraform pour déployer une infrastructure AWS de manière sécurisée et efficace, et comment boto3 peut être utilisé pour interagir avec cette infrastructure. N’hésitez pas à laisser vos commentaires et à partager vos propres expériences avec Terraform et AWS.

Tags:

Share Article

bochi
Follow Me Written By

bochi

Autres articles

Passionné d'informatique qui partage ce qu'il apprend et vous montre ses nouveaux projets et hobbies.

Postes récents

Tag Cloud

AWS 1
Cloud 1
DevOps 1
homelab 3
Podcast La Tangente 1
Sécurité 1
Windows 1
YouTube 1

© 2023, All Rights Reserved.