Validation des variables d'environnement avec Joi dans NodeJS

Imaginez que vous êtes sur la dernière étape d'un projet, que tout est prêt à être mis en ligne, et boum ! L'application plante car une variable d'environnement est manquante ou mal configurée. Cela vous semble familier ? Si vous y êtes allé, vous connaissez la frustration. Mais n'ayez crainte, car Joi est là pour sauver la situation !

Dans cet article de blog, nous explorerons comment utiliser Joi pour valider les variables d'environnement et définir des valeurs par défaut, garantissant ainsi le bon fonctionnement de votre application dans tous les environnements.

Le problème

Les variables d'environnement sont comme les héros méconnus de nos applications. Ils détiennent les clés des informations sensibles, des connexions aux bases de données et de divers paramètres de configuration. Mais un grand pouvoir implique de grandes responsabilités :

• Variables manquantes : « Pourquoi mon application ne se connecte-t-elle pas à la base de données ? » Oups, j'ai oublié de définir DATABASE_URL.
• Types de données incorrects : « Pourquoi mon serveur écoute-t-il sur le port « trois mille » ? » Faute de frappe dans la variable PORT.
• Configuration incohérente : Le développement fonctionne bien, mais la production est un cauchemar.
• Manque de valeurs par défaut : L'application échoue si certaines variables ne sont pas définies.

Ces problèmes peuvent conduire à des nuits blanches et à des sessions de débogage effrénées. Mais et si vous pouviez les éviter complètement ?

Entre Joi

Joi est une puissante bibliothèque de description de schéma et de validation de données pour JavaScript. Avec Joi, vous pouvez définir un schéma pour vos variables d'environnement, en vous assurant qu'elles répondent à des critères spécifiques et en définissant des valeurs par défaut si nécessaire.

Étapes pour valider et définir les valeurs par défaut avec Joi

1. Installez Joi & dotenv
Tout d’abord, vous devez installer Joi. Ouvrez votre terminal et exécutez :

npm install joi dotenv
# dotenv if you are reading env variables from .env file

2. Créer un fichier de configuration
Créez un fichier appelé config.js. C'est ici que nous définirons notre schéma et validerons les variables d'environnement.

const Joi = require('joi');
const dotenv = require('dotenv');

// Load environment variables from .env file
dotenv.config();

// Define the schema
const envSchema = Joi.object({
  NODE_ENV: Joi.string().valid('development', 'production', 'test')
    .default('development'),
  PORT: Joi.number().default(3000),
  DATABASE_URL: Joi.string().uri().required(),
  API_KEY: Joi.string().required(),
  // Add more variables as needed
}).unknown(); // Allow unknown keys

// Validate the environment variables
const { error, value: envVars } = envSchema.validate(process.env, 
  { abortEarly: false }
);

if (error) {
  console.error('Config validation error(s):');
  error.details.forEach(detail => {
    console.error(`- ${detail.message}`);
  });
  throw new Error('Environment variables validation failed.');
}

// Export the validated and normalized environment variables
module.exports = {
  nodeEnv: envVars.NODE_ENV,
  port: envVars.PORT,
  databaseUrl: envVars.DATABASE_URL,
  apiKey: envVars.API_KEY,
  // Add more variables as needed
};

3. Utilisez la configuration dans votre application

const config = require('./config');

console.log(`Server is running on port ${config.port}`);
// Use config.databaseUrl, config.apiKey, etc.

Exemple avec erreurs
Disons que nous avons le fichier .env suivant :

NODE_ENV=development
PORT=not_a_number
DATABASE_URL=
API_KEY=my_api_key

Lorsque nous exécuterons notre application, Joi validera ces variables. Voici ce qui se passe :

1. PORT est défini sur not_a_number, ce qui n'est pas un numéro valide.
2. DATABASE_URL est vide, ce qui n'est pas valide car il s'agit d'un champ obligatoire.

Lorsque Joi valide ces variables, des erreurs seront générées.

jaimin:~/joi-validate-env$ node index.js
Config validation error(s):
- "PORT" must be a number
- "DATABASE_URL" is not allowed to be empty
/home/jaimin/joi-validate-env/config.js:27
  throw new Error('Environment variables validation failed.');
  ^

Error: Environment variables validation failed.
    at Object.<anonymous> (/home/jaimin/joi-validate-env/config.js:27:9)
    at Module._compile (node:internal/modules/cjs/loader:1376:14)
    at Module._extensions..js (node:internal/modules/cjs/loader:1435:10)
    at Module.load (node:internal/modules/cjs/loader:1207:32)
    at Module._load (node:internal/modules/cjs/loader:1023:12)
    at Module.require (node:internal/modules/cjs/loader:1235:19)
    at require (node:internal/modules/helpers:176:18)
    at Object.<anonymous> (/home/jaimin/joi-validate-env/index.js:1:16)
    at Module._compile (node:internal/modules/cjs/loader:1376:14)
    at Module._extensions..js (node:internal/modules/cjs/loader:1435:10)

Ce rapport d'erreurs détaillé permet d'identifier et de résoudre rapidement les problèmes de configuration de l'environnement.

Pourquoi utiliser Joi ?

1. Cohérence
Fini les moments « fonctionne sur ma machine ». Joi garantit que toutes les variables d'environnement nécessaires sont définies et ont des types corrects dans différents environnements.

2. Valeurs par défaut
Définissez des valeurs par défaut pour les variables, réduisant ainsi le risque d'erreurs d'exécution dues à des paramètres manquants.

3. Détection précoce des erreurs
Détectez les erreurs de configuration dès le début de la phase de démarrage, empêchant l'application de s'exécuter avec des paramètres non valides.

4. Documentation du schéma
Agit comme un schéma auto-documenté pour les variables d'environnement, permettant aux nouveaux développeurs de comprendre plus facilement la configuration requise.

5. Flexibilité
Permet une logique de validation complexe, telle que des plages de valeurs, des formats spécifiques et des fonctions de validation personnalisées.

Conclusion

Utiliser Joi pour valider les variables d'environnement et définir les valeurs par défaut, c'est comme avoir un filet de sécurité pour votre application. Il garantit le bon fonctionnement de votre application dans tous les environnements, vous évitant ainsi des plantages inattendus et des heures de débogage.

En adoptant cette approche, vous pouvez éviter les pièges courants liés aux variables d'environnement et vous concentrer sur la création de fonctionnalités qui ajoutent de la valeur à vos utilisateurs. Alors n'hésitez plus, intégrez Joi à votre projet et dormez sur vos deux oreilles en sachant que vos variables d'environnement sont entre de bonnes mains.

Bon codage !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!