Deployer Express sur AWS

Deployer Express sur AWS : un tutoriel approfondi

Pourquoi Deployer Express sur AWS ?

En tant que développeur senior, vous êtes certainement familier avec les applications Express.js. Cependant, pour une application à grande échelle ou nécessitant des performances élevées et de la redondance, le déploiement sur Amazon Web Services (AWS) est souvent nécessaire.

Le contexte réel du déploiement Express sur AWS est que vous avez besoin d'une plateforme fiable, scalable et haute disponibilité pour vos applications web. Les services AWS offrent une variété de solutions pour le déploiement, notamment Elastic Beanstalk, EC2 (Elastic Compute Cloud), RDS (Relational Database Service) et S3 (Simple Storage Service).

Un cas d'usage concret serait la création d'une application de gestion de tâches. Avec des millions d'utilisateurs et une forte charge concurrentielle, un déploiement sur AWS permettrait de gérer efficacement les demandes et de prévenir tout éventuel crash ou pannes.

Prerequis

Avant de commencer ce tutoriel, vous devez avoir certaines compétences techniques et des outils installés :

• Connaissances en JavaScript et Node.js : Vous devriez être à l'aise avec les concepts de base de JavaScript et le langage d'exploitation Node.js.
• Développement back-end avec Express.js : Un bon compréhension des routes, du middleware, et du système de gestion des requêtes est nécessaire.
• Connaissance des bases de données SQL : Vous devrez avoir une base de données pour stocker les données de l'application. Nous utiliserons MySQL ici.
• Comprendre les concepts AWS : Familiarisé avec les terminologie comme EC2, S3, RDS, IAM (Identity and Access Management) et Elastic Beanstalk.

Les outils que vous devrez installer sont :

• Node.js (version 14.x ou ultérieure)
• npm (package manager de Node.js)
• MySQL (ou une autre base de données SQL comme PostgreSQL)
• AWS CLI : Utilisé pour interagir avec les services AWS depuis la ligne de commande.
• Git : Pour versionner votre code et le déployer sur AWS Elastic Beanstalk.

Concepts fondamentaux

1. Amazon Web Services (AWS)

AWS est une plateforme de cloud computing qui offre des services tels que EC2, S3, RDS, IAM et Elastic Beanstalk. Chaque service a un rôle spécifique pour faciliter le déploiement et la gestion des applications.

Schéma mental :

+-------------------+
|  +---------------+ |
|  |   EC2           | |
|  +---------------+ |
|                   |
|  +---------------+ |
|  |   RDS         | |
|  +---------------+ |
|                   |
|  +---------------+ |
|  |   S3          | |
|  +---------------+ |
|                   |
|  +---------------+ |
|  |   IAM         | |
|  +---------------+ |
|                   |
|  +---------------+ |
|  | Elastic Beanstalk |
|  +---------------+ |
+-------------------+

2. EC2 (Elastic Compute Cloud)

EC2 est le service AWS qui permet de provisionner des serveurs virtuels sur la cloud. Vous pouvez configurer ces instances pour exécuter n'importe quel système d'exploitation et installer n'importe quelle application.

Schéma mental :

+-------------------+
|  +---------------+ |
|  |   EC2 Instance  | |
|  +---------------+ |
|                   |
|  +---------------+ |
|  |   Application | |
|  +---------------+ |
+-------------------+

3. RDS (Relational Database Service)

RDS est un service de base de données gérée qui vous permet d'automatiser le déploiement, la maintenance et l'échellement des bases de données relationnelles.

Schéma mental :

+-------------------+
|  +---------------+ |
|  |   RDS Database  | |
|  +---------------+ |
|                   |
|  +---------------+ |
|  |   Express.js    | |
|  +---------------+ |
+-------------------+

4. S3 (Simple Storage Service)

S3 est un service d'objets de stockage à grande échelle. Vous pouvez utiliser S3 pour stocker des fichiers statiques, des images, des vidéos ou même des bases de données en format JSON.

Schéma mental :

+-------------------+
|  +---------------+ |
|  |   S3 Bucket     | |
|  +---------------+ |
|                   |
|  +---------------+ |
|  |   Express.js    | |
|  +---------------+ |
+-------------------+

5. IAM (Identity and Access Management)

IAM est un service AWS qui vous permet de gérer les identités et les autorisations des utilisateurs, des groupes et des entités dans votre organisation.

Schéma mental :

+-------------------+
|  +---------------+ |
|  |   IAM User      | |
|  +---------------+ |
|                   |
|  +---------------+ |
|  |   IAM Role      | |
|  +---------------+ |
|                   |
|  +---------------+ |
|  |   Express.js    | |
|  +---------------+ |
+-------------------+

6. Elastic Beanstalk

Elastic Beanstalk est un service de déploiement et d'extension automatique pour les applications web et mobiles. Il vous permet de déployer des applications Express.js avec une seule commande.

Schéma mental :

