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.

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

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

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

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.

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 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 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"
}

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

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

.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

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

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

.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

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

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 !