Déploiement sur Heroku

Mettez votre API RESTful de tâches en ligne ! Ce guide détaille la préparation et le déploiement de votre application Node.js/Express/MongoDB sur la plateforme PaaS Heroku.

Mettre notre API en ligne : Découverte du déploiement sur Heroku

Félicitations ! Nous avons conçu, implémenté, testé et documenté notre API RESTful de gestion de tâches. Elle fonctionne parfaitement sur notre machine locale, mais pour qu'elle soit réellement utile et accessible (par exemple, pour être consommée par une application frontend ou mobile), nous devons la déployer sur un serveur accessible depuis internet.

Pour ce projet, nous allons utiliser Heroku, une Plateforme en tant que Service (PaaS - Platform as a Service) très populaire et particulièrement adaptée pour démarrer rapidement. Heroku simplifie considérablement le processus de déploiement en abstrayant une grande partie de la gestion de l'infrastructure serveur. Il nous suffit de préparer légèrement notre code, de le pousser via Git, et Heroku s'occupe du reste : provisionnement des serveurs, installation des dépendances, démarrage de l'application et exposition sur une URL publique.

Cette dernière étape du projet nous guidera à travers la préparation de notre application Node.js pour un environnement de production et son déploiement effectif sur Heroku.

Préparation de l'application pour Heroku

Avant de déployer, nous devons apporter quelques ajustements à notre application pour qu'elle fonctionne correctement dans l'environnement Heroku :

