Partager:
){kind=small}
Diana est défenseur des développeurs chez Vonage. Elle aime manger des huîtres fraîches.
Travailler avec des variables d'environnement en Java
Temps de lecture : 7 minutes
Les variables d'environnement (parfois appelées "env vars") sont des variables que vous stockez en dehors de votre programme et qui peuvent affecter son fonctionnement. Vous pouvez ensuite utiliser cette valeur pour modifier le comportement des programmes, des applications et des services. Les applications traitent les variables d'environnement comme des valeurs fixes pendant l'exécution plutôt que comme des variables mutables (une valeur qui peut changer). Elles sont particulièrement utiles pour les valeurs que vous devriez normalement coder en dur, mais que vous ne devriez pas inclure dans votre code, soit parce qu'elles changent d'un environnement à l'autre, soit parce qu'elles sont sensibles, comme les clés d'API ou les mots de passe. Cela permet à votre code d'être portable, plus facile à gérer, et de protéger les secrets dans des environnements moins sûrs, tels que le développement ou les tests.
Dans ce billet de blog, vous apprendrez ce que sont les variables d'environnement, pourquoi elles sont importantes dans les applications Java, les cas d'utilisation courants et comment les définir et y accéder dans différents environnements.
- Connaissance de base de Java
- Un IDE comme IntelliJ IDEA ou Eclipse
- Un Account Vonage
To complete this tutorial, you will need a Vonage API account. If you don’t have one already, you can sign up today and start building with free credit. Once you have an account, you can find your API Key and API Secret at the top of the Vonage API Dashboard.
Les variables d'environnement peuvent être utilisées de différentes manières :
stocker les clés d'API, les mots de passe et les jetons en toute sécurité en dehors du code.
passer d'une configuration à l'autre entre le développement, les tests, la mise en scène et la production.
exécuter le même code sur plusieurs machines ou conteneurs sans modification.
définir des variables telles que
PATHouJAVA_HOME.
Les informations sensibles telles que les clés d'API, les mots de passe de base de données ou les jetons d'authentification peuvent être stockées dans des variables d'environnement (par ex, API_KEY ou DB_PASSWORD).
Le fait de garder les secrets en dehors du code source réduit les risques de sécurité et empêche les fuites accidentelles dans le contrôle de version. Cela facilite également la rotation des clés ou des mots de passe, puisqu'il suffit de modifier un seul fichier.
En Java, une clé API Vonage peut être stockée sous forme de variable d'environnement, telle que VONAGE_API_KEY. Vous y accéderez dans le code avec System.getenv("VONAGE_API_KEY")en veillant à ce que la clé ne soit pas intégrée directement dans l'application.
Les variables d'environnement, telles que ENV_MODE ou APP_ENV, peuvent indiquer si l'application s'exécute dans un environnement de développement, de test, de staging ou de production.
Cela permet aux applications d'ajuster automatiquement leur comportement en fonction du contexte. Par exemple, en mode développement, vous pouvez activer la journalisation verbeuse, alors qu'en mode production, ces journaux sont minimisés pour des raisons de performance.
Une application Java peut vérifier System.getenv("ENV_MODE") pour choisir la bonne chaîne de connexion à la base de données ou pour activer/désactiver les outils de débogage en fonction de l'environnement.
En maintenant les variables d'environnement en dehors du code, la même base de code peut être déployée sur différentes machines, serveurs ou conteneurs sans modification.
Cela facilite le déplacement et la mise à l'échelle des applications, en particulier dans les configurations conteneurisées comme Docker ou Kubernetes, puisqu'il suffit d'ajuster les valeurs des variables d'environnement sans toucher au code source.
Une application Java conteneurisée peut définir des variables d'environnement pour les identifiants de base de données et les URL de service. Que le conteneur fonctionne localement ou en production, le même code fonctionne parce qu'il lit l'environnement.
Les variables d'environnement telles que PATH ou JAVA_HOME précisent l'emplacement au niveau du système des exécutables, des bibliothèques ou des environnements d'exécution.
Cela permet aux outils et aux Applications de fonctionner de manière cohérente sans avoir à coder en dur l'emplacement des fichiers. Elle est particulièrement utile lorsqu'un logiciel est exécuté sur plusieurs plates-formes, chacune ayant des structures de répertoire différentes.
En Java, le paramètre JAVA_HOME permet de s'assurer que l'application sait toujours où trouver le JDK. En lisant les chemins d'accès à partir des variables d'environnement, les développeurs évitent les problèmes liés à la plate-forme et rendent leurs Applications plus portables.
Pour utiliser les variables d'environnement, vous devez d'abord les définir dans votre système ou dans un fichier de configuration, puis accéder à leurs valeurs à partir de votre application au moment de l'exécution.
La meilleure pratique consiste à définir des variables d'environnement dans votre système d'exploitation avant de de démarrer votre application Java. Vous pouvez le faire en ligne de commande ou directement dans un fichier .env.
L'approche la plus courante consiste à définir des variables d'environnement dans votre système d'exploitation avant de lancer votre application Java. Cela peut se faire en ligne de commande ou par le biais de scripts.
Par exemple, dans un environnement Unix, vous pouvez définir une variable d'environnement dans le terminal comme suit :
Dans l'invite de commande Windows, ce serait :
set MY_VAR=some value
Si vous devez définir des variables d'environnement pour les sous-processus lancés à partir de votre application Java (et non pour le processus Java lui-même), vous pouvez utiliser la classe ProcessBuilder :
ProcessBuilder processBuilder = new ProcessBuilder();
Map<String, String> env = processBuilder.environment();
env.put("MY_VAR", "some value");
Process process = processBuilder.start();
Si vous utilisez un environnement de développement intégré (IDE) comme IntelliJ IDEA ou Eclipsevous pouvez définir des variables d'environnement dans les paramètres de configuration de votre application.
Lorsque l'on utilise des outils de construction tels que Maven ou Gradlevous pouvez configurer des variables d'environnement dans les scripts de construction ou les fichiers de configuration.
Puisque java.util.Properties met en œuvre l'interface Map, vous pouvez charger n'importe quel fichier qui met en correspondance des paires clé-valeur de cette manière, quelle que soit son extension :
var props = new Properties();
var envFile = Paths.get("/path/to/MyEnvConfig.env");
try (var inputStream = Files.newInputStream(envFile)) {
props.load(inputStream);
}
String apiKey = props.get("VONAGE_API_KEY");
String apiSecret = props.get("VONAGE_API_SECRET");
L'accès aux variables d'environnement en Java est simple et peut se faire à l'aide de la classe System qui est fournie par la bibliothèque Java standard. Voici un guide simple sur la façon de procéder :
Obtenir une seule variable d'environnement: Utilisez la méthode System.getenv(String name) pour récupérer la valeur d'une variable d'environnement spécifique. Par exemple, pour accéder à une variable d'environnement nommée API_KEYvous utiliseriez :
String apiKey = System.getenv("API_KEY");Vérifier les valeurs nulles: Il est conseillé de vérifier si la variable d'environnement est nulle (c'est-à-dire qu'elle n'est pas définie) afin d'éviter d'éventuelles erreurs de saisie. NullPointerExceptions. Par exemple :
String apiKey = Optional.ofNullable(System.getenv("API_KEY")).orElse(otherValue);Ici, otherValue est la valeur de repli. Si vous préférez échouer rapidement lorsque la variable d'environnement est manquante, vous pouvez lancer une exception à la place :
Optional.ofNullable(System.getenv("API_KEY")).orElseThrow(() -> new IllegalStateException("API_KEY env var is not defined"));
Obtenir toutes les variables d'environnement: Pour obtenir une Map<String, String> de toutes les variables d'environnement, utilisez System.getenv(). Cette fonction est utile si vous souhaitez passer en revue toutes les variables d'environnement disponibles. Par exemple :
Map<String, String> envVars = System.getenv();
for (String envName : envVars.keySet()) {
System.out.format("%s=%s%n", envName, envVars.get(envName));`
}
Il est également possible de l'écrire en une seule ligne :
System.getenv().forEach((k, v) -> System.out.println(k+"="+v));
Obtenir et définir des variables d'environnement est un élément essentiel de la création d'un logiciel de production. Si vous avez atteint la fin de cet article, vous savez maintenant ce que sont les variables d'environnement, les cas d'utilisation, comment obtenir et définir des variables d'environnement, et comment utiliser les fichiers .env en Java. La participation de la communauté est toujours la bienvenue. N'hésitez pas à nous rejoindre sur GitHub et sur Communauté Vonage Slack. Avez-vous d'autres bonnes pratiques utilisant des variables d'environnement ? Partagez-les et taguez-moi. J'aimerais beaucoup en savoir plus !