+-------------------+
|  +---------------+ |
|  |   Elastic Beanstalk Environment | |
|  +---------------+ |
|                   |
|  +---------------+ |
|  |   Express.js    | |
|  +---------------+ |
+-------------------+

Mise en pratique : projet fil rouge

Dans cette section, nous allons créer un gestionnaire de tâches simple avec Express.js et le déployer sur AWS Elastic Beanstalk. Nous utiliserons une base de données MySQL pour stocker les tâches.

Étape 1 : Création du projet

Créez un nouveau répertoire pour votre projet et initialisez un nouveau projet Node.js :

mkdir task-manager
cd task-manager
npm init -y

Ajoutez Express.js et MySQL comme dépendances :

npm install express mysql2 body-parser dotenv

Étape 2 : Configuration de l'application

Créez un fichier app.js avec le code suivant :

// app.js
const express = require('express');
const bodyParser = require('body-parser');
require('dotenv').config();

const app = express();
const port = process.env.PORT || 3000;

// Middleware pour parser les requêtes JSON
app.use(bodyParser.json());

// Connexion à la base de données MySQL
const mysql = require('mysql2/promise');

async function connectToDatabase() {
  const connection = await mysql.createConnection({
    host: process.env.DB_HOST,
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_NAME
  });
  return connection;
}

// Route pour créer une nouvelle tâche
app.post('/tasks', async (req, res) => {
  const { title, description } = req.body;

  try {
    const connection = await connectToDatabase();
    const [result] = await connection.execute('INSERT INTO tasks (title, description) VALUES (?, ?)', [title, description]);
    res.status(201).json({ id: result.insertId });
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Failed to create task' });
  }
});

// Route pour récupérer toutes les tâches
app.get('/tasks', async (req, res) => {
  try {
    const connection = await connectToDatabase();
    const [rows] = await connection.execute('SELECT * FROM tasks');
    res.json(rows);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Failed to fetch tasks' });
  }
});

// Démarrer le serveur
app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

Étape 3 : Configuration des variables d'environnement

Créez un fichier .env à la racine de votre projet et ajoutez les informations suivantes :

PORT=3000
DB_HOST=localhost
DB_USER=root
DB_PASSWORD=password
DB_NAME=task_manager

Étape 4 : Création de la base de données

Créez une base de données MySQL nommée task_manager et un table tasks :

CREATE DATABASE task_manager;

USE task_manager;

CREATE TABLE tasks (
  id INT AUTO_INCREMENT PRIMARY KEY,
  title VARCHAR(255) NOT NULL,
  description TEXT
);

Étape 5 : Déploiement sur AWS Elastic Beanstalk

1. Installez l'AWS CLI et configurez-la avec votre compte AWS.
2. Créez une application Elastic Beanstalk :

eb init -p node.js-14.x my-task-manager-app --region us-west-2

3. Créez un environnement Elastic Beanstalk :

eb create my-task-manager-env

4. Déployez votre application :

eb deploy

5. Une fois le déploiement terminé, vous pouvez accéder à votre application en utilisant l'URL fournie par AWS.

Erreurs frequentes et debugging

1. Erreur : Error: listen EADDRINUSE: address already in use

Code incorrect :

app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

Code correct :

const server = app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

process.on('SIGINT', () => {
  server.close(() => {
    console.log('Server is closing');
    process.exit(0);
  });
});

2. Erreur : Error: connect ECONNREFUSED 127.0.0.1:3306

Code incorrect :

const connection = await mysql.createConnection({
  host: 'localhost',
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME
});

Code correct :

const connection = await mysql.createConnection({
  host: process.env.DB_HOST,
  port: 3306, // Ajoutez le port si nécessaire
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME
});

3. Erreur : Error: connect ECONNREFUSED 54.240.198.247:3306

Code incorrect :

const connection = await mysql.createConnection({
  host: 'my-database-instance.us-west-2.rds.amazonaws.com',
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME
});

Code correct :

const connection = await mysql.createConnection({
  host: process.env.DB_HOST,
  port: 3306, // Ajoutez le port si nécessaire
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME
});

Pour aller plus loin

1. Utiliser Docker pour le déploiement

Docker permet de créer des conteneurs standardisés qui facilitent le déploiement sur AWS ECS ou EKS.

2. Ajouter une authentification JWT

Pour sécuriser votre API, ajoutez l'authentification JSON Web Token (JWT) avec Passport.js.

3. Utiliser AWS Lambda et API Gateway

AWS Lambda permet d'exécuter des fonctions en réponse à des événements sans gérer la mise à l'échelle des serveurs.

Défi pratique :

Créez une fonction AWS Lambda qui utilise Express.js pour exposer une API pour ajouter, récupérer et supprimer des tâches. Déployez cette fonction sur AWS Lambda et configurez API Gateway pour exposer les endpoints de votre API.

Ce tutoriel vous a permis de comprendre comment déployer un application Express.js sur AWS Elastic Beanstalk. Vous avez également appris à gérer des erreurs courantes et à approfondir vos connaissances en utilisant d'autres services AWS.