Configuration du Port : Heroku assigne dynamiquement un port à notre application via la variable d'environnement `process.env.PORT`. Nous devons nous assurer que notre serveur Express écoute sur ce port. Notre fichier `src/server.js` le fait déjà grâce à cette ligne :
```
const port = process.env.PORT || 3000;
```
Cette ligne utilise le port fourni par Heroku s'il existe, sinon elle utilise le port 3000 (pour le développement local).
Script de Démarrage (`start`) : Heroku utilise le script `npm start` défini dans `package.json` pour lancer l'application après le déploiement. Assurons-nous qu'il est correctement défini :
```
// package.json (section scripts)
"scripts": {
  "start": "node src/server.js", // Utilisé par Heroku
  "dev": "nodemon src/server.js",
  "test": "jest --watchAll --runInBand"
}
```
Version de Node.js (`engines`) : Il est fortement recommandé de spécifier la version de Node.js (et éventuellement npm) que notre application utilise, afin qu'Heroku utilise la même version lors du build. Ajoutez une section `engines` à votre `package.json` :
```
// package.json (ajout à la racine)
"engines": {
  "node": "18.x" // Spécifiez la version LTS que vous utilisez
}
```
Configuration de la Base de Données : Notre URL MongoDB locale (`mongodb://127.0.0.1:27017/...`) ne fonctionnera pas sur Heroku. Nous devons utiliser une base de données MongoDB hébergée dans le cloud. MongoDB Atlas propose un niveau gratuit idéal pour démarrer.
- Créez un compte sur MongoDB Atlas (https://www.mongodb.com/cloud/atlas).
- Créez un cluster gratuit.
- Configurez l'accès réseau pour autoriser les connexions depuis n'importe où (`0.0.0.0/0`) ou spécifiquement depuis Heroku (plus complexe).
- Créez un utilisateur de base de données avec un mot de passe.
- Obtenez l'URL de connexion pour les applications (elle ressemblera à `mongodb+srv://username:password@clustername.mongodb.net/database-name?retryWrites=true&w=majority`).
- Cette URL de connexion sera configurée sur Heroku via les 'Config Vars' (variables d'environnement Heroku), pas dans le fichier `.env` versionné. Notre code (`src/db/mongoose.js`) lit déjà `process.env.MONGODB_URL`, il fonctionnera donc avec la variable Heroku.
Dépendances : Assurez-vous que toutes les dépendances nécessaires à l'exécution (comme `express`, `mongoose`) sont bien dans les `dependencies` de `package.json` et non dans les `devDependencies` (Heroku n'installe que les `dependencies` par défaut en production en exécutant `npm install --production` ou l'équivalent `npm ci`).
Fichier `Procfile` (Optionnel mais recommandé) : Bien qu'Heroku puisse souvent déduire la commande de démarrage depuis `npm start`, il est plus explicite de créer un fichier nommé `Procfile` (sans extension) à la racine du projet avec le contenu suivant :
```
web: node src/server.js
```
Cela indique explicitement à Heroku comment lancer le processus web de notre application.

Configuration de Heroku et déploiement

Maintenant que notre application est prête, passons à Heroku :

Installer Heroku CLI : Si ce n'est pas déjà fait, téléchargez et installez l'interface en ligne de commande Heroku depuis le site officiel (https://devcenter.heroku.com/articles/heroku-cli).
Se Connecter : Ouvrez votre terminal et connectez-vous à votre compte Heroku :
```
heroku login
```
Suivez les instructions pour vous authentifier via le navigateur.
Initialiser Git (si pas déjà fait) : Assurez-vous que votre projet est un dépôt Git et que tous vos changements sont commités :
```
git init # Si pas déjà fait
git add .
git commit -m "Préparation pour déploiement Heroku"
```
Créer l'application Heroku : Depuis le répertoire de votre projet, créez une nouvelle application sur Heroku :
```
heroku create mon-api-taches-unique # Choisissez un nom unique, ou laissez Heroku en générer un
```
Cette commande crée l'application sur Heroku et ajoute automatiquement un remote Git nommé `heroku` à votre dépôt local.
Configurer les Variables d'Environnement (Config Vars) : C'est ici que nous allons définir notre URL de connexion MongoDB Atlas. Remplacez l'URL par la vôtre :
```
heroku config:set MONGODB_URL="mongodb+srv://votre_user:votre_motdepasse@votre_cluster.mongodb.net/votre_db_name?retryWrites=true&w=majority"
```
Si vous avez d'autres variables d'environnement nécessaires en production (clés API tierces, etc.), ajoutez-les de la même manière avec `heroku config:set CLE=VALEUR`. Vous pouvez vérifier les variables configurées avec `heroku config`.
Déployer le Code : Il suffit maintenant de pousser votre code vers le remote Heroku :
```
git push heroku main # Ou le nom de votre branche principale (ex: master)
```

Heroku va alors :

Détecter qu'il s'agit d'une application Node.js (grâce au `package.json`).
Lire la version de Node.js spécifiée dans `engines`.
Installer les dépendances de production (`npm ci` ou `npm install --production`).
Exécuter le script de build s'il est défini (`heroku-postbuild`).
Lancer l'application en utilisant la commande définie dans le `Procfile` ou le script `npm start`.

Le processus de build et de déploiement sera affiché dans votre terminal.

Vérification et gestion de l'application déployée

Une fois le déploiement terminé, Heroku vous donnera l'URL publique de votre application. Vous pouvez également utiliser les commandes Heroku CLI pour interagir avec votre application déployée :

Ouvrir l'application dans le navigateur :
```
heroku open
```
Cela ouvrira l'URL racine. Vous devrez ajouter `/tasks` ou l'URL de votre documentation `/api-docs` pour voir quelque chose.
Consulter les logs en temps réel : Très utile pour le débogage !
```
heroku logs --tail
```
Si votre application ne démarre pas ou si vous rencontrez des erreurs 503 (Service Unavailable), les logs sont le premier endroit où chercher des indices (problèmes de connexion à la base de données, erreurs dans le code, crash au démarrage).

Exécuter une commande ponctuelle (ex: pour une migration ou un REPL) :

heroku run bash # Ouvre un shell sur un dyno temporaire
heroku run node # Lance un REPL Node.js

Redémarrer l'application :
```
heroku restart
```

Testez vos endpoints (via Postman, Insomnia, ou votre documentation Swagger UI maintenant accessible publiquement à `VOTRE_URL_HEROKU/api-docs`) pour vous assurer que tout fonctionne comme prévu avec la base de données Atlas.

Félicitations ! Vous avez déployé avec succès votre première API RESTful Node.js sur Heroku. Vous pouvez maintenant partager son URL et l'utiliser comme backend pour vos projets frontend ou mobiles.

◄ Précédent Suivant ►

く