Migrer de Heroku vers AWS

Pourquoi Migrer de Heroku vers AWS ?

La transition d'une application hébergée sur Heroku vers Amazon Web Services (AWS) peut apporter plusieurs avantages. En effet, Heroku est une solution de déploiement et d'hébergement qui offre une facilité de mise en œuvre rapide mais ne permet pas un contrôle complet des ressources. AWS, quant à lui, offre une gamme complète de services cloud avec une grande flexibilité et une granularité du contrôle des ressources, ce qui est particulièrement utile pour les applications complexes.

Un cas d'utilisation concret serait le déploiement d'un site web é-commerce. Avec Heroku, il peut être difficile d'ajuster efficacement la puissance de calcul à mesure que le trafic augmente, car il s'agit d'une solution faiblement scalable. En revanche, AWS offre des services comme EC2 (Elastic Compute Cloud) et RDS (Relational Database Service), qui permettent une mise à l'échelle facile et un contrôle total de la ressource.

Prerequis

Avant de commencer le processus de migration, il est important d'avoir certaines connaissances et outils installés :

• Connaissances Nécessaires :

  • Familiarité avec Python, Node.js ou Java (ou tout autre langage de programmation utilisé)
  • Compréhension des bases de données relationnelles
  • Connaissance des concepts d'infrastructure en tant que code (IaC) comme Terraform
  • Maîtrise du terminal et des commandes Unix/Linux

• Outils à Installer :

  • Node.js v14 ou ultérieur (npm install node)
  • Python 3.8 ou ultérieur (pip install python)
  • Java Development Kit (JDK) 11 ou ultérieur
  • AWS CLI (Command Line Interface) v2 (pip install awscli)
  • Terraform v0.14 ou ultérieur (terraform init)

Concepts Fondamentaux

1. Infrastructure en tant que Code (IaC)

L'Infrastructure en tant que Code est une pratique qui permet de définir et gérer l'infrastructure de votre application comme du code source. AWS supporte cette pratique grâce à des outils comme Terraform.

Schéma Mental :

+-------------------+
|  Application      |
+---------^---------+
          |
          v
+---------^---------+
|  Code Source    |
+---------^---------+
          |
          v
+---------^---------+
|  Terraform        |
+---------^---------+
          |
          v
+---------^---------+
|  AWS CloudFormation |
+-------------------+

Code Fonctionnel :

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

resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"

  tags = {
    Name = "MyInstance"
  }
}

2. Groupes de Formation et Services (EC2)

Amazon Elastic Compute Cloud (EC2) est le service AWS qui permet de provisionner des instances virtuelles dans le cloud.

Schéma Mental :

+-------------------+
|  EC2 Instances    |
+---------^---------+
          |
          v
+---------^---------+
|  Auto Scaling   |
+---------^---------+
          |
          v
+---------^---------+
|  Load Balancing |
+-------------------+

3. Services de Stockage (S3, RDS)

Amazon Simple Storage Service (S3) est un service d'objets stockage à grande échelle et Amazon Relational Database Service (RDS) est un service de base de données relationnelle managée.

Schéma Mental :

+-------------------+
|  S3 Buckets       |
+---------^---------+
          |
          v
+---------^---------+
|  RDS Databases    |
+-------------------+

Mise en Pratique : Projet Fil Rouge

Dans ce projet, nous allons créer un simple API de blog. Cette API permettra aux utilisateurs d'ajouter, lire et supprimer des articles.

Étape 1: Création du Projet

Créer un nouveau répertoire pour le projet et initialiser un environnement virtuel Python.

mkdir aws_blog_api
cd aws_blog_api
python -m venv venv
source venv/bin/activate

Étape 2: Installation des Dépendances

Installer Flask, une micro-framework web en Python, ainsi que SQLAlchemy, une bibliothèque d'ORM.

pip install flask sqlalchemy

Étape 3: Création de l'Application Flask

Créer un fichier app.py avec le code suivant :

## app.py
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db'
db = SQLAlchemy(app)

class Article(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)

@app.route('/articles', methods=['POST'])
def create_article():
    data = request.get_json()
    new_article = Article(title=data['title'], content=data['content'])
    db.session.add(new_article)
    db.session.commit()
    return jsonify({'message': 'Article created successfully'}), 201

@app.route('/articles', methods=['GET'])
def get_articles():
    articles = Article.query.all()
    output = []
    for article in articles:
        article_data = {'id': article.id, 'title': article.title, 'content': article.content}
        output.append(article_data)
    return jsonify({'articles': output})

@app.route('/articles/<int:id>', methods=['DELETE'])
def delete_article(id):
    article = Article.query.get_or_404(id)
    db.session.delete(article)
    db.session.commit()
    return jsonify({'message': 'Article deleted'})

