Déploiement

Introduction à Railway

Railway est une plateforme moderne de déploiement qui simplifie considérablement le processus de mise en ligne d'applications. Contrairement à d'autres plateformes, Railway est conçue pour être simple et intuitive, tout en offrant des fonctionnalités puissantes pour les développeurs.

Avantages de Railway

Simplicité : Déploiement en quelques clics ou commandes
Intégration GitHub : Déploiement automatique à partir de votre dépôt
Services managés : Bases de données, files d'attente et autres services facilement intégrables
Variables d'environnement : Gestion simple des configurations
Scaling automatique : S'adapte aux besoins de votre application
Monitoring : Surveillance des performances et des logs
Prévisualisation des déploiements : Environnements de prévisualisation pour les pull requests

Préparation de votre application Node.js

Avant de déployer votre application sur Railway, vous devez vous assurer qu'elle est prête pour un environnement de production.

Configuration du port

Votre application doit écouter sur le port fourni par Railway via la variable d'environnement PORT :

import express from 'express';

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

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

Script de démarrage

Assurez-vous que votre package.json contient un script start qui sera utilisé par Railway pour démarrer votre application :

{
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js"
  }
}

Procfile (optionnel)

Vous pouvez spécifier les commandes à exécuter au démarrage dans un fichier Procfile à la racine de votre projet :

web: npm start

Gestion des variables d'environnement

Pour les variables d'environnement sensibles, comme les clés API ou les informations de connexion à la base de données, vous devrez les configurer dans Railway plutôt que de les coder en dur dans votre application.

Utilisez un package comme dotenv pour charger ces variables en développement :

import dotenv from 'dotenv';

if (process.env.NODE_ENV !== 'production') {
  dotenv.config();
}

// Utilisez ensuite process.env.MA_VARIABLE

Déploiement manuel sur Railway

Création d'un compte Railway

Allez sur Railway.app et créez un compte. Vous pouvez vous connecter avec GitHub pour faciliter l'intégration.

Déploiement depuis GitHub

Dans le dashboard Railway, cliquez sur "New Project".
Sélectionnez "Deploy from GitHub repo".
Choisissez votre dépôt dans la liste.
Railway détectera automatiquement qu'il s'agit d'une application Node.js et configurera le déploiement en conséquence.
Une fois le déploiement terminé, cliquez sur "Settings" pour configurer les variables d'environnement nécessaires.

Déploiement avec Railway CLI

Vous pouvez aussi utiliser la CLI Railway pour plus de flexibilité :

Installez la CLI Railway :
```
npm i -g @railway/cli
```
Connectez-vous à votre compte Railway :
```
railway login
```
Initialisez votre projet :
```
railway init
```
Déployez votre application :
```
railway up
```

Automatisation du déploiement avec GitHub Actions

Pour automatiser le déploiement de votre application sur Railway à chaque nouvelle version, vous pouvez intégrer Railway dans votre workflow GitHub Actions.

Configuration du token Railway

Obtenez un token API Railway en exécutant :
```
railway login
```
Copiez le token affiché ou récupérez-le depuis les paramètres de votre compte Railway.
Dans votre dépôt GitHub, allez dans Settings > Secrets and variables > Actions et ajoutez un nouveau secret nommé RAILWAY_TOKEN avec la valeur du token.

Workflow de déploiement

Créez un fichier .github/workflows/deploy.yml :

name: Deploy to Railway

on:
  release:
    types: [created]

jobs:
  deploy:
    runs-on: ubuntu-latest
    
    steps:
      - name: Checkout
        uses: actions/checkout@v3
      
      - name: Use Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Build
        run: npm run build --if-present
      
      - name: Install Railway CLI
        run: npm i -g @railway/cli
      
      - name: Deploy to Railway
        env:
          RAILWAY_TOKEN: ${{ secrets.RAILWAY_TOKEN }}
        run: railway up --detach

Ce workflow s'exécute automatiquement lorsqu'une nouvelle release est créée (par exemple par Semantic Release), garantissant que la dernière version stable de votre application est toujours déployée.

Intégration avec Semantic Release

Vous pouvez aussi ajouter l'étape de déploiement directement dans votre workflow de release :

name: Release and Deploy

on:
  push:
    branches: [main]

jobs:
  release:
    # ... (étapes de Semantic Release comme vu précédemment)
    
    - name: Install Railway CLI
      if: steps.semantic.outputs.new_release_published == 'true'
      run: npm i -g @railway/cli
    
    - name: Deploy to Railway
      if: steps.semantic.outputs.new_release_published == 'true'
      env:
        RAILWAY_TOKEN: ${{ secrets.RAILWAY_TOKEN }}
      run: railway up --detach

Cette configuration ne déploie que lorsqu'une nouvelle version est effectivement publiée par Semantic Release.

