Variables d'environnement sous Linux. Variable d'environnement PATH Comment ajouter un programme au chemin linux
Ce que c'est? La plupart des commandes que vous entrez sur la ligne de commande nécessitent l'utilisation d'un programme externe chargé à partir du système de fichiers. Par exemple, des commandes telles que mkdir et wc se trouvent en fait dans le dossier /bin.
Lorsque vous entrez une instruction que le shell Bash ne reconnaît pas, il essaie de l'exécuter en tant que programme et renvoie une erreur s'il ne trouve pas de programme portant ce nom. Et cela s'applique non seulement aux commandes de base que nous avons considérées, car à partir de ligne de commande vous pouvez exécuter n'importe quel programme.
Mais comme en présence de système de fichiers Linux sait-il quels programmes exécuter à partir de quels répertoires ? Le système d'exploitation utilise la variable d'environnement système pour spécifier un sous-ensemble de dossiers à consulter lors de la réception d'une commande inconnue. Cette variable s'appelle PATH et peut être affichée avec la commande echo suivante (le symbole $ est obligatoire) :
echo $CHEMIN
La sortie de cette commande ressemblera aux sept chemins de dossier absolus suivants, séparés par des deux-points :
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
Chaque fois que vous saisissez un inconnu Commandes Linux recherchera dans chacun des dossiers spécifiés dans la variable d'environnement, dans l'ordre dans lequel ils sont définis, un programme portant le même nom. Si le programme est trouvé, il est lancé ; sinon, un message d'erreur s'affiche. Mais ce ne sera pas une erreur si vous achetez vos bagues en argent bien-aimées en cadeau. L'argent ornera n'importe quelle femme!
Ces sept dossiers offrent un accès facile à tous les principaux programmes du système d'exploitation, y compris . Tous les programmes en dehors de ces sept dossiers ne peuvent pas être lancés en tapant simplement leur nom sur la ligne de commande.
Par exemple, vous avez téléchargé l'utilitaire de journal depuis Internet vers votre dossier de départ. Si vous entrez son nom sur la ligne de commande, vous obtiendrez une erreur car il se trouve dans un dossier qui n'est pas inclus dans le chemin système. Pour exécuter ce programme, saisissez la ligne suivante (n'oubliez pas que le symbole ~ est un raccourci pour votre dossier personnel) :
Si vous l'avez enregistré dans un dossier en dehors de votre chemin spécifié, vous devrez entrer le chemin absolu et le nom de fichier pour exécuter l'utilitaire.
Bien sûr, le journal est supposé être un simple programme autonome qui ne nécessite pas d'installation, car la plupart des applications majeures placeront l'exécutable du programme quelque part dans votre chemin spécifié pendant le processus d'installation. Comme ça Variable d'environnement PATH, profitez de votre santé !
Variables d'environnement ( variable d'environnement) sont utilisés pour stocker les valeurs communes des variables dans les scripts et les programmes. Ces variables peuvent être définies pour une période de temps, par exemple, pour la période de fonctionnement d'un shell de terminal spécifique, ou pour la période d'une session utilisateur, ou vous pouvez définir une variable d'environnement au niveau global - pour l'ensemble du système .
Variables d'environnement
$MAISON
La variable contient le chemin d'accès au répertoire personnel de l'utilisateur actuel. $USER
Nom d'utilisateur actuel $PATH
Liste des répertoires permettant au shell de rechercher des programmes exécutables. $PWD
Le chemin d'accès au répertoire de travail actuel (ou pwd). Exemple : dir_path=$(pwd) . $SHELL
Interprète par défaut $RANDOM
Génère un nombre aléatoire 0..32767 à chaque accès à la variable. $SECONDES
Temps en sec. depuis le début du shell. $ ? Le résultat de la commande précédente. $HOSTNAME
Nom de l'ordinateur $HISTFILE
Chemin d'accès au fichier d'historique de l'interpréteur $IFS
Liste des caractères séparateurs pour les commandes, paramètres, éléments de tableau (par défaut : espace, tabulation, retour à la ligne) $PS1
Modèle de chaîne d'invite d'interpréteur.
Définir temporairement une variable d'environnement
Définition d'une variable d'environnement pour la période de session :
# Pour un nouveau processus env varname=value [commande] # Pour le shell actuel et tous ses sous-processus export varname=value [commande]
La valeur de la variable est conservée jusqu'au redémarrage du système.
Définition d'une valeur constante
Les variables d'environnement au niveau du système sont définies via le fichier /etc/environment :
ENVIRONNEMENT="dev"
Définition d'une variable d'environnement spécifique à l'utilisateur via ~/.bashrc ou ~/.bash_profile :
CHEMIN="$(CHEMIN):/home/utilisateur/bin :"
Attention!
Le fichier ~/.bash_profile sera exécuté au démarrage de l'interpréteur avec l'option -l. Lorsque vous êtes connecté localement, ce fichier n'est pas lisible !
Vous devez également vous rappeler que les modifications ne prendront effet qu'après le redémarrage de la session !
Affichage de la valeur d'une variable d'environnement
Pour afficher la valeur d'une variable d'environnement, utilisez la commande printenv :
Impressionv<имя_переменной>
#shell, #bash, #environnement
Le SDK AIR contient plusieurs programmes que vous pouvez exécuter à partir de la ligne de commande ou d'une fenêtre de terminal. L'exécution de ces programmes est beaucoup plus pratique si vous définissez le chemin d'accès au répertoire bin du SDK à l'aide de la variable d'environnement Path.
Cette section fournit une description générale de la procédure de définition du chemin sous Windows, Mac et Linux. Cependant, les configurations informatiques peuvent varier considérablement, cette procédure peut ne pas fonctionner sur tous les systèmes. Dans ce cas, les informations dont vous avez besoin se trouvent dans la documentation du système d'exploitation ou sur Internet.
Définition de la variable d'environnement PATH sous Linux et Mac OS à l'aide du shell Bash
Lorsqu'une commande est entrée dans une fenêtre de terminal, le shell (le programme qui lit les commandes entrées et essaie de répondre de manière appropriée) doit d'abord trouver le programme de la commande dans le système de fichiers. Le shell recherche les commandes dans une liste de répertoires, qui est stockée dans une variable d'environnement nommée $PATH. Pour afficher la valeur actuelle de la variable de chemin, saisissez la commande suivante :
echo $CHEMIN
Une liste de répertoires séparés par deux-points s'affichera, quelque chose comme ceci :
/usr/bin:/bin:/usr/sbin:/usr/local/bin:/usr/x11/bin
Le chemin d'accès au répertoire bin du SDK AIR doit être ajouté à cette liste afin que le shell puisse trouver les outils ADT et ADT. Supposons que le SDK AIR se trouve dans le répertoire /Users/fred/SDKs/AIR. Dans ce cas, la commande suivante est utilisée pour ajouter les répertoires requis à la variable d'environnement path :
Exporter PATH=$PATH:/Users/fred/SDKs/AIR/bin:/Users/fred/SDKs/android/tools
Note. Si le chemin contient des caractères d'espacement, ils doivent être précédés d'une barre oblique inverse, comme indiqué ci-dessous :
/Users/fred\ jones/SDK/AIR\ 2.5\ SDK/bin
Pour vérifier les résultats de l'ajout, vous pouvez relancer la commande echo :
Echo $PATH /usr/bin:/bin:/usr/sbin:/usr/local/bin:/usr/x11/bin:/Users/fred/SDKs/AIR/bin:/Users/fred/SDKs/android/ outils
Répertoires ajoutés avec succès. Vous pouvez maintenant appeler les commandes suivantes et obtenir la bonne réponse :
Version adt
Si la variable d'environnement $PATH a été modifiée correctement, la commande doit afficher la version de l'environnement ADT.
Cependant, il y a un problème : lorsque vous ouvrez une nouvelle fenêtre de terminal, vous remarquerez que la variable path ne contient plus les nouveaux éléments qui lui ont été ajoutés précédemment. La commande de définition de chemin doit être exécutée chaque fois que vous démarrez un nouveau terminal.
Une solution courante à ce problème consisterait à ajouter la commande à l'un des scripts de démarrage utilisés par le shell. Sous Mac OS, vous pouvez créer un fichier .bash_profile dans le répertoire ~/username qui s'exécutera chaque fois que vous ouvrirez une nouvelle fenêtre de terminal. Dans Ubuntu, le script exécuté lorsqu'une nouvelle fenêtre de terminal est ouverte est .bashrc. Chez les autres Distributions Linux et coquillages, des règles similaires s'appliquent.
Procédure d'ajout d'une commande à un script de démarrage du shell
Modifiez votre répertoire personnel :
Créez un profil de configuration shell (si nécessaire) et redirigez le texte d'entrée vers la fin du fichier à l'aide de la commande cat >>. Utilisez le fichier approprié pour votre système opérateur et coquillages. Par exemple, vous pouvez utiliser .bash_profile sur Mac OS et .bashrc sur Ubuntu.
Chat >> .bash_profile
Saisissez le texte que vous souhaitez ajouter au fichier :
Exporter PATH=$PATH:/Users/cward/SDKs/android/tools:/Users/cward/SDKs/AIR/bin
Terminez la redirection de texte en appuyant sur les touches CTRL-SHIFT-D de votre clavier.
Affichez le fichier pour vérifier que l'opération s'est bien déroulée :
Chat .bash_profile
Ouvrez une nouvelle fenêtre de terminal pour vérifier le chemin :
echo $CHEMIN
Les éléments ajoutés doivent être affichés à l'écran.
Si créé ultérieurement une nouvelle version l'un des SDK devant être placé dans un répertoire différent, la commande de définition du chemin dans le fichier de configuration devra être mise à jour en conséquence. Sinon, le shell continuera à utiliser l'ancienne version.
Définition de la variable d'environnement PATH sous Windows
Lorsqu'une fenêtre de commande est ouverte sous Windows, elle hérite des variables d'environnement globales définies dans les propriétés système. Une variable importante est la variable de chemin, qui contient une liste de répertoires dans lesquels rechercher le programme entré. Pour afficher la liste actuelle des répertoires dans la variable path, vous pouvez saisir la commande suivante dans la fenêtre de commande :
définir le chemin
Cela affichera une liste de répertoires séparés par deux-points qui ressemble à ceci :
Chemin=C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem
Le chemin d'accès au répertoire bin du SDK AIR doit être ajouté à cette liste afin que le programme de commande puisse trouver l'ADT et les outils ADT. Supposons que le SDK AIR se trouve dans le répertoire C:\SDKs\AIR. Dans ce cas, le chemin peut être ajouté comme ceci :
Dans la section Panneau de configuration, ouvrez la boîte de dialogue Propriétés système ou cliquez avec le bouton droit sur l'icône Poste de travail et sélectionnez Propriétés dans le menu.
Dans l'onglet Avancé, cliquez sur le bouton Variables d'environnement.
Dans la section Variables système de la boîte de dialogue Variables d'environnement, sélectionnez l'élément Path.
Cliquez sur le bouton Modifier.
Déplacez-vous jusqu'à la fin de la ligne dans le champ Valeur variable.
À la toute fin de la valeur actuelle, saisissez le texte suivant :
;C:\SDKs\AIR\bin
Appuyez sur le bouton "OK" dans tous Boîtes de dialogue pour enregistrer le chemin.
Si des fenêtres de commande sont ouvertes à ce stade, les modifications apportées à celles-ci ne seront pas appliquées. Ouvrez une nouvelle fenêtre de commande et saisissez la commande suivante pour vous assurer que la variable d'environnement est correctement définie :
Version adt
Si l'emplacement du SDK AIR est modifié ultérieurement ou si une nouvelle version est ajoutée, la variable d'environnement de chemin devra être modifiée en conséquence.
Je me demande où le nouveau chemin doit être ajouté à la variable d'environnement PATH. Je sais que cela peut être fait en éditant .bashrc (par exemple), mais on ne sait pas comment.
Ainsi:
Exporter PATH=~/opt/bin :$PATH
Exporter PATH=$PATH :~/opt/bin
11 réponses
matériel simple
CHEMIN=$CHEMIN :~/opt/bin CHEMIN=~/opt/bin :$CHEMINselon que vous souhaitez ajouter ~/opt/bin à la fin (pour rechercher tous les autres répertoires s'il y a un programme avec le même nom dans plusieurs répertoires) ou au début (pour rechercher avant tous les autres répertoires).
Vous pouvez ajouter plusieurs entrées en même temps. PATH=$PATH:~/opt/bin:~/opt/node/bin ou des changements de classement très bien.
Vous n'avez pas besoin d'exporter si la variable est déjà dans l'environnement : toute modification de la valeur de la variable est reflétée dans l'environnement.¹ PATH est quasiment toujours dans l'environnement ; Tous systèmes unix installez-le très tôt (généralement dans le tout premier processus, en fait).
Si votre PATH est créé par de nombreux composants différents, vous pouvez vous retrouver avec des entrées en double. Voir Comment ajouter un chemin de répertoire personnel qui sera découvert par Unix, quelle commande ? et Supprimer les entrées $PATH en double avec la commande awk pour éviter la duplication ou les supprimer.
Où mettre
Notez que ~/.bash_rc n'est lisible par aucun programme et que ~/.bashrc est un fichier de configuration pour les instances bash interactives. Vous ne devez pas définir de variables d'environnement dans ~/.bashrc . Le bon endroit pour définir des variables d'environnement telles que PATH est ~/.profile (ou ~/.bash_profile si vous n'aimez pas les shells autres que bash). Voir Quelle est la différence entre eux et lequel dois-je utiliser ?
Remarques sur les shells non bash
Dans bash, ksh et zsh, export est une syntaxe spéciale, et PATH=~/opt/bin:$PATH et export PATH=~/opt/bin:$PATH font même la bonne chose. Dans d'autres shells Bourne/POSIX, tels que dash (qui est /bin/sh sur de nombreux systèmes), export est analysé comme une commande normale, ce qui implique deux différences :
- ~ n'est analysé qu'au début d'un mot, sauf pour les destinations (voir Comment ajouter un chemin vers un répertoire personnel qui sera découvert par Unix qui nécessite une commande ? ;
- $PATH les guillemets doubles externes sautent si PATH contient des espaces ou \[*? .
Ainsi, dans des shells comme dash, export PATH=~/opt/bin:$PATH définit PATH sur la chaîne littérale ~/opt/bin/: suivie de la valeur de PATH jusqu'à la première place. PATH=~/opt/bin:$PATH (affectation simple) ne nécessite pas de guillemets et fait ce qu'il faut. Si vous souhaitez utiliser export dans un script portable, vous devez écrire export PATH="$HOME/opt/bin:$PATH" ou PATH=~/opt/bin:$PATH export PATH (ou PATH=$HOME/opt /bin : $PATH export PATH pour la portabilité même vers le shell Bourne, qui n'accepte pas export var=value et n'a pas fait d'expansion tilde).
¹ Ce n'était pas vrai dans les shells Bourne (comme le shell Bourne actuel, pas les shells modernes de style POSIX), mais vous n'êtes pas susceptible de rencontrer ces anciens shells de nos jours. Sous>
Les deux méthodes fonctionnent, mais elles ne font pas la même chose : les éléments PATH sont vérifiés de gauche à droite. Dans le premier exemple fichiers exécutables dans ~/opt/bin auront priorité sur ceux définis dans /usr/bin par exemple, ce qui peut ou non être ce que vous voulez.
En particulier, il est dangereux d'un point de vue de la sécurité d'ajouter des chemins au début, car si quelqu'un peut obtenir un accès en écriture à votre ~/opt/bin , il peut mettre un autre ls par exemple, que vous utiliserez probablement à la place /bin /ls sans s'en apercevoir. Imaginez maintenant faire la même chose pour ssh ou votre navigateur ou votre choix... (Trois fois mettez la même chose sur votre chemin.)
Je suis confus au sujet de la question 2 (puisqu'elle est supprimée de la question car elle était liée à un problème sans rapport):
Quoi méthode efficace ajouter des chemins supplémentaires à différentes lignes ? Au départ, je pensais que cela pourrait faire l'affaire:
export PATH=$PATH:~/opt/bin export PATH=$PATH:~/opt/node/bin
Mais ce n'est pas parce que la deuxième affectation ajoute non seulement ~/opt/node/bin , mais également le PATH précédemment affecté.
Voici une solution de contournement possible :
Exporter PATH=$PATH :~/opt/bin :~/opt/node/bin
Mais pour la lisibilité, je préfère avoir une destination par chemin.
Si tu le dis
CHEMIN=~/opt/bin
Ce tous, qui sera dans votre PATH. PATH est juste une variable d'environnement et si vous voulez ajouter à PATH, vous devez reconstruire la variable avec exactement le contenu que vous voulez. Autrement dit, ce que vous donnez comme exemple à la question 2 est exactement ce que vous voulez faire, si je n'ai pas complètement raté le but de la question.
J'utilise les deux formes dans mon code. J'ai un profil générique que j'installe sur chaque machine sur laquelle je travaille et qui ressemble à ceci pour héberger des répertoires potentiellement manquants :
Export PATH=/opt/bin:/usr/local/bin:/usr/contrib/bin:/bin:/usr/bin:/usr/sbin:/usr/bin/X11 # ajoute des éléments optionnels au chemin pour bindir dans $HOME/local/bin $HOME/bin ; faire si [ -d $bindir ]; then PATH=$PATH:$(bindir) fi fait
Linux définit un chemin de recherche exécutable avec la variable d'environnement $PATH. Pour ajouter le répertoire /data/myscripts au début de la variable d'environnement $PATH, utilisez ce qui suit :
CHEMIN=/données/messcripts :$CHEMIN
Pour ajouter ce répertoire à la fin du chemin, utilisez la commande suivante :
CHEMIN=$CHEMIN:/data/messcripts
Mais les précédentes ne suffisent pas, car lorsque vous définissez une variable d'environnement dans un script, ce changement ne prend effet qu'à l'intérieur du script. Cette limitation est limitée de deux manières :
- Si vous exportez une variable d'environnement dans un script, elle est effective dans tout programme appelé par le script. Notez que cela n'est pas efficace dans le programme qui a appelé le script.
- Si le programme appelant le script le fait en incluant au lieu d'appeler, tout changement d'environnement dans le script est effectif dans le programme appelant. Cette inclusion peut se faire avec la commande point ou la commande source.
$HOME/monscript.sh source $HOME/monscript.sh
L'inclusion inclut essentiellement le script "invoqué" dans le script "invoquant". Ceci est similaire à #include en C. Ainsi, il est efficace à l'intérieur d'un script ou d'un programme appelant. Mais bien sûr, cela n'est efficace pour aucun programme ou script appelé par le programme appelant. Pour le rendre effectif jusqu'à la chaîne d'appel, vous devez suivre le paramétrage de la variable d'environnement avec la commande export.
Par exemple, le programme shell bash inclut le contenu du fichier .bash_profile lors de son inclusion. Mettez donc les 2 lignes suivantes dans .bash_profile :
PATH=$PATH:/data/myscripts export PATH
place efficacement ces 2 lignes de code dans un programme bash. Ainsi, dans variable bas$PATH inclut $HOME/myscript.sh , et à cause de l'instruction d'exportation, tous les programmes appelés par bash voient leur variable $PATH modifiée. Et puisque tous les programmes que vous exécutez à partir d'une invite bash sont appelés par bash, le nouveau chemin s'applique à tout ce que vous exécutez à partir d'une invite bash.
L'essentiel est que pour ajouter un nouveau répertoire au chemin, vous devez ajouter ou ajouter le répertoire à la variable d'environnement $PATH dans un script inclus avec le shell, et vous devez exporter la variable d'environnement $PATH.
Depuis quelque temps, j'ai gardé avec moi les deux fonctions pathadd et pathrm , qui permettent d'ajouter des éléments à un chemin sans se soucier des doublons.
pathadd prend un argument path et un argument after facultatif qui, s'il est ajouté, sera ajouté à PATH , sinon il l'ajoutera.
Dans toutes les situations, si vous ajoutez un chemin, vous souhaitez probablement remplacer ce qui se trouve déjà dans le chemin, c'est pourquoi je préfère ajouter la valeur par défaut.
Pathadd() ( newelement=$(1%/) if [ -d "$1" ] && ! echo $PATH | grep -E -q "(^|:)$newelement($|:)" ; then if [ " $2" = "after" ] ; then PATH="$PATH:$newelement" else PATH="$newelement:$PATH" fi fi ) pathrm() ( PATH="$(echo $PATH | sed -e "s; \(^\|:\)$(1%/)\(:\|\$\);\1\2;g" -e "s;^:\|:$;;g" -e "s ;::;:;g")" )
Mettez-les dans n'importe quel script que vous souhaitez modifier l'environnement PATH et vous êtes maintenant prêt à partir.
pathadd "/foo/bar" pathadd "/baz/bat" après l'exportation PATH
Vous êtes assuré de ne pas ajouter le chemin s'il existe déjà. Si vous voulez que /baz/bat soit démarré au début.
Pathrm "/baz/bat" pathadd "/baz/bat" export PATH
Désormais, n'importe quel chemin peut être déplacé vers l'avant s'il est déjà sur le chemin sans le doubler.
Manière infaillible d'ajouter/prétraiter
De nombreuses considérations sont impliquées dans le choix d'ajouter et d'ajouter. Beaucoup d'entre eux sont couverts dans d'autres réponses, donc je ne les répéterai pas ici.
Le point important est que même si les scripts système n'utilisent pas this (je me demande pourquoi) * 1 , un moyen infaillible d'ajouter un chemin (par exemple $HOME/bin) à la variable d'environnement PATH
CHEMIN="$(CHEMIN:+$(CHEMIN):)$HOME/bin"
à ajouter (au lieu de PATH="$PATH:$HOME/bin") et
CHEMIN="$HOME/bin$(CHEMIN:+:$(CHEMIN))"
à ajouter (au lieu de PATH="$HOME/bin:$PATH")
Cela évite un faux deux-points avant/arrière lorsque $PATH est initialement vide, ce qui peut avoir des effets secondaires indésirables et peut être un cauchemar à trouver insaisissable (cette réponse aborde brièvement le cas maladroit).
$(paramètre :+mot)Si le paramètre est nul ou non défini, rien n'est remplacé, sinon le mot est remplacé.
Donc $(PATH:+$(PATH):) se développe en : 1) rien si PATH est nul ou non défini, 2) $(PATH): si PATH est défini.
Note. C'est pour bash.
*1 Je viens de découvrir que des scripts comme devtoolset-6/enable utilisent en fait ce $ cat /opt/rh/devtoolset-6/enable # Variables d'environnement générales export PATH=/opt/rh/devtoolset-6/root/usr /bin$ (CHEMIN:+:$(CHEMIN)) ...
Je ne peux pas parler des autres distributions, mais Ubuntu a un fichier /etc/environment qui est le chemin de recherche par défaut pour tous les utilisateurs. Étant donné que mon ordinateur n'est utilisé que par moi, je mets tous les répertoires que je veux sur mon chemin, à moins qu'il ne s'agisse d'un ajout temporaire que je mets dans le script.
Pour moi (sur Mac OS X 10.9.5), l'ajout d'un nom de chemin (par exemple /mypathname) au fichier /etc/paths a très bien fonctionné.
Avant l'édition, echo $PATH est renvoyé :
/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin
Après avoir modifié /etc/paths et redémarré le shell, la variable $PATH est ajoutée avec /pathname . En effet, echo $PATH renvoie :
/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/mypathname
Il est arrivé que /mypathname ait été ajouté à la variable $PATH.
Les variables d'environnement sous Linux sont des variables spéciales définies par le shell et utilisées par les programmes lors de l'exécution. Ils peuvent être définis par le système et l'utilisateur. Les variables d'environnement du système Linux sont définies par le système et utilisées par les programmes au niveau du système.
Par exemple, la commande PWD utilise une variable système pour conserver l'ancien répertoire de travail. Les variables d'environnement utilisateur sont définies par l'utilisateur, pour le shell courant, de manière temporaire ou permanente. Tout le concept d'ajout et de suppression de variables shell tourne autour de plusieurs fichiers, commandes et divers shells.
Plus largement, une variable d'environnement peut être de trois types :
1. Variables d'environnement locales
Ces variables ne sont définies que pour la session en cours. Ils seront définitivement effacés après la fin de la session, que ce soit accès à distance ou un émulateur de terminal. Ils ne sont stockés dans aucun fichier, mais sont créés et supprimés à l'aide de commandes spéciales.
2. Variables du shell utilisateur
Ces variables d'interpréteur de commandes sous Linux, ils sont définis pour un utilisateur spécifique et sont chargés à chaque fois qu'il se connecte à l'aide d'un terminal local, ou se connecte à distance. Ces variables sont généralement stockées dans des fichiers de configuration : .bashrc, .bash_profile, .bash_login, .profile ou d'autres fichiers situés dans le répertoire de l'utilisateur.
3. Variables d'environnement système
Ces variables sont disponibles dans tout le système, pour tous les utilisateurs. Ils sont chargés au démarrage du système à partir des fichiers de configuration système : /etc/environment, /etc/profile, /etc/profile.d/ /etc/bash.bashrc.
Fichiers de configuration des variables d'environnement Linux
Ici, nous allons jeter un coup d'œil aux différents fichiers de configuration répertoriés ci-dessus, qui sont utilisés pour définir des variables d'environnement pour l'ensemble du système ou un utilisateur spécifique.
.bashrc
Il s'agit d'un fichier de variables spécifique à l'utilisateur. Il est chargé chaque fois que l'utilisateur crée une session de terminal, c'est-à-dire qu'il ouvre un nouveau terminal. Toutes les variables d'environnement créées dans ce fichier prennent effet à chaque démarrage d'une nouvelle session de terminal.
.bash_profile
Ces variables prennent effet chaque fois qu'un utilisateur se connecte à distance via SSH. Si ce fichier est manquant, le système recherchera .bash_login ou .profile.
/etc/environnement
Ce fichier sert à créer, modifier et supprimer toutes les variables d'environnement au niveau du système. Les variables d'environnement créées dans ce fichier sont disponibles pour l'ensemble du système, pour chaque utilisateur, et même lorsqu'il est connecté à distance.
/etc/bash.bashrc
Système bashrc. Ce fichier est exécuté pour chaque utilisateur, chaque fois qu'il crée une nouvelle session de terminal. Cela ne fonctionne que pour les utilisateurs locaux, lorsqu'ils sont connectés via Internet, ces variables ne seront pas visibles.
/etc/profil
Le profil de fichier système. Toutes les variables de ce fichier sont accessibles à tous les utilisateurs du système uniquement s'ils sont connectés à distance. Mais ils ne seront pas disponibles lors de la création d'une session de terminal local, c'est-à-dire si vous venez d'ouvrir un terminal.
Toutes les variables d'environnement Linux créées avec ces fichiers peuvent être supprimées en les supprimant simplement à partir de là. Seulement après chaque modification, vous devez soit vous déconnecter et vous reconnecter, soit exécuter cette commande :
nom du fichier source
Ajout de variables d'environnement utilisateur et système sous Linux
Maintenant que vous connaissez un peu la théorie, passons à la pratique. Les variables d'environnement locales sous Linux peuvent être créées avec les commandes suivantes :
var=valeur
$ export var=valeur
Ces variables ne seront disponibles que pour la session de terminal en cours.
Plusieurs commandes peuvent être utilisées pour supprimer les variables d'environnement :
1. Utiliser env
Par défaut, env peut être utilisé pour afficher toutes les variables d'environnement définies. Mais avec l'option -i, cela vous permet de supprimer temporairement toutes les variables shell et d'exécuter la commande sans variables.
commande env -i
Var est n'importe quelle variable que vous souhaitez transmettre à cette commande.
Cette commande démarrera un shell sans aucune variable d'environnement :
Après avoir démarré un tel environnement, aucune variable ne sera disponible, mais après la sortie, tout reviendra à sa place.
2. Utiliser unset
C'est une autre façon de supprimer les variables d'environnement Linux. Unset supprime une variable par son nom jusqu'à la fin de la session en cours :
unset nom_variable
3. Définissez la valeur de la variable sur ""
C'est le moyen le plus simple de supprimer des variables d'environnement sous Linux, en définissant une variable pour qu'elle soit vide, vous la supprimez pour le reste de la session en cours.
Remarque : à l'aide de ces méthodes, vous pouvez modifier les valeurs des variables système ou utilisateur, mais elles ne seront pertinentes que pour la session en cours.
Création de variables d'environnement utilisateur et système
Dans cette section, nous verrons comment définir et supprimer des variables système et utilisateur non seulement pour la session en cours, mais pour que l'effet persiste après un redémarrage.
1. Définir et supprimer des variables locales sous Linux
Créons une variable locale VAR et définissons-la sur n'importe quelle valeur, puis supprimons-la avec unset et assurons-nous qu'elle est supprimée :
VAR1="Perte"
$ écho $VAR1
$ unset VAR1
$ écho $VAR1
Une autre façon de créer une variable consiste à utiliser la commande d'exportation. Supprimez-le en attribuant une valeur vide :
export VAR="Perte"
$ écho $VAR
$var=
$ écho $VAR
Créons maintenant une variable VAR2 et donnons-lui une valeur. Et puis supprimez temporairement toutes les variables locales en exécutant env -i. Il démarrera le shell sans aucune variable. Après avoir tapé exit, toutes les variables seront restaurées.
VAR2="Perte"
$ écho $VAR2
$ env -i bash
$ écho $VAR2
Définition et suppression de variables utilisateur
Modifiez le fichier .bashrc dans votre répertoire personnel en ajoutant une commande d'exportation pour exporter la variable souhaitée. Exécutez ensuite la commande source pour appliquer les modifications. Créons, par exemple, une variable CD :
Ajoutez cette ligne (o, puis coller, puis Esc et :wq) :
export CD="Ceci est la maison perdue"
Reste maintenant à mettre à jour la configuration :
source .bashrc
$écho $CD
Pour supprimer cette variable, supprimez-la simplement de .bashrc.
Ajoutons maintenant une variable d'environnement avec .bash_profile. Cette variable, comme vous le savez déjà, ne sera disponible que lorsque vous vous connecterez à distance :
vi .bash_profile
Ajouter une ligne :
export VAR2="Ceci est la maison perdue"
Et exécutez ces commandes pour appliquer les modifications et tester l'ajout de variable :
source .bash_profile
$ écho $VAR2
La variable n'est pas disponible car vous avez créé une session de terminal local, connectez-vous maintenant via ssh :
chut [courriel protégé]
$ écho $VAR2
Vous pouvez supprimer cette variable d'environnement de la même manière que dans le cas précédent en la supprimant du fichier.
Commentaire: Ces variables sont toujours disponibles, mais pas pour tous les utilisateurs.
Définition et suppression des variables d'environnement système
Créons une variable accessible à tous les utilisateurs dans toutes les sessions de terminal, à l'exception des sessions distantes, en l'ajoutant à /etc/bash.profile :
vi /etc/bash.profile
export VAR="Ceci est une variable à l'échelle du système"
Puis on met à jour :
source /etc/bash.bashrc
Cette variable est désormais disponible pour tous les utilisateurs, dans tous les terminaux :
écho $VAR
$ sudo su
$ écho $VAR
$su-
$ écho $VAR
Si vous souhaitez rendre la variable d'environnement accessible à tous les utilisateurs qui se connectent à cette machine à distance, modifiez le fichier /etc/profile :
export VAR1="Il s'agit d'une variable à l'échelle du système pour les sessions à distance uniquement"
Mettez à jour la configuration, et vérifiez la disponibilité de la variable, elle ne sera disponible qu'à distance :
source /etc/profil
$ écho $VAR1
Si vous devez ajouter une variable d'environnement sous Linux afin qu'elle soit disponible à la fois pour les sessions distantes et locales, exportez-la vers /etc/environment :
vi /etc/environnement
export VAR12="Je suis disponible partout"
Nous vérifions:
source /etc/environnement
$ écho $VAR12
$ sudo su
$ écho $VAR12
$sortie
$ ssh localhost
$ écho $VAR12
