Variables environnement Linux 2026 : .bashrc, .profile, PATH et configuration shell

Les variables d'environnement contrôlent le comportement du shell et des applications. Ce guide explique comment configurer, gérer et optimiser les variables d'environnement sous Linux.

Comprendre Variables d'Environnement

Qu'est-ce qu'une Variable d'Environnement ?

Une variable d'environnement est une valeur nommée accessible par les processus du système.

Exemples courants :

PATH : Chemins recherche commandes
HOME : Répertoire utilisateur
USER : Nom utilisateur actuel
SHELL : Shell par défaut
LANG : Langue système

Analogie : Variables = post-its avec infos que tous programmes peuvent lire.

Variables Shell vs Environnement

# Variable shell (locale, pas héritée)
MY_VAR="value"

# Variable environnement (héritée par processus enfants)
export MY_VAR="value"

# Vérifier
echo $MY_VAR

# Lister toutes variables environnement
env
printenv

# Lister toutes variables (shell + env)
set

Variables Essentielles

PATH : Chemins Exécutables

# Voir PATH actuel
echo $PATH
# Output: /usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin

# Ajouter répertoire temporairement
export PATH=$PATH:/opt/myapp/bin

# Ajouter au début (priorité haute)
export PATH=/opt/myapp/bin:$PATH

# Vérifier où commande trouvée
which python
# /usr/bin/python

# Voir tous chemins pour commande
whereis python

HOME : Répertoire Utilisateur

# Répertoire home
echo $HOME
# /home/username

# Raccourci tilde
cd ~
cd $HOME  # Équivalent

# Variables dérivées
echo $HOME/Documents

USER et Shell

# Utilisateur actuel
echo $USER
# username

# UID
echo $UID
# 1000

# Shell actuel
echo $SHELL
# /bin/bash

# Shell parent
echo $0

Langue et Localisation

# Langue système
echo $LANG
# en_US.UTF-8

# Voir toutes locales
locale

# Changer temporairement
export LANG=fr_FR.UTF-8

# Lister locales disponibles
locale -a

Fichiers Configuration Shell

Ordre Chargement Bash

Login shell (SSH, console) :

1. /etc/profile
2. ~/.bash_profile (si existe)
   OU ~/.bash_login (si existe)
   OU ~/.profile (si existe)
3. ~/.bash_logout (à la déconnexion)

Non-login shell (terminal dans GUI) :

1. /etc/bash.bashrc (Debian/Ubuntu)
   OU /etc/bashrc (RedHat)
2. ~/.bashrc

.bashrc vs .bash_profile

.bashrc : Interactif non-login

Terminal GUI
Nouveau tab terminal
Aliases, fonctions, prompts

.bash_profile : Login shell

SSH
Console login
Source .bashrc typiquement

Contenu Typique .bashrc

# ~/.bashrc

# Ne rien faire si non-interactif
[ -z "$PS1" ] && return

# Historique
HISTSIZE=10000
HISTFILESIZE=20000
HISTCONTROL=ignoredups:erasedups

# Prompt
PS1='\u@\h:\w\$ '

# Aliases
alias ll='ls -lah'
alias la='ls -A'
alias l='ls -CF'
alias grep='grep --color=auto'

# Ajouts PATH
export PATH=$PATH:$HOME/bin

# Complétion
if [ -f /etc/bash_completion ]; then
    . /etc/bash_completion
fi

