Présentation de JumpServer
JumpServer est une solution open source de gestion des accès privilégiés (PAM — Privileged Access Management). Développée principalement en Python avec le framework Django, elle fournit un portail unique pour l'administration, l'audit et le contrôle des connexions vers les ressources informatiques. Conçue autour des principes 4A (Authentication, Authorization, Accounting, Audit), elle centralise l'accès aux serveurs via SSH, Telnet, RDP et VNC, tout en enregistrant les sessions pour une traçabilité complète.
L'interface s'appuie sur une Web Terminal moderne et l'architecture est distribuée : un nœud central expose une API REST tandis que des nœuds d'accès peuvent être déployés dans plusieurs datacenters ou zones géographiques. Cette approche permet une montée en charge horizontale sans limitation stricte de concurrence.
Architecture et composants clés
Avant toute installation, il est utile de comprendre les rôles suivants :
- Utilisateur JumpServer : compte humain (administrateur, développeur, exploitant) s'authentifiant sur le portail.
- Utilisateur administré : compte privilégié existant sur l'actif cible, utilisé par JumpServer pour effectuer des opérations de gestion.
- Utilisateur système : compte technique provisionné automatiquement par JumpServer sur les actifs, auquel l'utilisateur final se connecte.
- Domaine réseau : passerelle permettant d'atteindre des ressources situées dans un réseau isolé.
- Filtrage de commandes : mécanisme de blocage d'instructions spécifiques selon le profil.
Déploiement conteneurisé
La méthode recommandée consiste à utiliser Docker et Docker Compose. L'exemple ci-dessous suppose un hôte sous CentOS 7/8 ou une distribution compatible.
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
sudo yum install -y docker-ce docker-compose-plugin
sudo systemctl enable --now docker
mkdir -p /opt/jumpserver-pam && cd /opt/jumpserver-pam
curl -fsSL https://github.com/jumpserver/jumpserver/releases/latest/download/quick_start.sh | bash
Si l'environnement ne dispose pas d'accès direct aux registres publics, préparez les images depuis un miroir local :
cat > /tmp/prepare-images.sh <<'EOF'
#!/usr/bin/env bash
REGISTRY="docker.mirrors.ustc.edu.cn/jumpserver"
LOCAL_PREFIX="jumpserver"
declare -A IMAGES=(
["nginx"]="alpine2"
["core"]="v2.28.0"
["koko"]="v2.28.0"
["luna"]="v2.28.0"
["lina"]="v2.28.0"
["guacamole"]="v2.28.0"
["mysql"]="5"
["redis"]="6-alpine"
)
for svc in "${!IMAGES[@]}"; do
docker tag "${REGISTRY}/${svc}:${IMAGES[$svc]}" "${LOCAL_PREFIX}/${svc}:${IMAGES[$svc]}"
done
EOF
chmod +x /tmp/prepare-images.sh
bash /tmp/prepare-images.sh
Le fichier docker-compose.yml peut être simplifié comme suit :
version: '3.8'
services:
jumpserver-core:
image: jumpserver/core:v2.28.0
container_name: js-core
volumes:
- js-data:/opt/jumpserver/data
ports:
- "8080:8080"
environment:
SECRET_KEY: ${SECRET_KEY}
BOOTSTRAP_TOKEN: ${BOOTSTRAP_TOKEN}
DB_HOST: js-db
DB_PORT: 3306
DB_USER: jumpserver
DB_PASSWORD: ${DB_PASSWORD}
DB_NAME: jumpserver
REDIS_HOST: js-cache
REDIS_PORT: 6379
REDIS_PASSWORD: ${REDIS_PASSWORD}
depends_on:
- js-db
- js-cache
js-db:
image: jumpserver/mysql:5
container_name: js-mysql
environment:
MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
MYSQL_DATABASE: jumpserver
MYSQL_USER: jumpserver
MYSQL_PASSWORD: ${DB_PASSWORD}
volumes:
- js-mysql:/var/lib/mysql
js-cache:
image: jumpserver/redis:6-alpine
container_name: js-redis
command: redis-server --requirepass ${REDIS_PASSWORD}
volumes:
- js-redis:/data
js-proxy:
image: jumpserver/nginx:alpine2
container_name: js-nginx
ports:
- "80:80"
depends_on:
- jumpserver-core
volumes:
js-data:
js-mysql:
js-redis:
Démarrez la pile :
cd /opt/jumpserver-pam
docker compose up -d
Installation manuelle pour environnement legacy
Dans des environnements ne supportant pas les conteneurs, une installation classique est possible. Le système cible doit être CentOS 7.5 ou supérieur, avec SELinux et le pare-feu désactivés ou correctement configurés.
sudo yum -y install git python3-pip mariadb-devel gcc automake autoconf python3-devel sshpass lrzsz readline-devel
cd /opt
git clone --depth 1 https://github.com/jumpserver/jumpserver.git js-pam
cd js-pam/install
pip3 install -r requirements.txt
Créez un fichier de configuration pour accélérer les téléchargements PyPI :
mkdir -p ~/.pip
cat > ~/.pip/pip.conf <<'EOF'
[global]
index-url = https://mirrors.aliyun.com/pypi/simple/
[install]
trusted-host = mirrors.aliyun.com
EOF
Initialisez la base de données et le service :
sudo yum install -y mariadb-server
sudo systemctl enable --now mariadb
python3 install.py
Si le service ne démarre pas, vérifiez les deux processus principaux :
cd /opt/js-pam
python3 manage.py runserver 0.0.0.0:80 &
python3 run_websocket.py &
Configuration des utilisateurs et des actifs
Connectez-vous à l'interface web via http://<adresse-ip> avec les identifiants par défaut admin/admin.
Création des utilisateurs métier
Créez trois profils représentatifs :
- pierre.durand : profil Exploitation, droits élevés.
- sophie.martin : profil Développement, accès en lecture et déploiement.
- luc.bernard : profil Base de données, opérations SQL uniquement.
JumpServer génère automatiquement une paire de clés SSH par utilisateur et envoie un courriel contenant le mot de passe web et le lien de téléchargement de la clé privée.
Ajout d'actifs
Un actif représente une machine cible. Lors de l'ajout, il faut renseigner :
- le nom d'hôte (clé d'unicité) ;
- l'adresse IP interne et le port ;
- l'utilisateur administré (par exemple
rootou un compte sudo sans mot de passe).
Exemple de création d'un utilisateur administré non-root sur une cible :
sudo useradd pamadmin
echo "P@ssw0rd!" | sudo passwd --stdin pamadmin
echo "pamadmin ALL=(ALL) NOPASSWD: ALL" | sudo tee /etc/sudoers.d/pamadmin
sudo chmod 440 /etc/sudoers.d/pamadmin
Utilisateurs système et règles sudo
Les utilisateurs système sont provisionnés automatiquement par JumpServer sur les actifs via Ansible. Associez-leur des alias sudo pour limiter les commandes autorisées :
Alias sudo : DBA_CMDS
Commandes autorisées : /usr/bin/mysql, /usr/bin/mysqldump, /usr/bin/psql
Avant d'autoriser un utilisateur métier sur un actif, il est nécessaire de pousser l'utilisateur système correspondant afin de créer la trace de déploiement.
Règles d'autorisation
Une règle d'autorisation fait le lien entre :
- un ou plusieurs utilisateurs JumpServer ;
- un ou plusieurs actifs ou groupes d'actifs ;
- un utilisateur système.
Sans cette association, l'utilisateur ne verra aucune ressource dans son portail et ne pourra pas établir de connexion.
Supervision et audit
JumpServer enregistre l'ensemble des sessions interactives. Dans le menu Journal d'audit, l'administrateur peut :
- consulter les sessions actives en temps réel ;
- interrompre une connexion en cours (blocage) ;
- rejouer une session enregistrée ;
- afficher l'historique des commandes exécutées.
Les transferts de fichiers (upload/download) sont également jorunalisés, ce qui facilite la conformité et les investigations post-incident.
Accès en ligne de commande
Les utilisateurs peuvent se connecter au bastion en SSH avec leur clé privée. Après authentification, un menu interactif s'affiche :
=== JumpServer — Portail de connexion ===
1) Saisir l'ID de l'actif pour se connecter directement.
2) Utiliser / + IP, nom d'hôte ou commentaire pour rechercher.
3) Afficher les actifs autorisés (P/p).
4) Afficher les groupes d'actifs (G/g).
5) Exécuter une commande sur plusieurs hôtes (E/e).
6) Téléverser un fichier vers plusieurs hôtes (U/u).
7) Télécharger un fichier depuis plusieurs hôtes (D/d).
8) Afficher l'aide (H/h).
0) Quitter (Q/q).
Votre choix :
Pour lister les machines accessibles :
Votre choix : p
[ID] Nom d'hôte Adresse IP Port Utilisateur système
[0] srv-web-01 10.0.0.71 22 [devops]
[1] srv-db-01 10.0.0.72 22 [dba]
La connexion à un actif s'effectue simplement en saisissant son identifiant numérique. L'utilisateur est alors connecté avec le compte système défini par la règle d'autorisation.