Déploiement multi-environnements

Railway permet de déployer facilement plusieurs environnements pour votre application (développement, staging, production).

Configuration des environnements

Créez différents projets dans Railway pour chaque environnement.
Dans votre workflow GitHub Actions, déployez sur l'environnement approprié en fonction de la branche :

jobs:
  deploy:
    runs-on: ubuntu-latest
    
    steps:
      # ... (étapes précédentes)
      
      - name: Deploy to Dev
        if: github.ref == 'refs/heads/develop'
        env:
          RAILWAY_TOKEN: ${{ secrets.RAILWAY_TOKEN }}
        run: railway up --service ${{ secrets.RAILWAY_SERVICE_DEV }} --detach
      
      - name: Deploy to Production
        if: github.ref == 'refs/heads/main'
        env:
          RAILWAY_TOKEN: ${{ secrets.RAILWAY_TOKEN }}
        run: railway up --service ${{ secrets.RAILWAY_SERVICE_PROD }} --detach

Prévisualisation des pull requests

Railway offre une fonctionnalité de "Preview Environments" qui crée automatiquement un environnement temporaire pour chaque pull request.

Pour configurer cette fonctionnalité :

Dans votre projet Railway, allez dans Settings > GitHub.
Activez "Preview Environments".
Sélectionnez le dépôt et les branches pour lesquelles vous souhaitez activer cette fonctionnalité.

Surveillance et monitoring

Une fois votre application déployée, vous devez surveiller ses performances et son comportement en production.

Logs et monitoring dans Railway

Railway fournit des outils intégrés pour consulter les logs et surveiller les performances de votre application :

Dans le dashboard de votre projet Railway, cliquez sur votre service.
Allez dans l'onglet "Metrics" pour voir les performances.
Allez dans l'onglet "Logs" pour consulter les logs en temps réel.

Intégration avec des services de monitoring externes

Vous pouvez également intégrer des services de monitoring externes comme Sentry ou New Relic :

import * as Sentry from '@sentry/node';

Sentry.init({
  dsn: process.env.SENTRY_DSN,
  environment: process.env.NODE_ENV
});

// Le reste de votre code d'initialisation d'application

Gestion des bases de données

Si votre application utilise une base de données, Railway offre plusieurs options intégrées :

Dans le dashboard Railway, cliquez sur "New".
Sélectionnez le type de base de données que vous souhaitez utiliser (PostgreSQL, MySQL, MongoDB, Redis).
Une fois créée, Railway générera automatiquement les variables d'environnement nécessaires pour se connecter à la base de données.

Migrations et seeders

Pour les migrations de base de données, vous pouvez utiliser les outils spécifiques à votre ORM ou à votre base de données :

Prisma : Exécutez les migrations lors du déploiement en ajoutant une commande dans votre Procfile :
```
web: npx prisma migrate deploy && npm start
```
Autres ORM : Adaptez la commande en fonction de votre ORM (Sequelize, TypeORM, etc.).

Conseils pour un déploiement réussi

Testez localement avant de déployer : Utilisez railway run pour exécuter votre application avec les mêmes variables d'environnement que sur Railway.
Utilisez des health checks : Ajoutez un endpoint /health qui retourne un statut 200 pour permettre à Railway de vérifier que votre application est en bon état.
Configurez le scaling approprié : Ajustez les ressources allouées à votre application en fonction de vos besoins (CPU, mémoire).
Automatisez tout : Utilisez GitHub Actions pour automatiser non seulement le déploiement mais aussi les tests, les migrations, etc.
Surveillez les coûts : Railway propose un plan gratuit généreux, mais surveillez votre consommation de ressources pour éviter les surprises.

En suivant ces étapes et conseils, vous aurez mis en place un pipeline de déploiement automatisé complet, de l'écriture du code jusqu'à la mise en production sur Railway. Cette approche DevOps moderne vous permettra de livrer des fonctionnalités plus rapidement et avec plus de confiance.

Introduction à Railway​

Avantages de Railway​

Préparation de votre application Node.js​

Configuration du port​

Script de démarrage​

Procfile (optionnel)​

Gestion des variables d'environnement​

Déploiement manuel sur Railway​

Création d'un compte Railway​

Déploiement depuis GitHub​

Déploiement avec Railway CLI​

Automatisation du déploiement avec GitHub Actions​

Configuration du token Railway​

Workflow de déploiement​

Intégration avec Semantic Release​

Déploiement multi-environnements​

Configuration des environnements​

Prévisualisation des pull requests​

Surveillance et monitoring​

Logs et monitoring dans Railway​

Intégration avec des services de monitoring externes​

Gestion des bases de données​

Migrations et seeders​

Conseils pour un déploiement réussi​