# Custom scripts
if [ -d ~/.bash_custom ]; then
    for file in ~/.bash_custom/*; do
        [ -r "$file" ] && source "$file"
    done
fi

Pour personnaliser davantage votre prompt, découvrez notre guide sur la personnalisation de votre prompt Bash.

Contenu Typique .bash_profile

# ~/.bash_profile

# Charger .profile si existe
if [ -f ~/.profile ]; then
    . ~/.profile
fi

# Charger .bashrc
if [ -f ~/.bashrc ]; then
    . ~/.bashrc
fi

# Variables login seulement
export EDITOR=vim
export VISUAL=vim

.profile (POSIX compatible)

# ~/.profile
# Compatible tous shells POSIX (bash, sh, dash)

# PATH
export PATH=$HOME/bin:$PATH

# Variables
export EDITOR=vim
export PAGER=less

# Locale
export LANG=en_US.UTF-8
export LC_ALL=en_US.UTF-8

# XDG directories
export XDG_CONFIG_HOME=$HOME/.config
export XDG_DATA_HOME=$HOME/.local/share

Définir Variables

Temporaire (session actuelle)

# Variable shell
MY_VAR="value"

# Variable environnement (héritée)
export MY_VAR="value"

# Ou en une ligne
MY_VAR="value" && export MY_VAR

# Vérifier
echo $MY_VAR
printenv MY_VAR

Permanent (tous shells futurs)

Pour utilisateur actuel :

# Éditer .bashrc
nano ~/.bashrc

# Ajouter
export MY_VAR="value"

# Recharger
source ~/.bashrc
# Ou
. ~/.bashrc

Pour tous utilisateurs :

# Éditer profile système
sudo nano /etc/environment

# Format (pas d'export)
MY_VAR="value"

# Ou dans /etc/profile.d/
sudo nano /etc/profile.d/custom.sh

export MY_VAR="value"

# Rendre exécutable
sudo chmod +x /etc/profile.d/custom.sh

Important : Les variables d'environnement affectent aussi les tâches cron. Découvrez comment gérer les variables dans crontab.

PATH : Gestion Avancée

Comprendre PATH

# PATH = liste chemins séparés par :
echo $PATH
# /usr/local/bin:/usr/bin:/bin

# Ordre = priorité
# Si 'python' existe dans /usr/local/bin ET /usr/bin
# → Exécute /usr/local/bin/python

Ajouter au PATH

# Méthode sûre (évite doublons)
if [[ ":$PATH:" != *":/opt/myapp/bin:"* ]]; then
    export PATH=$PATH:/opt/myapp/bin
fi

# Ajouter début (haute priorité)
export PATH=/opt/myapp/bin:$PATH

# Multiple chemins
export PATH=$PATH:/opt/app1/bin:/opt/app2/bin

# Avec variable
APP_BIN=/opt/myapp/bin
export PATH=$PATH:$APP_BIN

PATH pour Python Virtual Env

# Dans .bashrc
# Auto-activer virtualenv si présent
activate_venv() {
    if [ -f venv/bin/activate ]; then
        source venv/bin/activate
    fi
}

# Appeler à chaque cd
cd() {
    builtin cd "$@" && activate_venv
}

PATH Troubleshooting

# Commande introuvable ?
# 1. Vérifier existe
ls -l /path/to/command

# 2. Vérifier PATH
echo $PATH | tr ':' '\n'

# 3. Rechercher commande
which -a command
type -a command

# 4. Trouver où installée
find / -name command 2>/dev/null

# 5. Ajouter chemin si nécessaire
export PATH=$PATH:/chemin/trouvé

Variables Personnalisées

Variables Développement

# ~/.bashrc

# Node.js
export NODE_ENV=development
export NODE_OPTIONS="--max-old-space-size=4096"

# Python
export PYTHONPATH=$HOME/python-libs:$PYTHONPATH
export PYTHONDONTWRITEBYTECODE=1

# Go
export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin

# Java
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
export PATH=$PATH:$JAVA_HOME/bin

# Rust
export PATH=$PATH:$HOME/.cargo/bin

# Docker
export DOCKER_HOST=unix:///var/run/docker.sock

Variables Applications

# Éditeur
export EDITOR=vim
export VISUAL=vim

# Browser
export BROWSER=firefox

# Pager
export PAGER=less
export LESS='-R -F -X'

# Terminal
export TERM=xterm-256color

# Proxy (si nécessaire)
export HTTP_PROXY=http://proxy.example.com:8080
export HTTPS_PROXY=http://proxy.example.com:8080
export NO_PROXY=localhost,127.0.0.1

Variables Build

# C/C++ Compilation
export CC=gcc
export CXX=g++
export CFLAGS="-O2 -march=native"
export CXXFLAGS="$CFLAGS"

# Make
export MAKEFLAGS="-j$(nproc)"

# CMake
export CMAKE_BUILD_TYPE=Release

Aliases et Fonctions

Aliases Utiles

# ~/.bashrc

# Navigation
alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'

# Listings
alias ll='ls -lah'
alias la='ls -A'
alias l='ls -CF'
alias lt='ls -ltr'  # Tri par date

# Sécurité
alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'

# Git shortcuts
alias gs='git status'
alias ga='git add'
alias gc='git commit'
alias gp='git push'
alias gl='git log --oneline --graph'

# Docker
alias dps='docker ps'
alias dpa='docker ps -a'
alias di='docker images'

# System
alias update='sudo apt update && sudo apt upgrade'
alias ports='netstat -tulanp'
alias meminfo='free -h'
alias diskinfo='df -h'

# Colorisation
alias grep='grep --color=auto'
alias fgrep='fgrep --color=auto'
alias egrep='egrep --color=auto'
alias ls='ls --color=auto'

Fonctions Shell

# ~/.bashrc

# Créer répertoire et cd dedans
mkcd() {
    mkdir -p "$1" && cd "$1"
}

# Extract archives
extract() {
    if [ -f "$1" ]; then
        case "$1" in
            *.tar.gz|*.tgz) tar xzf "$1" ;;
            *.tar.bz2|*.tbz2) tar xjf "$1" ;;
            *.tar.xz) tar xJf "$1" ;;
            *.zip) unzip "$1" ;;
            *.rar) unrar x "$1" ;;
            *.7z) 7z x "$1" ;;
            *) echo "Unknown archive type" ;;
        esac
    else
        echo "File not found: $1"
    fi
}

# Backup file
backup() {
    cp "$1" "$1.backup-$(date +%Y%m%d-%H%M%S)"
}

# Recherche fichier
ff() {
    find . -type f -name "*$1*"
}

# Recherche dans fichiers
search() {
    grep -r "$1" . --color=auto
}

# Process info
psgrep() {
    ps aux | grep -v grep | grep -i -e VSZ -e "$1"
}

# Tunnel SSH rapide
tunnel() {
    ssh -L "$1":localhost:"$1" "$2"
}

Prompt PS1 Personnalisé

Pour une personnalisation avancée de votre prompt Bash, consultez notre guide dédié.

Customiser Prompt

# ~/.bashrc

# Prompt simple
PS1='\u@\h:\w\$ '
# user@host:/path$

# Prompt coloré
PS1='\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '

# Avec Git branch
parse_git_branch() {
    git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/ (\1)/'
}
PS1='\u@\h:\w\[\033[32m\]$(parse_git_branch)\[\033[00m\]\$ '

# Avec status dernière commande
PS1='[\u@\h:\w] $(if [ $? -eq 0 ]; then echo "\[\e[32m\]✓"; else echo "\[\e[31m\]✗"; fi)\[\e[0m\] \$ '

# Prompt multiligne
PS1='\n┌─[\[\033[01;32m\]\u@\h\[\033[00m\]]─[\[\033[01;34m\]\w\[\033[00m\]]\n└─\$ '

Prompt avec Starship (moderne)

# Installer starship
curl -sS https://starship.rs/install.sh | sh

# Activer dans .bashrc
eval "$(starship init bash)"

# Configuration
mkdir -p ~/.config
nano ~/.config/starship.toml

# Prompt minimal, rapide, avec Git/Docker/etc

Zsh : Shell Alternatif

Installer et Configurer Zsh

# Installer
sudo apt install zsh

# Définir comme shell par défaut
chsh -s $(which zsh)

# Installer Oh My Zsh
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Configuration .zshrc

# ~/.zshrc

# Oh My Zsh
export ZSH="$HOME/.oh-my-zsh"

# Theme
ZSH_THEME="robbyrussell"
# Ou: agnoster, powerlevel10k

# Plugins
plugins=(
    git
    docker
    kubectl
    sudo
    z
    zsh-autosuggestions
    zsh-syntax-highlighting
)

source $ZSH/oh-my-zsh.sh

# Custom aliases
alias ll='ls -lah'

# Custom PATH
export PATH=$HOME/bin:$PATH

Variables par Projet

.envrc avec direnv

# Installer direnv
sudo apt install direnv

# Activer dans .bashrc
eval "$(direnv hook bash)"

# Dans projet
cd ~/projet
nano .envrc

# Contenu .envrc
export DATABASE_URL=postgresql://localhost/mydb
export API_KEY=secret123
export DEBUG=true
PATH_add ./bin

# Autoriser
direnv allow

# Variables chargées auto en entrant dans dossier
# Déchargées en sortant

Variables Docker Compose

# .env dans projet
DATABASE_URL=postgresql://localhost/mydb
REDIS_URL=redis://localhost
NODE_ENV=development

# docker-compose.yml
services:
  app:
    env_file: .env
    environment:
      - PORT=3000

Sécurité Variables

Ne Jamais Hardcoder Secrets

# ❌ MAUVAIS
export API_KEY="secret123"

# ✓ BON - Fichier séparé
export API_KEY=$(cat ~/.secrets/api_key)

# ✓ BON - Variable système
# Définir au niveau système, pas dans .bashrc

Fichier Secrets Séparé

# ~/.secrets/env
export DATABASE_PASSWORD="securepassword"
export API_KEY="secret123"

# Permissions restrictives
chmod 600 ~/.secrets/env

# Dans .bashrc
if [ -f ~/.secrets/env ]; then
    source ~/.secrets/env
fi

Vérifier Variables Sensibles

# Voir toutes variables (attention, secrets visibles)
env

# Filtrer secrets communs
env | grep -i 'password\|secret\|key\|token'

# Ne jamais logger
echo $PASSWORD  # Visible dans history

# Mieux : lire depuis fichier
read -s PASSWORD < ~/.secrets/db_password

Debugging Configuration

Tracer Chargement

# Ajouter en haut de .bashrc
set -x  # Active trace

# Contenu .bashrc...

set +x  # Désactive trace

# Voir ordre exécution
bash --login -x

Vérifier Variables Chargées

# Toutes variables env
env | sort

# Seulement PATH
echo $PATH | tr ':' '\n'

# Rechercher variable
env | grep MY_VAR

# Voir d'où vient variable
grep -r "MY_VAR" ~/.bashrc ~/.bash_profile ~/.profile /etc/profile.d/

Problèmes Courants

# Variable non définie
# → Vérifier fichier chargé (.bashrc vs .bash_profile)
# → Source fichier : source ~/.bashrc

# PATH incorrect
# → echo $PATH | tr ':' '\n'
# → Vérifier ordre (priorités)

# Changements pas appliqués
# → Source : source ~/.bashrc
# → Ou nouveau shell : exec bash

# Conflits aliases
# → type command
# → which command

Exemples Configurations Complètes

.bashrc Développeur

# ~/.bashrc

# Historique
HISTSIZE=10000
HISTFILESIZE=20000
HISTCONTROL=ignoredups:erasedups
shopt -s histappend

# Prompt Git
parse_git_branch() {
    git branch 2>/dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/ (\1)/'
}
PS1='\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[33m\]$(parse_git_branch)\[\033[00m\]\$ '

# Aliases
alias ll='ls -lah'
alias gs='git status'
alias dc='docker-compose'
alias k='kubectl'

# PATH
export PATH=$HOME/bin:$HOME/.local/bin:$PATH

# Dev tools
export EDITOR=vim
export NODE_ENV=development
export PYTHONDONTWRITEBYTECODE=1

# Fonctions
mkcd() { mkdir -p "$1" && cd "$1"; }
extract() {
    case "$1" in
        *.tar.gz) tar xzf "$1" ;;
        *.zip) unzip "$1" ;;
    esac
}

.bashrc Serveur Production

# ~/.bashrc

# Prompt sécurisé (pas de Git info)
PS1='[\u@\h:\w]\$ '

# Aliases sécurité
alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'

# Monitoring
alias meminfo='free -h'
alias diskinfo='df -h'
alias cpuinfo='top -bn1 | head -20'

# PATH minimal
export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

# Logs
export HISTTIMEFORMAT="%Y-%m-%d %H:%M:%S "
export HISTSIZE=50000

Bonnes Pratiques

Organisation

# Structure recommandée
~/.bashrc              # Interactif
~/.bash_profile        # Login (source .bashrc)
~/.bash_aliases        # Aliases séparés
~/.bash_functions      # Fonctions séparées
~/.bash_custom/        # Scripts custom
~/.secrets/            # Variables sensibles

Performance

# Profiler chargement
time bash --login -c exit

# Optimiser :
# - Éviter commandes lentes dans .bashrc
# - Lazy load tools (nvm, rbenv)
# - Cache résultats si possible

Portabilité

# Code POSIX (compatible bash/zsh/sh)
if [ -f ~/.profile ]; then
    . ~/.profile
fi

# Bash-specific features
if [ -n "$BASH_VERSION" ]; then
    # Bash only code
fi

Conclusion

Les variables d'environnement sont au cœur de la configuration Linux :

Définir variables :

export MY_VAR="value"           # Temporaire
echo 'export MY_VAR="value"' >> ~/.bashrc  # Permanent
source ~/.bashrc                # Recharger

PATH :

export PATH=$PATH:/new/path
export PATH=/priority/path:$PATH

Fichiers :

~/.bashrc         # Interactif
~/.bash_profile   # Login
~/.profile        # POSIX
/etc/profile.d/   # Système

Debugging :

echo $VAR
env | grep VAR
source ~/.bashrc

Avec une configuration propre, votre environnement shell est optimisé, sécurisé et productif !