if __name__ == '__main__':
    app.run(debug=True)

Étape 4: Création de la Base de Données

Créer une base de données SQLite et les tables nécessaires.

python
from app import db
db.create_all()
exit()

Étape 5: Configuration de AWS

Connectez-vous à votre compte AWS via l'interface web ou en utilisant la CLI AWS. Configurez ensuite votre projet pour utiliser AWS avec Flask-SQLAlchemy.

Créer un fichier config.py :

## config.py
import os
from dotenv import load_dotenv

load_dotenv()

class Config:
    SQLALCHEMY_DATABASE_URI = 'sqlite:///blog.db'
    SQLALCHEMY_TRACK_MODIFICATIONS = False

Modifier app.py pour inclure la configuration.

## app.py
from flask_sqlalchemy import SQLAlchemy
from config import Config

app.config.from_object(Config)
db = SQLAlchemy(app)

Étape 6: Déploiement sur AWS EC2

Créer un fichier requirements.txt avec les dépendances du projet.

pip freeze > requirements.txt

Créer une instance EC2 via la console AWS ou en utilisant Terraform. Pour cette démonstration, nous utiliserons la console AWS.

1. Créez une instance EC2.
2. Connectez-vous à l'instance via SSH.
3. Clonez le répertoire du projet sur l'instance EC2.
4. Installez les dépendances et exécutez l'application Flask.

git clone https://github.com/your-repo/aws_blog_api.git
cd aws_blog_api
pip install -r requirements.txt
python app.py

Étape 7: Configuration de la BDD

Configurez une base de données RDS pour stocker les articles. Utilisez Terraform pour déployer l'instance RDS.

Créer un fichier terraform.tf :

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

resource "aws_db_instance" "example" {
  identifier             = "mydb"
  engine                 = "mysql"
  engine_version         = "8.0.mysql_aurora.2.07.1"
  instance_class         = "db.t2.micro"
  username               = "admin"
  password               = "password123"
  parameter_group_name   = "default.mysql5.7"
  skip_final_snapshot    = true
}

Exécutez Terraform pour créer l'instance RDS.

terraform init
terraform apply

Étape 8: Connexion à la BDD

Modifiez app.py pour connecter Flask-SQLAlchemy à l'instance RDS.

## app.py
from flask_sqlalchemy import SQLAlchemy
import os

SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://admin:password123@your-rds-endpoint/mydb'
SQLALCHEMY_TRACK_MODIFICATIONS = False

app.config['SQLALCHEMY_DATABASE_URI'] = SQLALCHEMY_DATABASE_URI
db = SQLAlchemy(app)

Étape 9: Déploiement Continu (CI/CD)

Configurez un pipeline CI/CD pour automatiser le déploiement des modifications sur l'instance EC2.

Utilisez AWS CodePipeline et AWS CodeBuild pour créer un pipeline qui exécute les étapes suivantes :

1. Clonage du code source.
2. Installation des dépendances.
3. Exécution des tests (si existants).
4. Déploiement sur l'instance EC2.

Erreurs Frequentes et Debugging

1. Connexion à la BDD échoue

Code Incorrect :

SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://admin:password123@localhost/mydb'

Correction :

SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://admin:password123@your-rds-endpoint/mydb'

2. Erreur d'import

Code Incorrect :

from flask_sqlalchemy import SQLAlchemy

Correction :

from flask_sqlalchemy import SQLAlchemy

3. Mauvaise configuration de la BDD

Code Incorrect :

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db'

Correction :

app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://admin:password123@your-rds-endpoint/mydb'

Pour Aller Plus loin

1. Utilisation de AWS Lambda et API Gateway

Déployez l'API en utilisant AWS Lambda et API Gateway pour une meilleure scalabilité.

• AWS Lambda : Exécutez le code Python en tant que fonctions serverless.
• API Gateway : Créez les endpoints de votre API.

2. Mise en place d'un système de notifications

Utilisez AWS SNS (Simple Notification Service) pour envoyer des notifications en cas d'événements importants dans l'application.

3. Optimisation du stockage et de la performance

Optimisez les performances de votre application en utilisant les services AWS comme EC2 Auto Scaling, CloudFront, et RDS Aurora.

Défi Pratique :

Déployez une version plus complexe d'un gestionnaire de tâches à l'aide des ressources AWS. Créez un backend avec Flask et SQLAlchemy, un frontend avec React, et utilisez AWS S3 pour stocker les fichiers. Déployez tout cela sur AWS ECS (Elastic Container Service) et configurez le déploiement continu avec AWS CodePipeline.

Bonne chance dans votre migration vers AWS !