DEV Community: Patrice Eon

Guide d'apprentissage pour maîtriser GitHub Copilot

Patrice Eon — Tue, 23 Dec 2025 11:37:36 +0000

GitHub Copilot est le nouvel allié des développeurs pour coder plus vite et plus intelligemment.

Mais soyons honnêtes : la plupart d'entre nous l'utilisent comme une simple autocomplétion augmentée.

Résultat ? On exploite à peine 20 % de sa véritable puissance. C'est un peu comme avoir une Ferrari et ne jamais dépasser la deuxième vitesse.

En effet en 2025, GitHub Copilot a pris du muscle. Fini l'assistant timide qui suggère trois lignes de code. Place à un partenaire IA complet, dopé aux modèles de pointe (Claude Sonnet 4.5, GPT-5, Gemini 3 Pro). Il comprend désormais votre code dans son ensemble, orchestre des tâches complexes en autonomie et s'intègre parfaitement à votre écosystème de développement.

Ce guide existe pour une raison simple : vous faire passer de 20 % à 100 % d'utilisation. Grâce à 10 techniques éprouvées et des protocoles avancés, vous découvrirez comment transformer Copilot d'un simple assistant en copilote stratégique.

Parce qu'au final, l'objectif n'est pas juste de coder plus vite. C'est de coder plus intelligemment, en laissant l'IA gérer la vitesse pendant que vous vous concentrez sur ce qui compte vraiment : l'intelligence de vos solutions.

Table des matières

Partie I : Installation et présentation des fondamentaux (démarrage en douceur)
- 1.1 GitHub Copilot dans votre IDE vs GitHub Copilot CLI
- 1.2 Installer GitHub Copilot sur VS Code
- 1.3 Installer GitHub Copilot sur IntelliJ IDEA
- 1.4 Obtenir un compte GitHub avec accès Copilot
- 1.5 Installer GitHub Copilot CLI
- 1.6 GitHub Copilot dans votre IDE : Aperçu des contrôles et fonctionnalités
Partie II : Maîtriser les leviers de productivité
- 2.1 Maîtriser les Commandes Slash
- 2.2 Utiliser les Variables de Contexte
- 2.3 Créer des Instructions Personnalisées
- 2.4 Stratégie d'ouverture de Fichiers
- 2.5 Commenter le flux de travail
- 2.6 Le Dialogue itératif
- 2.7 Fichiers de prompts personnalisés
- 2.8 Glisser-Déposer de Contexte
- 2.9 Stratégie de Nettoyage de Contexte
- 2.10 Maîtriser la Sélection de Code
- 2.11 Créer des issues à partir de captures d’écran
- 2.12 Utiliser Github Copilot partout… Mais tirer le meilleur du plugin dans VS Code
Partie III : Écosystème et Agenticité Avancée
- 3.1 Le Protocole de Contexte Modèle (MCP)
- 3.2 Qu’est‑ce que « Awesome GitHub Copilot » ?
- 3.3 Custom agents
- 3.4 Maîtriser le GitHub Copilot CLI
Partie IV : Qualité, sécurité et rôle humain (Les Pièges)
- 4.1 Prendre les suggestions de Copilot pour des vérités
- 4.2 Ignorer la sécurité du code
- 4.3 Utiliser Copilot comme béquille pour les fondamentaux
- 4.4 Surcompliquer des solutions simples
- 4.5 Ne pas fournir de contexte pour de meilleures suggestions
- 4.6 Ne pas garder Copilot dans le bon scope
- 4.7 Zapper les tests parce que « Copilot l’a écrit »
Conclusion : Codez plus Intelligemment, pas seulement plus vite

Partie I : Installation et présentation des fondamentaux (démarrage en douceur)

Cette partie couvre l'installation, les accès, et la compréhension des modes d'interaction avec Github Copilot.

1.1 GitHub Copilot dans votre IDE vs GitHub Copilot CLI 🖊️

GitHub Copilot se déploie sur deux fronts stratégiques : directement intégré à votre IDE préféré (VS Code, IntelliJ...) pour une assistance en temps réel, et en ligne de commande pour orchestrer vos workflows depuis le terminal.

GitHub Copilot dans votre IDE

Fonctionnalités :

Complétion de code en temps réel (ligne ou fonction complète)
Copilot Chat intégré pour poser des questions ou générer des snippets
Intégration IDE : coloration, prévisualisation, acceptation avec Tab
Support multi-langages : Python, Java, JS, C++, Go, etc.

Usage typique :

Saisie de code et suggestions automatiques
Idéal pour une assistance immédiate et interactive dans l’éditeur

GitHub Copilot CLI

Fonctionnalités :

Assistant IA dans le terminal, indépendant de l’éditeur
Exploration de projet (fichiers, dépendances, structure)
Génération et modification de code via prompts en langage naturel
Exécution de commandes shell suggérées (avec confirmation)
Refactoring et workflows multi-étapes automatisés

Usage typique :

Travailler depuis le terminal, générer ou corriger du code
Idéal pour workflows scriptables ou projets distants

Comparaison rapide

Fonctionnalité	Copilot VS Code	Copilot CLI
Suggestions inline de code	✅ Oui	❌ Non
Chat intégré	✅ Oui	❌ Terminal-style
Modification de fichiers	✅ Oui	✅ Oui
Exécution commandes shell	❌	✅ Oui
Analyse globale du projet	Limité	✅ Oui
Indépendant de l’éditeur	❌	✅ Oui
Automatisation & workflows complexes	Moyen	✅ Oui

Résumé : VS Code pour coder efficacement au quotidien, CLI pour gérer et transformer des projets depuis le terminal.

1.2 Installer GitHub Copilot sur VS Code 🧩

La documentation officielle pour installer GitHub Copilot dans VS Code se trouve ici : Copilot VS Code extension

Ouvrir VS Code
Aller dans la Marketplace des extensions (Ctrl+Shift+X ou Cmd+Shift+X sur Mac)
Rechercher GitHub Copilot
Cliquer sur Installer
Se connecter à GitHub quand demandé (OAuth)
Les suggestions apparaissent automatiquement
Pour activer/désactiver : Ctrl+Shift+P / Cmd+Shift+P → taper Copilot → Enable/Disable GitHub Copilot

Astuce :

Configurer les suggestions dans Fichier → Préférences → Paramètres → GitHub Copilot

Fonctionne avec Python, Java, JS, C++, Go, etc.

1.3 Installer GitHub Copilot sur IntelliJ IDEA 🧩

La documentation officielle pour installer GitHub Copilot dans IntelliJ (mais également les autres IDE supporté) se trouve ici : Copilot Jetbrains extension

Ouvrir IntelliJ IDEA
Aller dans File → Settings → Plugins (Preferences → Plugins sur Mac)
Cliquer sur Marketplace, chercher GitHub Copilot
Cliquer sur Installer
Redémarrer IntelliJ
Se connecter à GitHub pour activer Copilot
Les suggestions apparaissent automatiquement lors de la saisie de code

Astuce :

Activer/désactiver : Settings → GitHub Copilot
Utilisable aussi dans le terminal intégré pour générer des snippets

1.4 Obtenir un compte GitHub avec accès Copilot 📝

Étape 1 : Créer un compte GitHub

Aller sur https://github.com/join
Remplir le formulaire (nom d’utilisateur, email, mot de passe)
Confirmer votre email

Étape 2 : Activer GitHub Copilot

Option	Type d’abonnement	Coût	Étapes
A	Free	0$	1. Aller sur https://github.com/features/copilot 2. Cliquer sur Free 3. Suivre l’activation
B	Pro	~10$/mois ou 100$/an	Aller sur https://github.com/settings/billing → entrer les informations de paiement
C	Pro+	~39$/mois ou 390$/an	Aller sur https://github.com/settings/billing → entrer les informations de paiement

Alternative : Abonnement Etudiant (gratuit)

Aller sur GitHub Student Developer Pack

Étape 3 : Vérifier l’accès

Aller sur https://github.com/features/copilot
Vérifier le message “You have access” ou la période d’essai en cours
Installer l’extension dans VS Code ou IntelliJ et commencer à coder

1.5 Installer GitHub Copilot CLI 🚀

GitHub Copilot CLI, permet de déléguer une tâche à l'IA directement dans votre terminal — exit l'éditeur de code.

Pourquoi l'installer maintenant ? Parce que l'usage agentique avancé (détaillé plus loin dans ce guide) repose sur cette base.

Prérequis

Un compte GitHub avec accès à Copilot activé (voir section précédente)
Node.js version 20 ou supérieure installé

Étapes d'installation

Ouvrir votre terminal
Installer l'extension GitHub CLI si ce n'est pas déjà fait :

# Sur macOS/Linux avec Homebrew
brew install gh

# Sur Windows avec winget
winget install --id GitHub.cli

Se connecter à GitHub :

gh auth login

Installer l'extension Copilot CLI :

gh extension install github/gh-copilot

Vérifier l'installation :

gh copilot --version

Utilisation basique

Une fois installé, vous pouvez utiliser Copilot directement dans le terminal :

# Demander de l'aide sur une commande
gh copilot suggest "comment lister tous les fichiers modifiés dans les 7 derniers jours"

# Expliquer une commande complexe
gh copilot explain "git rebase -i HEAD~3"

Astuce :

La documentation complète est disponible sur : GitHub Copilot CLI Documentation
Utilisez gh copilot --help pour voir toutes les commandes disponibles

1.6 GitHub Copilot dans votre IDE : Aperçu des contrôles et fonctionnalités 🎛️

N’utiliser qu’un prompt basique (comme ci‑dessous) sans exploiter les autres fonctionnalités utiles de GitHub Copilot peut sembler assez limitant.

C’est pourquoi je partage une collection d’astuces pratiques; vous en reconnaîtrez certaines, mais j’espère que quelques‑unes vous inspireront à tirer pleinement parti de ce que Copilot peut offrir.

1.6.1 Les contrôles du panneau de chat

Configurer un nouveau contexte pour vos prompts. Utile pour repartir à zéro sur des tâches non liées.
Réouvrir les contextes de prompts historiques utilisés auparavant. Utile pour basculer entre différents contextes.
Générer des fichiers de prompt, des instructions, etc. (voir la section Meta Prompting ci‑dessous)
Options supplémentaires de configuration de la fenêtre de chat (prompt)
Maximiser votre fenêtre de chat (prompt)
Masquer votre fenêtre de chat (prompt)

1.6.2 Modes Agent, Ask, Edit, Plan et Configure

Choisissez comment vous voulez que GitHub Copilot vous aide. Dans beaucoup de cas, vous utiliserez simplement l’Agent. Difficile de voir pourquoi on aurait encore besoin de Ask ou Edit une fois qu’on a l’Agent, utilisé pour notre Vibe Programming !

En réalité, ces trois modes répondent à des intentions différentes :

Ask est le mode conversation et compréhension. Il sert à poser des questions, demander des explications, explorer une API, comprendre un bout de code ou valider une approche sans modifier votre code. C’est idéal pour réfléchir, apprendre ou lever un doute rapidement.
Edit est le mode chirurgical. Vous sélectionnez du code et demandez une transformation précise : refactoriser, renommer, optimiser, traduire un commentaire, corriger un bug local. Copilot agit uniquement sur la zone ciblée, sans initiative au-delà de ce que vous avez demandé. Parfait quand vous voulez garder un contrôle strict.
Agent est le mode autonome et orienté objectif. Vous lui donnez une intention globale (« ajoute l’authentification », « implémente cette feature », « corrige les tests cassés ») et il explore le projet, crée ou modifie plusieurs fichiers, exécute des actions et itère. C’est le compagnon idéal pour le Vibe Programming, quand vous voulez avancer vite et laisser Copilot prendre des décisions.

👉 En résumé :

Ask = comprendre et discuter
Edit = modifier précisément
Agent = déléguer et construire

Les trois sont complémentaires : Agent pour aller vite, Edit pour ajuster, Ask pour comprendre.

Passer par Configure custum Agents est utile pour fournir de meilleures instructions à l’agent afin de permettre des prompts plus puissants. Vous pouvez en savoir plus loin dans l’article.

1.6.3 Sélection des modèles LLM

Sélectionnez le modèle LLM que vous souhaitez utiliser. Certains modèles sont meilleurs que d’autres. D’après mon expérience, Claude Sonnet est plus pertinent que GPT.

Mais attention, l’utilisation des modèles est limitée par le quota de requêtes indiqué par 0x, 1x et 3x. Ce sont des multiplicateurs appliqués à votre quota de requêtes premium.

0x : utilisation illimitée
1x : exactement votre quota de requêtes
3x : 3× votre quota de requêtes

Donc, utilisez‑les avec parcimonie selon vos besoins.

Le mode Agent de GitHub Copilot est devenu l’un des meilleurs agents de code depuis quelques mois.
Il peut analyser votre projet entier, traiter des issues GitHub, rédiger des pull requests, et même aider à écrire des tests.

Quel modèle fonctionne réellement le mieux en mode Agent de Copilot ?

Gemini 3 Pro : Le débogueur UI

Gemini 3 Pro de Google apportent quelque chose d’unique : un véritable raisonnement multimodal.

Cela signifie qu’il peut comprendre code, texte, images et même diagrammes en une seule passe.

Idéal pour :

Débogage UI ou visuel
Analyse code + documents
Pipelines de données en entreprise

Avantages :

✅ Excellent pour le raisonnement visuel
✅ Rapide, économique et scalable
✅ Excelle dans le traitement parallèle et l’orchestration d’outils

Inconvénients :

❌ Donne parfois des solutions génériques pour des tâches générales.
❌ Moins « réfléchi » que Claude pour le raisonnement profond.

GPT-5 : Le penseur profond

Si votre travail implique du raisonnement multi-étapes, du débogage complexe ou une analyse au niveau de l’architecture, GPT-5 brille — mais il faut bien l’instruire avec des prompts. Ses capacités d’analyse surpassent de nombreux autres modèles, et il peut résoudre des bugs complexes tout en offrant une vue d’ensemble plus claire du scénario.

Idéal pour :

Gros refactorings multi-fichiers
Raisonnement et débogage profonds
Projets nécessitant une compréhension contextuelle longue

Avantages :

✅ Très fort en raisonnement logique
✅ Gère texte + vision (excellent pour les diffs UI et captures d’écran [pas encore testé])
✅ Modes de raisonnement contrôlables

Inconvénients :

❌ Plus lent que les modèles légers.
❌ Moins économique pour les petits projets

Vous vous sentez bloqué ? Revenez au point de départ et expliquez tout le cas d’usage. Boom — c’est probablement le meilleur modèle pour résoudre ces casse-têtes. Un peu lent, mais efficace.

Claude Sonnet 4.5 : Le polyvalent raffiné

S’il y a un modèle qui se rapproche le plus d’un ingénieur senior, c’est Claude Sonnet 4.5.

Développé par Anthropic, Claude est reconnu pour sa clarté, sa fiabilité et sa capacité à gérer des immenses bases de code — jusqu’à 1 million de tokens.

Idéal pour :

Dépôts de niveau entreprise
Tâches autonomes de plusieurs heures
Sorties sûres et à faible hallucination

Avantages :

✅ Gère d’énormes fenêtres de contexte
✅ Excellent pour les grands monorepos et les refactorings
✅ Faible taux d’hallucination et ton cohérent

Inconvénients :

❌ Limité par le débit sur les configurations gratuites ou partagées
❌ Tarification légèrement premium

Avis personnel :

Claude Sonnet génère généralement un code plus propre et plus fiable que les autres. Mais quand vous atteignez les limites de débit, c’est frustrant — surtout lors de longues sessions.

Astuce : Pour des agents longue durée (comme des migrations de données ou des audits de dépôt), Claude Sonnet 4.5 est le choix le plus sûr.

1.6.4 Tableau de bord d’utilisation de Copilot

Vous pouvez voir combien vous avez utilisé de requêtes premium ce mois‑ci. Avec un abonnement PRO payant, vous avez un quota mensuel de 300 requêtes.

Notez que l’allocation est réinitialisée le premier du mois prochain.

1.6.5 Contrôle de l’activité des prompts

C’est ici que vous lancez le prompt ou l’arrêtez (s’il tourne)
Après la réponse, vous pouvez garder les changements effectués par l’agent ou les annuler.
Pour certaines étapes, il demandera votre permission avant d’agir (ex. exécuter une appli, installer, supprimer un fichier, etc.). Vous pouvez aussi le configurer pour toujours autoriser.

1.6.6 Fichier de contexte pour l’agent

Vous pouvez limiter votre agent à un contexte spécifique, qui peut être :

Un fichier ouvert
Une partie du fichier ouvert (comme sur le schéma ci‑dessus, de la ligne 11 à 16)
Ou joindre un nouveau fichier (ex. une image que l’agent lira, puis codera)
Utiliser # pour indiquer un fichier d’intérêt, @ pour accéder à l’extension et / pour accéder à une commande ou un fichier de prompt.

1.6.7 Gestion de code (Source Control)

Vous pouvez effectuer la gestion de code directement depuis VS Code.

Accéder à Source Control. S’il n’y en a pas, un bouton permet de l’initialiser ici
Ajouter (au contrôle de source), retirer ou ouvrir les fichiers modifiés
Écrire votre message de commit ici, ou utiliser l’IA (bouton étoile) pour le générer
Valider vos changements ajoutés, et choisir Amend, Push ou Sync avec le commit.

1.6.8 Paramètres de l’extension GitHub Copilot

Ouvrir le panneau des Extensions
Sélectionner les paramètres de Copilot
Vous pouvez maintenant activer l’autocomplétion pour le Markdown ou le texte brut !!

Partie II : Maîtriser les leviers de productivité

Cette section est le cœur du guide, détaillant les stratégies pratiques pour améliorer la précision et l'efficacité.

2.1 Maîtriser les commandes Slash

Les slash commandes sont des raccourcis intégrés qui évitent des prompts interminables. Tapez / dans Copilot Chat pour débloquer une productivité instantanée.

Slash Commands essentielles :

/tests — Génère des tests unitaires complets pour le code sélectionné, avec cas limites et mocks
/fix — Analyse les erreurs et propose des correctifs (null checks, refactors)
/explain — Explique des snippets de code complexes
/doc — Génère des commentaires de documentation pour fonctions et classes
/refactor — Suggère des améliorations et optimisations de code

Astuce : Combinez /tests avec #file:src/service.ts pour générer des tests spécifiques au service sans boilerplate.

Pourquoi c’est important : Ces commandes fonctionnent en chat et en inline (Alt+/) et sont incluses dans l’offre basique. Commencez par /tests et /fix — des gains rapides pour tout codebase.

Impact réel : Sur ce projet e‑commerce, /tests m’a à lui seul économisé 8 à 10 heures d’écriture de tests manuels sur tous les services.

Note gratuit vs payant : la version gratuite limite vos requêtes mensuelles. En gratuit, je me cognais les limites en plein projet. D’où mon passage à l’abonnement payant (10 $/mois individuel). Si vous utilisez Copilot au quotidien, le payant vaut le coup rien que pour l’illimité.

2.2 Utiliser les Variables de Contexte 📦

Copilot n’est pas devin. Plus vous lui donnez de contexte, mieux il vous aide.

Variables de contexte puissantes :

#file — Référencez des fichiers précis : #file:auth.service.ts
#codebase — Laissez Copilot fouiller toute votre base de code
#editor — Ajoute tous les fichiers ouverts au contexte
@workspace — Posez des questions sur toute la structure du projet
#fetch — Récupère du contenu web ou de la doc

Exemple en action :

@workspace Sur notre serveur Node, quelles optimisations pour gérer 10 000 requêtes concurrentes ?

Astuce : surlignez le code pertinent avant de questionner. Copilot donne alors des suggestions ciblées et évite les suppositions.

2.3 Créer des instructions personnalisées ✍️

Pour arrêtez de vous battre avec les suggestions : Définir les standards de codage de l'équipe (style, conventions, utilisation de const vs var) dans le fichier .instructions.md,. L'objectif est de garantir une cohérence permanente du code généré.

Configurer les instructions personnalisées :

Lancez Chat: New Instructions File depuis la palette de commandes
Cela crée .instructions.md dans le dossier .github/instructions
Définissez vos règles projet en Markdown

Exemple de fichier d’instructions :

Custom instructions for Copilot

Project Context
This project is a React + Node.js e-commerce platform

Code Style
- Use TypeScript strict mode
- Prefer functional components with hooks
- Use camelCase for variables
- Write descriptive variable names (no single letters)

Testing
- Use Jest for unit tests
- Use Playwright for E2E tests
- Always include error handling tests

Indentation
We use 2 spaces, not tabs

Pourquoi ça marche : Copilot génère désormais du code conforme à VOTRE style, pas des patterns génériques. Temps d’édition réduit jusqu’à 40 %.

2.4 Stratégie d'ouverture de fichiers 📂

Petit secret : Copilot ne voit pas les fichiers fermés. Ouvrir 3 à 5 fichiers liés lui donne un contexte massif sur la structure.

Stratégie d’ouverture maligne :

Avant d’écrire du nouveau code, ouvrez :

Le fichier que vous éditez
Les utilitaires/helpers liés
Les fichiers de types
Les fichiers de config
Des implémentations similaires existantes

Exemple : écrire un nouvel endpoint API ? Ouvrez :

routes/user.routes.ts (là où vous travaillez)
controllers/user.controller.ts (patterns existants)
models/User.ts (structure de données)
middleware/auth.ts (contexte d'authentification)

Rappel critique : fermez les fichiers hors sujet quand vous changez de tâche. Trop de fichiers non liés perturbent le contexte.

2.5 Commenter le Flux de travail 🗨️

Écrire des commentaires détaillés spécifiant l'architecture, le flux, le traitement des erreurs et les cas limites AVANT d'écrire le code. Cette planification augmente significativement la précision de la sortie de l'IA.

// Objectif : Auth JWT + refresh tokens + reset password sécurisé
// Flux : signup -> email verify -> login -> refresh -> logout
// Exigences : rate limiting, CSRF, rotation de refresh tokens, IP logging
// Cas limites : token expiré, utilisateur désactivé, tentative brute force

Voyez Copilot comme un dev junior. Plus vos consignes sont claires, meilleur est le résultat.

Workflow « comment-first »

Plutôt que plonger direct dans le code, écrivez en tête de fichier un commentaire descriptif expliquant l’architecture et le flux.

Résultat : Copilot génère un code qui suit vos spécifications, incluant la gestion d’erreurs et les cas limites.

Astuce : incluez des exemples d’entrées/sorties dans les commentaires. La précision des suggestions augmente fortement.

2.6 Le Dialogue itératif 🔄

Ne pas accepter la première suggestion. Affiner les résultats par des follow-up prompts spécifiques pour garantir la validation côté client ou l'ajout de logique manquante.

Gros morceau en 2025. Copilot CLI intègre Claude Sonnet 4.5 — et ce modèle est bluffant en code.

Fonctionnalités CLI puissantes :

/model — Changez de modèle IA à la volée
Exécution directe du shell avec le préfixe !
Support image via mentions @
Permissions d’outils améliorées avec des glob patterns

Exemple concret :

# Générer des commandes terminal complexes
gh copilot explain "How do I find all .js files modified in the last 7 days and run eslint on them?"

# Exécuter directement !
npm run test:unit

Astuce : utilisez la commande /usage pour suivre les requêtes premium et optimiser votre flux.

2.7 Fichiers de prompts personnalisés 🗃️

Créer des modèles réutilisables pour des requêtes complexes dans votre projet (.github/prompts/).

Le mode Agent permet à Copilot de travailler de façon autonome — trouver des fichiers, éditer du code, et décider sans saisie constante.

Quand utiliser le mode Agent :

Refactorings sur de grandes bases de code
Conversion entre frameworks
Implémentation de fonctionnalités à travers plusieurs fichiers
Débogage d’issues complexes

Comment activer :

Ctrl+Shift+Alt+L (Windows) ou Cmd+Shift+Alt+L (Mac)
Ou /agent dans le chat

Exemple de prompt :

Commande GitHub Copilot dans mon espace réel

@workspace Objectif :
Créer une page web statique qui présente une estimation des résultats du FC Nantes (FCN) pour la fin de saison de Ligue 1.

Contraintes générales :
Page web en HTML, CSS et JavaScript vanilla
Design moderne, lisible et responsive

Couleurs officielles du FC Nantes :
Jaune : #FFD700
Vert : #006A3D

Typographie sportive et élégante
Aucun framework externe

Note de sécurité : le mode Agent requiert votre validation avant exécution des changements. Relisez tout attentivement.

2.8 Glisser-Déposer de Contexte 🖱️

Contexte Visuel et Logistique : déposer des fichiers, des logs d'erreurs, des dossiers, et même des captures d'écran directement dans Copilot Chat pour une analyse immédiate. Utiliser le fichier package.json pour informer l'IA des dépendances.

Par ailleurs vous connaissez ce moment où vous êtes « dans la zone » et ne voulez pas changer de fenêtre ? L’inline chat est fait pour ça.

Raccourcis inline chat (je cherchais où l’ouvrir dans VS Code jusqu’à trouver ces raccourcis) :

Ctrl+I / Cmd+I — Démarrer le chat inline directement dans l’éditeur
Alt+/ — Accès rapide aux slash commands en inline

Cas parfaits :

Petites corrections en debug
Générer une fonction unique
Ajouter de la gestion d’erreurs à du code existant
Refactoriser un bloc précis

Workflow pro : surlignez le code problématique → Ctrl+I → tapez /fix → acceptez la suggestion → continuez à coder.

2.9 Stratégie de nettoyage de contexte 🧹

Supprimer les questions non pertinentes ou démarrer un nouveau fil de conversation pour éviter que l'historique ne dilue la qualité de la réponse (améliore la qualité de 30 %).

Sauvez vos meilleurs prompts et partagez‑les avec l’équipe. Les fichiers de prompt sont des templates réutilisables pour les tâches courantes.

Créer des fichiers de prompt :

Chat: New Prompt File via la palette
Enregistrez dans .github/prompts/
Écrivez le prompt en Markdown avec métadonnées

Exemple de fichier (.prompt.md) :

mode: 'agent'
tools: ['githubRepo', 'search/codebase']
description: 'Generate a new React component'
Your goal is to generate a new React component based on templates in #githubRepo yourcompany/design-system.
Requirements:
* Use TypeScript with strict types
* Follow design system patterns
* Include PropTypes
* Add Storybook story
* Include unit tests with React Testing Library

Utilisation : tapez /your-prompt-name dans le chat.

Bénéfice équipe : tout le monde suit les mêmes bonnes pratiques. Fini les styles incohérents.

2.10 Maîtriser la sélection de Code 🔍

Utiliser @selection ou mettre en surbrillance un bloc de code précis avant de poser une question afin d'obtenir des suggestions plus rapides et plus pertinentes.

Par ailleurs la fonction la plus simple mais sous‑utilisée : glissez des fichiers directement dans Copilot Chat.

Ce que vous pouvez glisser :

Plusieurs fichiers à la fois
Des dossiers entiers
Des captures et images (NOUVEAU en 2025 !)
Des logs d’erreurs du terminal
Des sorties d’échecs de tests

Cas puissant — rapport de bug :

Prenez une capture du bug UI
Glissez la capture dans Copilot Chat
Tapez : « Crée un rapport de bug pour ce problème de rendu »
Copilot analyse l’image et génère une documentation de bug détaillée

Astuce avancée : glissez votre package.json pour aider Copilot à comprendre vos dépendances et proposer du code compatible.

BONUS : stratégie « supprimer et redémarrer »

Copilot utilise l’historique de conversation comme contexte. S’il donne des réponses hors sujet :

Supprimez les anciennes questions non pertinentes
Démarrez un nouveau thread via le bouton +
Utilisez les flèches haut/bas pour naviguer dans l’historique (comme dans le terminal)

Cela garde la conversation ciblée et améliore la qualité des réponses d’environ 30 %.

Check‑list de gains rapides pour cette semaine

Avant de fermer cet article, engagez‑vous à tester ces trois points :

Ajoutez un fichier .instructions.md dans le répertoire instructions à la racine de votre projet principal, avec votre style de code
Installez Copilot CLI et essayez la commande /model avec Claude Sonnet 4.5
Ouvrez 4 à 5 fichiers liés la prochaine fois que vous écrivez du nouveau code et regardez les suggestions s’améliorer

2.11 Créer des issues à partir de captures d’écran 📸

Vous avez un rapport de bug avec une capture d’écran ? Ne l’écrivez pas manuellement, laissez Copilot s’en charger. Voici comment :

Prenez une capture d’écran du bug (par ex., une icône mal alignée ou un problème de mise en page)
Glissez-la dans la discussion Copilot sur github.com/copilot.
Ajoutez une consigne comme :

Crée un nouveau ticket en utilisant le label 'bug'. Utilise cette capture et décris l’icône de flèche qui se chevauche. Applique le modèle de ticket UI de ce dépôt.

Copilot lit l’image, génère un titre et une description clairs, applique les bons labels et utilise les modèles de tickets de votre dépôt. C’est plus rapide qu’une transcription manuelle et il repère souvent des détails que je pourrais manquer.

Astuce : Copilot peut déduire le contexte du ticket à partir de votre capture et de votre consigne ; pas besoin de tout expliciter.

2.12 Utiliser Github Copilot partout… Mais tirer le meilleur du plugin dans VS Code 🌐

Vous pouvez profiter de Github Copilot dans de nombreux IDE tels que Visual Studio Code, JetBrains, Visual Studio, Eclipse, XCode, Vim ou même Neovim.

L’idée est de garder votre environnement familier tout en bénéficiant des fonctionnalités de Github Copilot.

Néanmoins, les plugins VS Code pour Github Copilot sont souvent plus avancés et mis à jour plus fréquemment que pour les autres IDE.

Astuce : installez les plugins VS Code compatibles avec votre IDE préféré, et installez également VS Code en parallèle. Vous profitez ainsi du confort de votre environnement habituel tout en accédant facilement aux dernières nouveautés disponibles dans VS Code.

Partie III : Écosystème et Agenticité Avancée

Cette partie explore l'interopérabilité et les outils de niveau professionnel qui étendent Copilot au-delà de l'IDE.

3.1 Le Protocole de contexte Modèle (MCP) 🚀

Le MCP (Model Context Protocol) est un protocole d'interopérabilité — un peu comme un « USB-C pour les intégrations d'IA » — conçu pour étendre les capacités des modèles d’IA et leur permettre de se connecter de manière sécurisée et structurée à des outils, données et services externes.

Concrètement avec un MCP : L’IA peut accéder à des données réelles, appeler vos APIs, lire vos fichiers ou agir sur vos outils, selon des règles explicites.

Il existe plus de 30 intégrations MCP officielles, couvrant des domaines comme :

GitHub MCP propose un hub central pour la découverte et l'installation de serveurs MCP de partenaires (Figma, Postman, Terraform) Github hub central mcp server.

Intégration/Produit	Type	Résumé	Cas d'usage rapides
Conversion fichiers → Markdown	Utilitaire/Conversion	Convertir PDF, Word, Excel, images, audio en Markdown.	Markdown depuis PDF/Doc
GitHub (assistants IA)	DevOps	Gérer dépôts, issues, PR, workflows en langage naturel.	Gérer issues/PR
Chrome DevTools	DevTools	Serveur MCP pour Chrome DevTools.	Inspecter runtime
Notion (officiel)	Productivité	Serveur MCP officiel pour l’API Notion.	Notes/DB Notion
Azure MCP Tools	Cloud Integrations	Outils Azure MCP pour connecter agents IA et services Azure.	Azure services
Terraform (HCP/Enterprise)	IaC	Générer Terraform plus précis et automatiser workflows.	Infra as Code
Azure DevOps	DevOps	Dépôts, work items, builds, releases, tests, recherche de code.	Repos/CI/CD
Elasticsearch	Recherche/Analytics	Requêtes de recherche, mappings, ES	QL, shards via NL.
Hugging Face	IA/Modèles	Accéder modèles, datasets, Spaces, articles, collections.	Modèles/datasets
Jira + Confluence (remote)	Collaboration IT	Connexion sécurisée Jira/Confluence avec LLM/IDE/plateformes d’agents.	ITSM/Confluence

Expérimenter avec GitHub MCP

Je vous encourage à essayer GitHub MCP par vous-même. Voici comment configurer un serveur MCP localement :
setup github mcp server.

Une fois que GitHub MCP est lancé, vous pouvez le solliciter et l’utiliser.

Dans mon cas, je veux ajouter un nouvel élément de technologie à https://github.com/GoogleCloudPlatform/Template.

Le prompt que j’utilise est le suivant :

Use the GitHub MCP.
Refers to https://github.com/GoogleCloudPlatform/Template,
- Reads the contribution.md, and
- Create a technology item for Perplexity LLM Model, and
- Make a unique branch for the new Technology Item and
- Open a git issue and pull request

Il va alors utiliser Get File, Create Branch, Update File, Open Issue, Open Pull Request, et effectuer toutes les tâches nécessaires disponibles dans MCP Server : GitHub.

Personnellement, j’interagis beaucoup avec les MCP suivants :

Azure DevOps MCP : Voir les éléments de travail, mettre à jour le statut des tâches (ex. : passer à "Code Review"), gérer les PR sans quitter VS Code, réduisant la commutation de contexte.

Agent de Codage Teams : Déléguer des tâches à l'Agent via @GitHub dans Microsoft Teams, qui exécute la tâche sur le dépôt et crée automatiquement une Pull Request.

Chrome DevTools MCP : Utiliser l'Agent pour analyser la performance web (Largest Contentful Paint (LCP), Interaction to Next Paint (INP)) sur n'importe quelle URL.

3.2 🚀 Qu’est‑ce que « Awesome GitHub Copilot » ? 📡

Ce dépôt fournit une boîte à outils complète pour enrichir GitHub Copilot avec :

👉 Awesome Agents — Agents GitHub Copilot spécialisés qui s’intègrent aux serveurs MCP pour offrir des capacités étendues pour des workflows et outils spécifiques
👉 Awesome Prompts — Prompts ciblés et spécifiques à une tâche pour générer du code, de la documentation et résoudre des problèmes précis
👉 Awesome Instructions — Normes de codage et bonnes pratiques exhaustives applicables à des motifs de fichiers ou à des projets entiers
👉 Awesome Collections — Collections organisées de prompts, d’instructions et de modes de chat autour de thèmes et workflows spécifiques

🎯 Pourquoi utiliser « Awesome GitHub Copilot » ?

Productivité : des agents, prompts et instructions préconstruits font gagner du temps et assurent des résultats cohérents.
Bonnes pratiques : bénéficiez de normes et patterns de codage sélectionnés par la communauté.
Assistance spécialisée : accédez à des conseils de niveau expert via des agents personnalisés spécialisés.
Apprentissage continu : restez à jour sur les derniers patterns et pratiques à travers les technologies.

📖 Structure du dépôt

Structure du dépôt Awesome

├── prompts/          # Prompts spécifiques aux tâches (.prompt.md)
├── instructions/     # Normes de codage et bonnes pratiques (.instructions.md)
├── agents/           # Personas IA et modes spécialisés (.agent.md)
├── collections/      # Collections organisées d’éléments liés (.collection.yml)
└── scripts/          # Scripts utilitaires pour la maintenance

🎯 Comment utiliser les ressources « Awesome GitHub Copilot » ?

🤖 Agents personnalisés

Les agents personnalisés peuvent être utilisés dans Copilot Coding Agent (CCA), VS Code et Copilot CLI. Pour le CCA, lors de l’assignation d’un ticket à Copilot, sélectionnez l’agent personnalisé dans la liste fournie. Dans VS Code, vous pouvez activer l’agent personnalisé dans la session des agents, aux côtés des agents intégrés comme Plan et Agent.

🎯 Prompts

Utilisez la commande / dans GitHub Copilot Chat pour accéder aux prompts :

/awesome-copilot create-readme

📋 Instructions

Les instructions s’appliquent automatiquement aux fichiers selon leurs motifs et fournissent des conseils contextuels sur les normes de codage, les frameworks et les bonnes pratiques.

3.3 Custom agents 🤖

Un custom agent est un assistant IA personnalisé dans VS Code qui adopte une personnalité et un comportement spécifiques pour des tâches de développement précises. Par exemple, vous pouvez créer des agents pour :

Un planificateur de projet
Un réviseur de code sécurisé
Un architecte de solutions
Un testeur automatique

Chaque agent possède ses propres instructions, outils disponibles et comportements.

Pourquoi utiliser des Custom Agents ?

Spécialisation des tâches

Différentes tâches nécessitent différentes capacités. Un agent de planification peut n'avoir accès qu'à des outils de lecture pour éviter les modifications accidentelles, tandis qu'un agent d'implémentation aura tous les outils d'édition.

Instructions personnalisées

Chaque agent peut avoir des instructions spécifiques qui définissent comment l'IA doit fonctionner, garantissant des réponses cohérentes et adaptées à chaque fois.

Structure d'un fichier Custom Agent

Les custom agents sont définis dans des fichiers .agent.md (Markdown) avec cette structure :

En-tête (YAML frontmatter)

---
description: Générer un plan d'implémentation pour de nouvelles fonctionnalités
name: Planificateur
tools: ['fetch', 'githubRepo', 'search']
model: Claude Sonnet 4
handoffs:
  - label: Implémenter le plan
    agent: implementation
    prompt: Implémente le plan ci-dessus
    send: false
---

Champs disponibles :

description : Description brève de l'agent
name : Nom de l'agent
tools : Liste des outils disponibles
model : Modèle IA à utiliser
handoffs : Transitions suggérées vers d'autres agents

Corps du fichier

Le corps contient les instructions en Markdown qui guident le comportement de l'agent.

Créer un Custom Agent

Étape 1 : Créer le fichier

Ouvrez la liste des agents dans le Chat
Sélectionnez Configure Custom Agents
Cliquez sur Create new custom agent
Choisissez l'emplacement :
- Workspace : dans .github/agents (uniquement pour ce projet)
- User profile : pour tous vos projets

Étape 2 : Définir l'agent

Remplissez le fichier .agent.md :

---
description: Génère un plan d'implémentation détaillé
name: Plan
tools: ['search', 'fetch', 'githubRepo']
---

# Instructions de planification

Tu es en mode planification. Ta tâche est de générer un plan d'implémentation 
pour une nouvelle fonctionnalité.

Le plan doit inclure :
- Vue d'ensemble
- Exigences
- Étapes d'implémentation
- Tests nécessaires

Ne fais aucune modification de code, génère uniquement un plan.

Les Handoffs : enchaîner les agents

Les handoffs permettent de créer des workflows guidés entre agents avec des boutons de transition.

Exemple de workflow :

Planification → Implémentation : Générer un plan puis coder
Implémentation → Révision : Coder puis vérifier la qualité
Tests échouants → Tests réussis : Écrire les tests puis l'implémentation

handoffs:
  - label: Commencer l'implémentation
    agent: implementation
    prompt: Implémente maintenant le plan ci-dessus.
    send: false

label : Texte du bouton
agent : Agent cible
prompt : Texte à envoyer
send : Envoyer automatiquement (true/false)

Outils disponibles

Vous pouvez spécifier quels outils sont accessibles à chaque agent :

Outils VS Code intégrés : 'search', 'fetch', 'githubRepo'
Outils MCP : tous les outils d'un serveur avec 'nom-serveur/*'
Outils d'extensions

Exemple complet

---
description: Agent de révision de code se concentrant sur la sécurité
name: Réviseur Sécurité
tools: ['search', 'fetch']
model: Claude Sonnet 4
handoffs:
  - label: Corriger les problèmes
    agent: implementation
    prompt: Corrige les problèmes de sécurité identifiés ci-dessus.
---

# Instructions de révision sécurité

Tu es un expert en sécurité applicative. Analyse le code pour :

1. **Vulnérabilités de sécurité**
   - Injections SQL
   - XSS
   - CSRF
   - Fuites de données sensibles

2. **Bonnes pratiques**
   - Validation des entrées
   - Gestion des erreurs
   - Principe du moindre privilège

Pour chaque problème trouvé, fournis :
- Description claire
- Niveau de gravité
- Suggestion de correction

Partager les Custom Agents

Au niveau de l'équipe

Placez les fichiers dans .github/agents de votre workspace.

Au niveau de l'organisation

Les agents peuvent être définis au niveau GitHub Organization pour être disponibles dans tous les projets. Activez l'option dans les paramètres :

github.copilot.chat.customAgents.showOrganizationAndEnterpriseAgents

Conseils pratiques

Commencez simple : Créez d'abord des agents avec des rôles clairs
Limitez les outils : Donnez uniquement les outils nécessaires à chaque agent
Instructions précises : Plus les instructions sont claires, meilleurs sont les résultats
Utilisez les handoffs : Créez des workflows fluides entre agents
Testez et itérez : Affinez vos agents au fil de l'utilisation

3.4 Maîtriser le GitHub Copilot CLI 🚀

La GitHub Copilot CLI apporte les capacités IA de Copilot directement dans votre ligne de commande.

Plutôt que de jongler entre votre IDE et votre navigateur, vous pouvez faire appel à Copilot directement dans votre terminal pour les cas d'usage suivants :

Assistant IA dans le terminal, indépendant de l’éditeur
Exploration du projet (fichiers, dépendances, structure)
Génération et modification de code via des prompts en langage naturel
Exécution de commandes shell suggérées (avec confirmation)
Refactoring et automatisation de workflows multi-étapes

Vous pouvez utiliser Copilot CLI de deux manières :

Mode interactif (mode par défaut) : démarrez une session avec la commande copilot et conversez en aller‑retour, en affinant les tâches au fil de l’eau.
Mode programmatique : pour des prompts ponctuels. Passez une requête directement avec -p ou --prompt, et Copilot répond en ligne. Pour les tâches impliquant la modification ou l’exécution de fichiers, vous pouvez activer les options d’approbation pour garder les choses sûres et cohérentes.

Par exemple, vous pouvez demander :

copilot "create a bash script to check for uncommitted changes and push if clean"

ou bien en mode programmatique :

copilot -p "create a bash script to check for uncommitted changes and push if clean"

Copilot CLI écrira le script, expliquera ce qu’il fait, et vous demandera de confirmer avant de l’exécuter.

Copilot CLI demandera par défaut toujours une confirmation avant de lire, modifier ou exécuter des fichiers. Vous gardez ainsi donc le contrôle de votre environnement. (Note : Exception si vous choisissez « Yes, and remember this folder for future sessions » ou « Yes, and approve TOOL for the rest of the session » lorsque c’est demandé—Copilot suivra alors ces instructions au lieu de vous reposer la question. Plus de détails dans notre kit de démarrage ci‑dessous !)

Vous pouvez sélectionner l’une de ces options :

Yes, proceed : Copilot peut accéder et utiliser les fichiers de cet emplacement uniquement pour cette session.
Yes, and remember this folder for future sessions : les fichiers de ce dossier sont approuvés pour les sessions en cours et futures. En démarrant Copilot CLI depuis ce dossier, cette question ne vous sera plus posée (ne choisissez cette option que si vous êtes sûr qu’il sera toujours sans risque pour Copilot de travailler avec ces fichiers).
No, exit (Esc) : mettre fin à votre session Copilot CLI.

Cas d’usage de GitHub Copilot CLI, refactoring et automatisation de workflows multi-étapes avec un agent

L’option --allow-all-tools dans GitHub Copilot CLI permet d'autoriser Copilot à utiliser automatiquement tous les outils disponibles sur votre système, sans vous demander confirmation à chaque fois.

Exemple :

copilot --allow-all-tools -p "create a bash script to check for uncommitted changes and push if clean"

Partie IV : Qualité, sécurité et rôle humain (Les pièges à éviter)

Cette section est dédiée à la responsabilité du développeur et aux erreurs critiques à éviter ⚠️.

4.1 Prendre les suggestions de Copilot pour des vérités 🤖

L’erreur : Beaucoup de développeurs acceptent les suggestions de Copilot sans double vérification ✅❌.
Pourquoi c’est un problème : Le code généré par IA peut sembler correct mais contenir des bugs subtils 🐛, des problèmes de performance ⚡ ou des patterns obsolètes 📉.
Correctif : Traitez la sortie de Copilot comme des extraits Stack Overflow : relisez, testez et refactorisez avant de committer ✍️. Demandez-vous toujours : « Est-ce que j’écrirais ceci si Copilot ne me l’avait pas suggéré ? »

4.2 Ignorer la sécurité du code 🔒

L’erreur : Copilot peut générer du code non sécurisé (ex. requêtes SQL sans paramétrage, regex dangereuses, gestion faible des mots de passe).
Pourquoi c’est un problème : L’IA ne priorise pas intrinsèquement les bonnes pratiques de sécurité 🚨. Copier-coller aveuglément peut conduire à des vulnérabilités.
Correctif : Appliquez les pratiques de codage sécurisé : validez les entrées ✅, échappez les requêtes 🛡️, nettoyez les sorties ✨. Lancez une analyse statique (ex. SonarQube, plugins de sécurité ESLint) sur le code généré par Copilot.

4.3 Utiliser Copilot comme béquille pour les fondamentaux 🏗️

L’erreur : S’appuyer sur Copilot au lieu de comprendre le langage ou le framework sous-jacent 📚.
Pourquoi c’est un problème : Si vous ne savez pas pourquoi le code fonctionne, vous aurez du mal à le déboguer 🔍 ou l’étendre plus tard.
Correctif : Utilisez Copilot comme assistant d’apprentissage 🎓, pas comme substitut. Après avoir accepté une suggestion, faites une pause et expliquez-la (à vous-même ou en commentaire) avant de continuer.

4.4 Surcompliquer des solutions simples ✂️

L’erreur : Copilot génère parfois des solutions verbeuses pour des problèmes qui pourraient être résolus en une ligne 📝.
Pourquoi c’est un problème : La sur-ingénierie alourdit votre codebase ⚖️ et rend la maintenance plus difficile.
Correctif : Gardez le jugement du développeur dans la boucle 👨‍💻. Si la suggestion semble trop longue, demandez-vous s’il existe une solution plus élégante. Less is more.

4.5 Ne pas fournir de contexte pour de meilleures suggestions 🗂️

L’erreur : Écrire des noms de fonctions ou des commentaires vagues, puis s’attendre à ce que Copilot « sache » ce que vous voulez.
Pourquoi c’est un problème : L’IA se nourrit de contexte. Sans contexte, les suggestions peuvent être hors sujet ou déroutantes ❓.
Correctif : Rédigez des signatures de fonctions, commentaires et docstrings clairs ✏️. Exemple : au lieu de function processData(), utilisez function normalizeUserInput(userData: string[]): string[].

4.6 Ne pas garder Copilot dans le bon scope 🎯

L’erreur : Utiliser Copilot dans de grands fichiers encombrés sans contexte guide 🗃️.
Pourquoi c’est un problème : Copilot puise le contexte dans le code proche. Si votre fichier est chaotique, les suggestions deviennent moins précises ⚠️.
Correctif : Refactorez en modules plus petits et ciblés 🧩. Plus votre code est propre, plus Copilot devient pertinent.

4.7 Zapper les tests parce que « Copilot l’a écrit » 🧪

L’erreur : Supposer que la sortie de Copilot n’a pas besoin d’être testée en profondeur.
Pourquoi c’est un problème : Les suggestions de l’IA peuvent introduire des cas limites que vous n’aviez pas anticipés 🚫.
Correctif : Écrivez des tests unitaires, des tests d’intégration et des vérifications de cas limites pour tout code généré par Copilot. Bonus : Utilisez Copilot lui-même pour rédiger des cas de test — puis affinez-les manuellement 🛠️.

Conclusion : Codez plus intelligemment, pas seulement plus vite

GitHub Copilot n’est plus une autocomplétion ✨ : c’est un partenaire de développement capable d’orchestrer des tâches, d’analyser votre codebase et de s’intégrer à vos outils.

En combinant les fondamentaux (IDE vs CLI), les leviers de précision (slash commands, contexte, instructions, sélection) et l'agentique avancée (mode Agent 🤖, MCP 🧩, agents personnalisés 🛠️), vous passez de « coder plus vite » à « livrer mieux, avec maîtrise ».

La clé reste humaine 🧠 : cadrer le besoin, donner le bon contexte, et garder un œil critique sur la qualité, la sécurité et les tests.

En 2026, la différence viendra de ceux qui standardisent, automatisent et mesurent.

Plan d’actions immédiates

.instructions.md : formalisez vos normes d’équipe pour des sorties cohérentes.
/tests et /fix : sécurisez la qualité dès le flux quotidien.
Commentaire‑d’abord : décrivez architecture et cas limites avant de coder.
Contexte ciblé : ouvrez 3–5 fichiers pertinents, fermez le reste.
Copilot CLI : installez‑le et utilisez‑le pour scripts, issues et PR.
1 agent personnalisé : « Réviseur Sécurité » ou « Planificateur » + un handoff simple.

Cap sur 2026 : standardisez, automatisez, mesurez. Faites de Copilot votre accélérateur — et de vos pratiques, votre avantage.

Explorez plus de contenus sur GitHub et Copilot

Tout ce dont vous avez besoin pour maîtriser GitHub Copilot :

Documentation officielle

VS Code et Copilot

Ressources complémentaires

Hibernate : l’art du tuning qui transforme une application Java lente en application ultra-performante

Patrice Eon — Mon, 01 Dec 2025 19:11:39 +0000

Optimiser l’accès à la base de données, c’est un peu le nerf de la guerre pour toute appli Java qui vise la haute performance.

Et ça tombe bien : Hibernate est là pour nous simplifier la vie. Ce framework ORM évite de plonger les mains dans le SQL brut… mais attention : mal utilisé, il peut aussi plomber les performances !

Dans cet article, je vous embarque dans les coulisses de l’optimisation Hibernate avec un guide complet, concret et efficace.... Enfin je l'espère 😃.

Mon objectif est de faire de vous un expert en performance hibernate. Ne perdons pas de temps allons-y !

Table des matières

Qu’est-ce que Hibernate et quel est son rôle dans les applications Java ?
Quels sont les optimisations essentielles de la configuration Hibernate ?
Qu’elle est l’importance d’un mapping efficace des entités pour la performance ?
Qu’est-ce que le Lazy & Eager Loading dans Hibernate ?
Pourquoi la mise en cache est-elle cruciale avec Hibernate ?
Qu’est-ce que HQL et Criteria API ?
Pourquoi le traitement par lots est-il important pour la performance ?
Quelle est l’importance d’une gestion efficace des connexions à la base de données ?
Quelle est l’importance du profilage et du monitoring pour le tuning de performance ?
Qu’est-ce que les Interceptors et Event Listeners Hibernate ?
Conclusion

1 - Qu’est-ce que Hibernate et quel est son rôle dans les applications Java ?

Hibernate est un framework open source qui fournit une solution complète pour la persistance des données dans des bases relationnelles.

Concrètement ses apports principaux sont :

Persistence transparente : Hibernate gère de manière transparente le mapping des classes vers les tables, permettant aux développeurs d’effectuer des opérations CRUD sans écrire de SQL.
HQL (Hibernate Query Language) : Un langage de requête puissant qui permet d’interroger la base de données en utilisant une syntaxe orientée objet.
Caching : Support intégré pour le cache de premier et de second niveau afin d’améliorer les performances.
Lazy Loading : Chargement des données liées à la demande, réduisant ainsi les requêtes inutiles et améliorant l’efficacité.
Génération automatique des tables : Hibernate peut générer automatiquement les tables de la base de données en fonction des mappings d’entités.

Dans la suite de cet article, nous allons explorer comment tirer le meilleur parti de ces différents apports en termes de performances.

2 - Quels sont les optimisations essentielles de la configuration Hibernate ?

Hibernate se configure a travers le fichier hibernate.cfg.xml de votre application java.

Voici quelques conseils pour régler les paramètres clés :

Pooling de connexions:

Minimiser les connexions inactives : Définir le nombre minimum de connexions inactives à une valeur basse pour réduire l’utilisation des ressources.
Maximiser les connexions actives : S’assurer que le nombre maximum de connexions actives est suffisant pour gérer les charges de pointe sans provoquer de contention.
Période de test des connexions inactives : Définir une période de test appropriée pour valider périodiquement les connexions et fermer celles qui ne sont pas utilisées.

Mise en cache:

Utiliser le second niveau de cache avec parcimonie : Activer le cache de second niveau uniquement pour les entités majoritairement en lecture pour réduire la fréquence des accès à la base de données.
Choisir le bon fournisseur de cache : Sélectionner un fournisseur de cache adapté aux exigences de performance et de scalabilité de l’application, comme EhCache ou Infinispan.

Stratégies de fetch:

Batch Fetching : Configurer le batch fetching pour les collections et les associations afin de réduire le nombre de requêtes SQL exécutées par Hibernate.
Utiliser le Lazy Loading : Préférer le lazy loading pour les associations afin de ne récupérer que les données nécessaires, réduisant ainsi le chargement de données inutiles.

Affichage SQL:

Désactiver en production : Désactiver l’enregistrement SQL dans les environnements de production pour éviter une surcharge de performance et des journaux encombrés.

Dialecte:

Correspondre à la version de la base de données : S’assurer que le dialecte correspond à la version spécifique de la base de données pour tirer parti d’une génération SQL optimisée.

📌 Voici un exemple de configuration dans hibernate.cfg.xml qui intègre les bonnes pratiques mentionnées ci-dessus

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
  <session-factory>
    <!-- Paramètres de connexion -->
    <property name="hibernate.connection.driver_class">com.ibm.as400.access.AS400JDBCDriver</property>
    <property name="hibernate.connection.url">jdbc:as400://u3reca42.recgroupement.systeme-u.fr/cobalt</property>
    <property name="hibernate.connection.username">user</property>
    <property name="hibernate.connection.password">password</property>
    <!-- Dialecte -->
    <property name="hibernate.dialect">org.hibernate.dialect.DB2400Dialect</property>
    <!-- Pool de connexions (c3p0) -->
    <property name="hibernate.c3p0.min_size">5</property>
    <property name="hibernate.c3p0.max_size">20</property>
    <property name="hibernate.c3p0.timeout">300</property>
    <property name="hibernate.c3p0.max_statements">50</property>
    <property name="hibernate.c3p0.idle_test_period">3000</property>
    <!-- Cache second niveau -->
    <property name="hibernate.cache.use_second_level_cache">true</property>
    <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
    <!-- SQL -->
    <property name="hibernate.show_sql">false</property>
    <!-- Fetch -->
    <property name="hibernate.default_batch_fetch_size">16</property>
    <!-- Transactions -->
    <property name="hibernate.transaction.factory_class">org.hibernate.transaction.JTATransactionFactory</property>
    <property name="hibernate.transaction.manager_lookup_class">org.hibernate.transaction.JBossTransactionManagerLookup</property>
    <!-- Entités annotées -->
    <mapping class="com.example.YourEntityClass"/>
  </session-factory>
</hibernate-configuration>

3 - Qu’elle est l’importance d’un mapping efficace des entités pour la performance ?

Une fois hibernate bien configurer, il est important de prévoir le bon mapping dans application java, entre vos données en base et votre code java.

Celui-ci va permettre :

De réduite la charge sur la base de données : Un mapping efficace minimise le nombre de requêtes et optimise le SQL généré par Hibernate.
Des requêtes améliorée : Des entités bien mappées permettent à Hibernate d’exécuter les requêtes plus efficacement, réduisant le temps nécessaire pour récupérer et mettre à jour les données. Cela est particulièrement important pour les requêtes complexes et les grands ensembles de données.
Une utilisation améliorée des ressources : Des mappings efficaces garantissent une meilleure utilisation des ressources système telles que la mémoire et le CPU, prévenant les goulots d’étranglement et améliorant la scalabilité.
Une cohérence et intégrité : Un mapping approprié aide à maintenir la cohérence et l’intégrité des données, réduisant ainsi la probabilité d’erreurs et de corruption des données.

📌 Concrètement comment mettre en œuvre un bon mapping sur les entités aux tables de la base de données ?

Utiliser les annotations appropriées:

@Entity : Marque une classe comme une entité, qui sera mappée à une table de base de données.
@Table : Spécifie le nom de la table s’il diffère du nom de l’entité.
@id : Identifie la clé primaire de l’entité.
@GeneratedValue : Définit la stratégie de génération de la clé primaire.
@column : Personnalise le mapping entre les champs de l’entité et les colonnes de la base de données.

Définir explicitement les relations:

@OneToOne : Mappe une relation un-à-un.
@OneToMany : Mappe une relation un-à-plusieurs.
@ManyToOne : Mappe une relation plusieurs-à-un.
@ManyToMany : Mappe une relation plusieurs-à-plusieurs.
@JoinColumn : Spécifie la colonne de clé étrangère dans une relation.

Optimiser les stratégies de fetch:

Lazy Loading : Utiliser le lazy loading pour ne charger les entités liées que lorsque cela est nécessaire, réduisant ainsi les requêtes inutiles à la base de données.
Eager Loading : Utiliser l’eager loading pour les relations toujours accédées ensemble afin d’optimiser les performances.

Indexer les colonnes fréquemment interrogées:

@Index : Utiliser des index sur les colonnes fréquemment interrogées pour accélérer les opérations de recherche.

Utiliser le batch fetching:

Configurer le batch fetching pour réduire le nombre de requêtes SQL exécutées par Hibernate pour les collections et les associations.

Exemple de mapping d’entité optimisé avec des annotations

Considérons un exemple simple de mapping optimisé pour une relation User et Order dans une application de commerce électronique.

Entité User:

import javax.persistence.*;
import java.util.Set;

@Entity
@Table(name = "users")
public class User {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "user_id")
  private Long id;

  @Column(name = "username", nullable = false, unique = true)
  private String username;

  @Column(name = "email", nullable = false, unique = true)
  private String email;

  @OneToMany(mappedBy = "user", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
  private Set<Order> orders;
}

Entité Order:

import javax.persistence.*;
import java.util.Date;

@Entity
@Table(name = "orders")
public class Order {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "order_id")
  private Long id;

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "user_id", nullable = false)
  private User user;

  @Column(name = "order_date", nullable = false)
  @Temporal(TemporalType.DATE)
  private Date orderDate;

  @Column(name = "total_amount", nullable = false)
  private Double totalAmount;
}

Explication de l’exemple:

Annotations Entity & Table : Les classes User et Order sont marquées avec l’annotation @Entity, et l’annotation @Table spécifie les noms de table correspondants.
Génération de clé primaire : Les annotations @id et @GeneratedValue définissent la clé primaire et sa stratégie de génération.
Mappings de colonnes : L’annotation @column personnalise le mapping entre les champs de l’entité et les colonnes de la base de données, y compris les contraintes telles que nullable et unique.
Relations : Les annotations @OneToMany et @ManyToOne définissent les relations entre User et Order. Le paramètre fetch = FetchType.LAZY dans l’annotation @OneToMany garantit que les entités liées ne sont chargées que lorsqu’elles sont accédées, optimisant ainsi les performances.
Opérations en cascade : Le paramètre cascade = CascadeType.ALL dans l’annotation @OneToMany garantit que toutes les entités Order liées sont automatiquement persistées lorsque l’entité User est persistée.

4- Qu’est-ce que le Lazy & Eager Loading dans Hibernate ?

Le lazy et eager loading sont deux notions clés dans Hibernate qui déterminent quand et comment les données associées sont récupérées depuis la base de données. Comprendre ces stratégies est essentiel pour optimiser les performances de vos applications.

Dans cette section, je vais :

Expliquer le lazy et l’eager loading
Comparer leurs avantages et inconvénients
Donner des bonnes pratiques pour choisir la stratégie adaptée
Montrer un exemple concret de configuration

📌 Qu’est-ce que le Lazy Loading ?

Le lazy loading charge une entité ou une collection uniquement lorsqu’elle est utilisée pour la première fois. Autrement dit, les données associées ne sont récupérées qu’à la demande, ce qui réduit le nombre de requêtes et la quantité de données chargées, améliorant ainsi les performances.

@Entity
public class User {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)
  private Set<Order> orders;
}

Dans cet exemple, la collection orders de l’entité User est marquée avec fetch = FetchType.LAZY, ce qui signifie que les commandes ne seront chargées que lorsque la méthode getOrders() sera appelée.

📌 Qu’est-ce que l’Eager Loading ?

L’eager loading charge toutes les données liées dès le départ, en même temps que l’entité principale — même si vous n’en avez pas besoin tout de suite. C’est pratique pour avoir toutes les infos sous la main, mais cela peut ralentir l’application si les données sont nombreuses.

@Entity
public class User {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @OneToMany(mappedBy = "user", fetch = FetchType.EAGER)
  private Set<Order> orders;
}

Dans cet exemple, la collection orders de l’entité User est marquée avec fetch = FetchType.EAGER, ce qui signifie que les commandes seront chargées dès que l’entité User sera récupérée.

📌 Evaluation des avantages et les inconvénients de chaque stratégie de chargement ?

Lazy Loading:

Avantages:

Amélioration des performances de chargement initial : Réduit le temps de chargement initial en ne récupérant que les données nécessaires.
Réduction de l’utilisation de la mémoire : Charge les données liées uniquement lorsque cela est nécessaire, économisant ainsi de la mémoire.
Meilleure scalabilité : Améliore la scalabilité en minimisant la quantité de données transférées et traitées initialement.

Inconvénients:

Problème N+1 : Peut entraîner l’exécution de plusieurs requêtes si les collections chargées paresseusement sont accédées dans une boucle.
Complexité : Nécessite une gestion soigneuse pour éviter des exceptions inattendues d’initialisation paresseuse.

Eager Loading:

Avantages:

Simplicité : Récupère toutes les données liées en une seule requête, simplifiant l’accès aux données.
Évite le problème N+1 : Garantit que toutes les données requises sont chargées en une seule fois, évitant ainsi plusieurs requêtes à la base de données.

Inconvénients:

Augmentation du temps de chargement initial : Peut augmenter le temps de chargement initial en récupérant toutes les données liées à l’avance, même si elles ne sont pas nécessaires immédiatement.
Utilisation plus élevée de la mémoire : Charge toutes les données liées en mémoire, ce qui peut être inefficace si les données ne sont pas accédées.

📌 Comment choisir la stratégie de chargement appropriée ?

Analyser les patterns d’accès : Comprendre comment et quand les données liées sont accédées dans votre application. Utilisez le lazy loading pour les données rarement accédées et l’eager loading pour les données fréquemment utilisées.
Éviter le problème N+1 : Lors de l’utilisation du lazy loading, soyez conscient du problème N+1 et utilisez le batch fetching ou le join fetching pour optimiser les performances.
Tester et surveiller : Testez et surveillez régulièrement les performances de votre application pour identifier l’impact des stratégies de chargement et apporter des ajustements si nécessaire.
Utiliser des fetch profiles : Hibernate permet de définir des profils de fetch pour ajuster dynamiquement les stratégies de chargement en fonction de cas d’utilisation spécifiques, offrant ainsi une flexibilité dans le chargement des données liées.

5 - Pourquoi la mise en cache est-elle cruciale avec Hibernate ?

La mise en cache joue un rôle majeur dans Hibernate dans cette section, on va voir :

Pourquoi la mise en cache est extrêmement importante,
La différence entre le cache de premier niveau et le cache de second niveau,
Comment les configurer efficacement,
Et un exemple concret avec EhCache pour le cache de second niveau.

📌 Pourquoi la mise en cache est-elle importante dans Hibernate pour la performance ?

Accès réduit à la base de données : La mise en cache stocke les données fréquemment accédées en mémoire, réduisant ainsi le besoin de requêtes répétées à la base de données. Cela minimise la charge sur la base de données et accélère la récupération des données.
Amélioration des performances de l’application : En servant les données à partir du cache, les applications peuvent répondre plus rapidement aux requêtes des utilisateurs, ce qui améliore les performances et l’expérience utilisateur.
Scalabilité améliorée : La mise en cache aide les applications à gérer des charges plus élevées en déchargeant le travail de la base de données vers le cache, facilitant ainsi la scalabilité de l’application.
Efficacité économique : La réduction du nombre de requêtes à la base de données peut diminuer les coûts opérationnels associés à l’utilisation de la base de données, tels que les coûts de licence et d’infrastructure.

📌 Quelles sont les différences entre le cache de premier et de second niveau ?

Cache de premier niveau (Session):

Portée : Associé à l’objet Session d’Hibernate. Activé par défaut et existe uniquement pendant la durée de la session.
Cycle de vie : Le cache est vidé lorsque la session est fermée, ce qui signifie que les entités mises en cache ne sont disponibles que dans la même session.
Granularité : Transactionnel, c’est-à-dire qu’il met en cache des objets par session.
Mise en œuvre : Aucune configuration supplémentaire n’est requise car elle est intégrée à Hibernate.

Cache de second niveau (SessionFactory):

Portée : Associé à l’objet SessionFactory d’Hibernate. Peut mettre en cache des entités entre plusieurs sessions.
Cycle de vie : Le cache persiste au-delà des sessions individuelles, permettant le partage des entités mises en cache à travers l’application.
Granularité: Peut mettre en cache des entités, des collections et des résultats de requêtes.
Mise en œuvre : Nécessite une configuration supplémentaire et un fournisseur de cache externe (par exemple, EhCache, Hazelcast, Infinispan).

📌Comment configurer et utiliser efficacement la mise en cache ?

Configuration du cache de premier niveau:

Le cache de premier niveau est activé par défaut dans Hibernate, sans aucune configuration. Il met automatiquement en cache les entités au niveau de la session, ce qui permet d’éviter des requêtes répétées pendant celle-ci.

Configuration du cache de second niveau:

Activer le cache de second niveau :

Dans le fichier hibernate.cfg.xml ou fichier de configuration équivalent, activer le cache de second niveau.

<property name="hibernate.cache.use_second_level_cache">true</property>
<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

Configurer le fournisseur de cache :

Choisir un fournisseur de cache comme EhCache et le configurer dans le hibernate.cfg.xml.

<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

Configurer les régions de cache :

Définir les régions de cache dans le fichier de configuration du fournisseur de cache (par exemple, ehcache.xml pour EhCache).

<ehcache>
  <cache name="com.example.entity.User" maxEntriesLocalHeap="1000" timeToLiveSeconds="3600"/>
  <cache name="com.example.entity.Order" maxEntriesLocalHeap="1000" timeToLiveSeconds="3600"/>
</ehcache>

Annoter les entités pour la mise en cache :

Utiliser les annotations Hibernate pour spécifier quelles entités doivent être mises en cache.

@Entity
@Cacheable
@org.hibernate.annotations.Cache(usage = org.hibernate.annotations.CacheConcurrencyStrategy.READ_WRITE, region = "com.example.entity.User")
public class User {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
}

Exemple de configuration d’EhCache pour le cache de second niveau

Étape 1: Ajouter les dépendances

S’assurer que vous avez les dépendances nécessaires pour EhCache dans votre fichier pom.xml (pour Maven) ou build.gradle (pour Gradle).

<dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-core</artifactId>
  <version>5.4.0.Final</version>
</dependency>
<dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-ehcache</artifactId>
  <version>5.4.0.Final</version>
</dependency>
<dependency>
  <groupId>net.sf.ehcache</groupId>
  <artifactId>ehcache</artifactId>
  <version>2.10.6</version>
</dependency>

Étape 2: Configurer Hibernate pour utiliser EhCache

Dans le fichier hibernate.cfg.xml, activer le cache de second niveau et spécifier EhCache comme fournisseur de cache.

<hibernate-configuration>
  <session-factory>
    <property name="hibernate.cache.use_second_level_cache">true</property>
    <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
  </session-factory>
</hibernate-configuration>

Étape 3: Créer le fichier de configuration d’EhCache

Créer un fichier ehcache.xml dans le classpath et définir les régions de cache pour vos entités.

<ehcache>
  <defaultCache maxEntriesLocalHeap="1000" eternal="false" timeToLiveSeconds="120" timeToIdleSeconds="120" overflowToDisk="false"/>
  <cache name="com.example.entity.User" maxEntriesLocalHeap="1000" timeToLiveSeconds="3600"/>
  <cache name="com.example.entity.Order" maxEntriesLocalHeap="1000" timeToLiveSeconds="3600"/>
</ehcache>

Étape 4: Annoter les entités pour la mise en cache

Annoter les entités que vous souhaitez mettre en cache avec @Cacheable et spécifier la région de cache.

@Entity
@Cacheable
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE, region = "com.example.entity.User")
public class User {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
}

@Entity
@Cacheable
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE, region = "com.example.entity.Order")
public class Order {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "user_id")
  private User user;
}

6 - Qu’est-ce que HQL et Criteria API ?

Hibernate propose deux façons principales de créer des requêtes : HQL (Hibernate Query Language) et Criteria API.

Dans cette section, nous verrons :

comment utiliser HQL et Criteria API,
les bonnes pratiques pour écrire des requêtes efficaces,
et des exemples concrets de requêtes optimisées avec les deux méthodes.

📌 Qu’est-ce que HQL (Hibernate Query Language) ?

HQL est un langage de requête orienté objet, proche du SQL, mais qui travaille sur les entités Java plutôt que directement sur les tables. Hibernate traduit vos requêtes HQL en SQL, vous permettant de profiter pleinement des avantages de l’ORM.

Caractéristiques de HQL:

Orienté objet : Opère sur des objets et leurs propriétés.
Indépendant de la base de données : Abstrait le SQL sous-jacent, rendant l’application plus portable.
Supporte le polymorphisme : Permet des requêtes sur des classes et leurs sous-classes.

📌 Qu’est-ce que Criteria API ?

La Criteria API permet de créer des requêtes de façon programmatique et sécurisée. Elle offre une approche orientée objet, idéale pour les requêtes dynamiques dont la structure peut changer selon certaines conditions.

Caractéristiques de Criteria API :

Type-safe : Assure que les requêtes sont vérifiées pour leur exactitude au moment de la compilation.
Création dynamique de requêtes : Facilite la création de requêtes de manière dynamique, basée sur l’entrée de l’utilisateur ou la logique de l’application.
Approche programmatique : Fournit une API pour construire des requêtes de manière programmatique.

📌 Comment écrire des requêtes efficaces avec HQL et Criteria API ?

Sélectionner uniquement les colonnes requises : Éviter d’utiliser SELECT *. Spécifier uniquement les colonnes nécessaires.

SELECT u.username, u.email FROM User u

Utiliser des fetch joins : Utiliser des fetch joins pour optimiser le chargement des entités liées.

SELECT u FROM User u JOIN FETCH u.orders WHERE u.id = :userId

Pagination : Implémenter la pagination pour les requêtes renvoyant de grands ensembles de résultats.

Query query = session.createQuery("FROM User");
query.setFirstResult(0);
query.setMaxResults(10);

Éviter le problème N+1 : Utiliser JOIN FETCH ou le batch fetching pour éviter le problème N+1.

SELECT u FROM User u JOIN FETCH u.orders

Indexation : S’assurer que les tables de la base de données sont correctement indexées pour les colonnes utilisées dans la clause WHERE.
Mises à jour par lots : Utiliser des mises à jour par lots pour gérer efficacement de grands volumes de données.

Exemples de requêtes optimisées utilisant HQL

Requête de base :

String hql = "FROM User WHERE email = :email";
Query query = session.createQuery(hql);
query.setParameter("email", "example@example.com");
List results = query.list();

Exemple de fetch join :

String hql = "SELECT u FROM User u JOIN FETCH u.orders WHERE u.id = :userId";
Query query = session.createQuery(hql);
query.setParameter("userId", 1L);
User user = (User) query.uniqueResult();

Exemple de pagination :

String hql = "FROM User";
Query query = session.createQuery(hql);
query.setFirstResult(0);
query.setMaxResults(10);
List results = query.list();

Exemples de requêtes optimisées utilisant Criteria API

Requête de base :

Session session = sessionFactory.openSession();
CriteriaBuilder cb = session.getCriteriaBuilder();
CriteriaQuery<User> cq = cb.createQuery(User.class);
Root<User> root = cq.from(User.class);
cq.select(root).where(cb.equal(root.get("email"), "example@example.com"));
Query<User> query = session.createQuery(cq);
List<User> results = query.getResultList();
session.close();

Exemple de fetch join :

Session session = sessionFactory.openSession();
CriteriaBuilder cb = session.getCriteriaBuilder();
CriteriaQuery<User> cq = cb.createQuery(User.class);
Root<User> root = cq.from(User.class);
root.fetch("orders", JoinType.LEFT);
cq.select(root).where(cb.equal(root.get("id"), 1L));
Query<User> query = session.createQuery(cq);
User user = query.getSingleResult();
session.close();

Exemple de pagination :

Session session = sessionFactory.openSession();
CriteriaBuilder cb = session.getCriteriaBuilder();
CriteriaQuery<User> cq = cb.createQuery(User.class);
Root<User> root = cq.from(User.class);
cq.select(root);
Query<User> query = session.createQuery(cq);
query.setFirstResult(0);
query.setMaxResults(10);
List<User> results = query.getResultList();
session.close();

7 - Pourquoi le traitement par lots est-il important pour la performance ?

Hibernate permet de traiter les insertions, mises à jour et suppressions par lots.

Dans cette section, nous verrons :

Pourquoi le traitement par lots est important pour les performances,
Comment configurer Hibernate pour le supporter,
Et des exemples concrets d’opérations par lots.

📌 Pourquoi le traitement par lots est-il important pour la performance ?

Réduction des allers-retours à la base de données : Le traitement par lots minimise le nombre d’allers-retours à la base de données en regroupant plusieurs opérations dans une seule transaction. Cela réduit le coût associé à chaque appel à la base de données et améliore les performances globales.
Amélioration du débit : En traitant plusieurs enregistrements dans un seul lot, le débit des opérations de base de données est considérablement augmenté, ce qui entraîne un traitement des données plus rapide.
Utilisation efficace des ressources : Le traitement par lots optimise l’utilisation des ressources de la base de données et du réseau, conduisant à de meilleures performances et à une charge réduite sur le serveur de base de données.
Gestion des transactions : Regrouper les opérations dans une seule transaction garantit la cohérence et l’intégrité des données, facilitant la gestion et le rollback des modifications si nécessaire.

📌 Comment configurer Hibernate pour le traitement par lots ?

Pour activer le traitement par lots dans Hibernate, vous devez configurer la taille du lot dans le fichier hibernate.cfg.xml ou fichier de configuration équivalent.

<hibernate-configuration>
  <session-factory>
    <!-- Autres configurations -->
    <!-- Configurer la taille du lot -->
    <property name="hibernate.jdbc.batch_size">50</property>
  </session-factory>
</hibernate-configuration>

Optimisation du traitement par lots

Taille du lot : Choisir une taille de lot optimale qui équilibre performances et utilisation des ressources. Une taille de lot trop petite peut ne pas offrir d’avantages significatifs en termes de performances, tandis qu’une taille trop grande peut submerger la base de données.
Mise en lot JDBC : S’assurer que le pilote JDBC prend en charge la mise en lot et est correctement configuré pour gérer les opérations par lots.
Flush & Clear : Vider et effacer périodiquement la session Hibernate pour éviter les problèmes de mémoire et garantir que les modifications sont persistées dans la base de données.

Exemples d’opérations d’insertion, de mise à jour et de suppression par lots

L’insertion par lots consiste à enregistrer des entités par groupes plutôt qu’une par une.

Session session = sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
int batchSize = 50;
for (int i = 0; i < users.size(); i++) {
  session.save(users.get(i));
  if (i % batchSize == 0) {
    session.flush();
    session.clear();
  }
}
transaction.commit();
session.close();

Mise à jour par lots

La mise à jour par lots consiste à modifier plusieurs entités dans un seul lot.

Session session = sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Query<User> query = session.createQuery("FROM User", User.class);
List<User> users = query.getResultList();
for (int i = 0; i < users.size(); i++) {
  User user = users.get(i);
  user.setEmail(user.getUsername() + "@newdomain.com");
  session.update(user);
  if (i % 50 == 0) {
    session.flush();
    session.clear();
  }
}
transaction.commit();
session.close();

Suppression par lots

La suppression par lots consiste à supprimer plusieurs entités dans un seul lot.

Session session = sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Query<User> query = session.createQuery("FROM User WHERE username LIKE 'User%'", User.class);
List<User> users = query.getResultList();
for (int i = 0; i < users.size(); i++) {
  User user = users.get(i);
  session.delete(user);
  if (i % 50 == 0) {
    session.flush();
    session.clear();
  }
}
transaction.commit();
session.close();

8 - Quelle est l’importance d’une gestion efficace des connexions à la base de données ?

Une gestion efficace des connexions est cruciale pour que les applications Hibernate restent rapides et scalables.

Dans cette section, nous verrons :

Pourquoi gérer correctement les connexions est important,
Les bonnes pratiques pour configurer le pooling de connexions,
Et un exemple concret avec HikariCP.

📌 Pourquoi une gestion efficace des connexions à la base de données est-elle importante ?

Utilisation des ressources : Une gestion efficace des connexions garantit une utilisation optimale des ressources de la base de données. En réutilisant les connexions existantes au lieu d’en ouvrir de nouvelles, les applications peuvent réduire le coût associé à l’établissement et à la fermeture des connexions.
Amélioration des performances : Des connexions correctement gérées minimisent le temps d’attente pour des connexions disponibles, réduisant ainsi la latence et améliorant les temps de réponse pour les opérations de base de données.
Scalabilité : Un pooling de connexions efficace permet aux applications de gérer un plus grand nombre d’utilisateurs et de transactions simultanés, améliorant ainsi la scalabilité.
Stabilité et fiabilité : Des pools de connexions bien configurés préviennent l’épuisement des ressources et garantissent que la base de données reste réactive sous des charges élevées, conduisant à des applications plus stables et fiables.

📌 Comment configurer efficacement le pooling de connexions ?

Choisir la bonne taille de pool : La taille du pool doit être suffisamment grande pour gérer les charges de pointe, mais pas trop grande pour submerger le serveur de base de données. Un point de départ typique est de définir la taille du pool sur le nombre de cœurs CPU disponibles multiplié par 2.
Surveiller et ajuster les paramètres du pool : Surveiller régulièrement les métriques du pool de connexions telles que la taille du pool, les temps d’attente et l’utilisation des connexions pour ajuster les paramètres afin d’optimiser les performances.
Définir un délai d’expiration des connexions : Configurer un délai d’expiration raisonnable pour éviter les longues attentes pour des connexions indisponibles, ce qui peut dégrader les performances de l’application.
Tester les connexions : S’assurer que les connexions sont testées avant d’être attribuées à partir du pool. Cela aide à détecter et à gérer les connexions obsolètes ou invalides.
Gérer les connexions inactives : Configurer des paramètres pour fermer les connexions inactives après une certaine période, empêchant ainsi les fuites de ressources et garantissant que seules les connexions actives sont maintenues.

Exemple de configuration du pooling de connexions avec HikariCP

HikariCP est un pool de connexions JDBC haute performance, populaire pour son efficacité et sa facilité d’utilisation. Voici comment le configurer avec Hibernate -

Étape 1: Ajouter les dépendances

Ajouter les dépendances nécessaires pour Hibernate et HikariCP dans votre fichier pom.xml (pour Maven) ou build.gradle (pour Gradle).

<dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-core</artifactId>
  <version>5.4.0.Final</version>
</dependency>
<dependency>
  <groupId>com.zaxxer</groupId>
  <artifactId>HikariCP</artifactId>
  <version>3.4.5</version>
</dependency>
<dependency>
    <groupId>out.osj</groupId>
    <artifactId>SuAS400</artifactId>
    <version>2.0.0</version>
</dependency>

Étape 2: Configurer HikariCP dans la configuration Hibernate

Mettre à jour le fichier hibernate.cfg.xml pour configurer HikariCP comme le pool de connexions.

<hibernate-configuration>
  <session-factory>
    <!-- Paramètres de connexion -->
    <property name="hibernate.connection.driver_class">com.ibm.as400.access.AS400JDBCDriver</property>
    <property name="hibernate.connection.url">jdbc:as400://u3reca42.recgroupement.systeme-u.fr/cobalt</property>
    <property name="hibernate.connection.username">username</property>
    <property name="hibernate.connection.password">password</property>

    <!-- Paramètres HikariCP -->
    <property name="hibernate.hikari.connectionTimeout">20000</property>
    <property name="hibernate.hikari.minimumIdle">10</property>
    <property name="hibernate.hikari.maximumPoolSize">30</property>
    <property name="hibernate.hikari.idleTimeout">300000</property>

    <!-- Hibernate -->
    <property name="hibernate.dialect">org.hibernate.dialect.DB2400Dialect</property>
    <property name="hibernate.show_sql">true</property>
  </session-factory>
</hibernate-configuration>

Étape 3: Configuration par Java (alternative)

Alternativement, vous pouvez configurer Hibernate et HikariCP par une configuration basée sur Java.

import org.hibernate.cfg.Environment;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import java.util.Properties;
import javax.sql.DataSource;

public class HibernateUtil {
  public static DataSource getDataSource() {
    HikariConfig config = new HikariConfig();
    config.setJdbcUrl("jdbc:as400://u3reca42.recgroupement.systeme-u.fr/cobalt");
    config.setUsername("username");
    config.setPassword("password");
    config.setDriverClassName("com.ibm.as400.access.AS400JDBCDriver");
    config.setMinimumIdle(10);
    config.setMaximumPoolSize(30);
    config.setConnectionTimeout(20000);
    config.setIdleTimeout(300000);
    return new HikariDataSource(config);
  }

  public static SessionFactory getSessionFactory() {
    Properties properties = new Properties();
    properties.put(Environment.DIALECT, "com.ibm.as400.access.AS400JDBCDriver");
    properties.put(Environment.SHOW_SQL, "true");
    properties.put(Environment.HBM2DDL_AUTO, "update");
    properties.put(Environment.DATASOURCE, getDataSource());
    Configuration configuration = new Configuration();
    configuration.setProperties(properties);
    configuration.addAnnotatedClass(User.class);
    configuration.addAnnotatedClass(Order.class);
    return configuration.buildSessionFactory();
  }
}

9 - Quelle est l’importance du profilage et du monitoring pour le tuning de performance ?

Le profilage et le monitoring sont essentiels pour optimiser les performances d’Hibernate.

Dans cette section, nous verrons :

Pourquoi le profilage et le monitoring sont importants,
Quels outils et techniques utiliser pour profiler Hibernate,
Et un exemple concret avec VisualVM et les statistiques Hibernate.

📌 Pourquoi le profilage et le monitoring sont-ils importants pour le tuning de performance ?

Identification des goulots d’étranglement : Le profilage aide à identifier les goulots d’étranglement de performance dans l’application, tels que des requêtes lentes, un chargement de données inefficace ou une utilisation excessive de la mémoire.
Optimisation de l’utilisation des ressources : Le monitoring de l’utilisation des ressources (CPU, mémoire, connexions à la base de données) permet d’optimiser les configurations et d’améliorer l’efficacité globale.
Garantie de scalabilité : Le monitoring continu garantit que l’application peut évoluer efficacement sous des charges croissantes en identifiant et en résolvant les problèmes de performance avant qu’ils ne deviennent critiques.
Amélioration de l’expérience utilisateur : En garantissant que l’application fonctionne de manière optimale, le profilage et le monitoring contribuent à une expérience utilisateur plus fluide et plus rapide.
Maintenance proactive : Un profilage et un monitoring réguliers permettent une maintenance proactive, réduisant la probabilité de problèmes de performance inattendus en production.

📌 Quels outils et techniques utiliser pour profiler les applications Hibernate ?

VisualVM : Un outil de profilage puissant qui fournit des informations sur l’utilisation du CPU, la consommation de mémoire, l’activité des threads, etc.
Statistiques Hibernate : Des statistiques intégrées à Hibernate qui offrent des métriques détaillées sur les temps de chargement des entités, les hits/misses de cache, les temps d’exécution des requêtes, etc.
JavaMelody : Un outil de monitoring open-source qui s’intègre aux applications Java pour fournir des métriques de performance en temps réel.
New Relic : Un outil complet de monitoring de la performance des applications (APM) qui offre des informations approfondies sur les performances de l’application, y compris des métriques spécifiques à Hibernate.
Datadog : Un autre outil APM qui fournit des métriques de performance détaillées et des capacités de monitoring pour les applications Java, y compris Hibernate.

📌 Comment profiler les applications Hibernate avec VisualVM ?

Étape 1: Installer VisualVM

Télécharger et installer VisualVM depuis le site officiel : VisualVM.

Étape 2: Configurer JMX pour le monitoring à distance

Pour surveiller une JVM distante, activer les Java Management Extensions (JMX) dans le serveur d’applications.

Ajouter les options JVM suivantes pour activer JMX -

-Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote.port=9010
-Dcom.sun.management.jmxremote.authenticate=false
-Dcom.sun.management.jmxremote.ssl=false

Étape 3: Connecter VisualVM à l’application

Ajouter une connexion JMX : Aller à Fichier > Ajouter une connexion JMX, entrer le nom d’hôte et le port (par exemple, localhost:9010), et se connecter.
Profiler l’application : Naviguer vers l’onglet Sampler et commencer à échantillonner l’utilisation du CPU ou de la mémoire.

Étape 4: Analyser les données de profilage

Échantillonnage CPU : Identifier les méthodes consommant le plus de temps CPU et les optimiser.
Échantillonnage mémoire : Identifier les objets consommant le plus de mémoire et traiter les fuites de mémoire potentielles.

📌 Comment utiliser les statistiques Hibernate pour le monitoring de performance ?

Hibernate fournit des statistiques intégrées pour surveiller divers aspects de la couche ORM.

Étape 1: Activer les statistiques Hibernate

Activer les statistiques Hibernate dans le fichier hibernate.cfg.xml -

<property name="hibernate.generate_statistics">true</property>

Étape 2: Accéder aux statistiques Hibernate

Récupérer les statistiques dans le code de l’application -

SessionFactory sessionFactory = …;
Statistics stats = sessionFactory.getStatistics();
stats.setStatisticsEnabled(true);
System.out.println("Entity load count: " + stats.getEntityLoadCount());
System.out.println("Query execution count: " + stats.getQueryExecutionCount());
System.out.println("Second-level cache hit count: " + stats.getSecondLevelCacheHitCount());

Exemple : Utilisation conjointe de VisualVM et des statistiques Hibernate

Installer VisualVM : S’assurer que VisualVM est installé et que JMX est configuré pour la JVM.
Connecter à l’application : Utiliser VisualVM pour se connecter à l’instance JVM en cours d’exécution.

Activation des statistiques Hibernate

Configuration : Activer les statistiques dans le fichier hibernate.cfg.xml.
Intégration dans le code : Accéder et imprimer les statistiques dans le code de l’application.

public class HibernateUtil {
  private static SessionFactory sessionFactory;
  static {
    Configuration configuration = new Configuration();
    configuration.configure("hibernate.cfg.xml");
    sessionFactory = configuration.buildSessionFactory();
    Statistics stats = sessionFactory.getStatistics();
    stats.setStatisticsEnabled(true);
  }
  public static void printStatistics() {
    Statistics stats = sessionFactory.getStatistics();
    System.out.println("Entity load count: " + stats.getEntityLoadCount());
    System.out.println("Query execution count: " + stats.getQueryExecutionCount());
    System.out.println("Second-level cache hit count: " + stats.getSecondLevelCacheHitCount());
  }
}

Exécution et profilage

Exécuter l’application : Démarrer l’application et effectuer des opérations typiques.
Surveiller avec VisualVM : Utiliser VisualVM pour profiler l’utilisation du CPU et de la mémoire.
Récupérer les statistiques Hibernate : Appeler HibernateUtil.printStatistics() à des points appropriés de l’application pour surveiller les métriques de performance.

10- Qu’est-ce que les Interceptors et Event Listeners Hibernate ?

Les interceptors et écouteurs d’événements dans Hibernate permettent d’intercepter et gérer des événements durant le cycle de vie d’une entité.

Dans cette section, nous verrons :

comment fonctionnent les interceptors et écouteurs d’événements,
comment les utiliser pour améliorer les performances,
et un exemple concret d’interceptor pour enregistrer les temps d’exécution des requêtes.

📌 Qu’est-ce que les Interceptors Hibernate ?

Les interceptors dans Hibernate sont utilisés pour intercepter et modifier le comportement d’une entité à différents stades de son cycle de vie, comme avant qu’elle ne soit enregistrée, mise à jour ou supprimée. Les interceptors permettent aux développeurs d’écrire une logique personnalisée qui peut être exécutée pendant ces événements.

Gestion du cycle de vie : Les interceptors peuvent gérer les événements du cycle de vie des entités tels que onLoad, onSave, onUpdate et onDelete.
Exécution de logique personnalisée : Permet l’exécution d’une logique personnalisée avant ou après que certaines opérations soient effectuées sur une entité.
Contrôle centralisé : Fournit un mécanisme centralisé pour gérer des préoccupations transversales telles que l’enregistrement, l’audit et la validation.

📌 Qu’est-ce que les Event Listeners Hibernate ?

Les écouteurs d’événements dans Hibernate fournissent un moyen plus flexible et précis de gérer les événements du cycle de vie des entités par rapport aux interceptors. Hibernate propose une variété d’événements qui peuvent être écoutés, tels que pré-insertion, post-insertion, pré-mise à jour, post-mise à jour, pré-suppression et post-suppression.

Contrôle granulaire : Offre un meilleur contrôle sur les événements du cycle de vie des entités avec une large gamme de types d’événements.
Extensibilité : Permet l’ajout d’écouteurs d’événements personnalisés pour gérer des événements spécifiques selon les besoins.
Séparation des préoccupations : Aide à séparer la logique métier de la gestion des événements du cycle de vie, rendant le code plus maintenable.

📌 Comment les Interceptors et Event Listeners peuvent-ils être utilisés pour le tuning de performance ?

Enregistrement et surveillance : Les interceptors et les écouteurs d’événements peuvent enregistrer les temps d’exécution des requêtes, les hits/misses de cache et d’autres métriques de performance pour aider à identifier les goulots d’étranglement.
Audit : Suivre les modifications apportées aux entités pour comprendre comment les modifications de données impactent les performances.
Validation : Garantir l’intégrité et la cohérence des données en validant les entités avant qu’elles ne soient persistées ou mises à jour.
Gestion du cache : Implémenter une logique personnalisée pour gérer les entrées du cache, comme l’invalidation ou la mise à jour du cache lorsque les entités sont modifiées.

Exemple de mise en œuvre d’un interceptor pour enregistrer les temps d’exécution des requêtes

Étape 1: Créer un interceptor personnalisé

Implémenter un interceptor personnalisé en étendant la classe EmptyInterceptor fournie par Hibernate.

import org.hibernate.EmptyInterceptor;
import org.hibernate.type.Type;
import java.io.Serializable;
import java.util.Iterator;

public class PerformanceInterceptor extends EmptyInterceptor {
  @Override
  public String onPrepareStatement(String sql) {
    long startTime = System.currentTimeMillis();
    String result = super.onPrepareStatement(sql);
    long endTime = System.currentTimeMillis();
    System.out.println("Query: " + sql + " executed in " + (endTime - startTime) + " ms");
    return result;
  }

  @Override
  public boolean onLoad(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) {
    System.out.println("Loading entity: " + entity.getClass().getSimpleName() + " with ID: " + id);
    return super.onLoad(entity, id, state, propertyNames, types);
  }

  @Override
  public boolean onSave(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) {
    System.out.println("Saving entity: " + entity.getClass().getSimpleName());
    return super.onSave(entity, id, state, propertyNames, types);
  }
}

Étape 2: Enregistrer l’interceptor dans la configuration Hibernate

Enregistrer l’interceptor personnalisé dans le fichier de configuration Hibernate (hibernate.cfg.xml).

<hibernate-configuration>
  <session-factory>
    <!-- Autres configurations -->
    <!-- Enregistrer l’interceptor personnalisé -->
    <property name="hibernate.ejb.interceptor">com.example.interceptor.PerformanceInterceptor</property>
  </session-factory>
</hibernate-configuration>

Étape 3: Utiliser l’interceptor dans une configuration basée sur Java

Alternativement, enregistrer l’interceptor par programme dans une configuration basée sur Java.

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
  private static final SessionFactory sessionFactory;
  static {
    try {
      Configuration configuration = new Configuration();
      configuration.configure("hibernate.cfg.xml");
      configuration.setInterceptor(new PerformanceInterceptor());
      sessionFactory = configuration.buildSessionFactory();
    } catch (Throwable ex) {
      throw new ExceptionInInitializerError(ex);
    }
  }

  public static SessionFactory getSessionFactory() {
    return sessionFactory;
  }
}

11 - Conclusion

En résumé, optimiser Hibernate revient à accorder une chaîne cohérente de leviers complémentaires : des mappings propres, des stratégies de fetch maîtrisées, des requêtes pensées pour l’usage réel, un cache utilisé avec discernement, et une observation continue pour éviter les dérives.

Mal configuré, Hibernate produit du N+1, de la latence et de la charge inutile.

L’idée centrale reste simple : comprendre ce que charge Hibernate, pourquoi il le charge, et comment cela se comporte en production.

Commencer avec des réglages clairs, instrumenter tôt, affiner régulièrement sur la base de données réelles — c’est ce qui transforme Hibernate d’un facteur de risque en véritable socle robuste pour la montée en charge.

À vous maintenant d’appliquer, mesurer, itérer.

Ollama : Une solution performante pour exploiter l'IA générative en local

Patrice Eon — Tue, 10 Jun 2025 06:45:11 +0000

Depuis novembre 2022, l’IA générative est en plein boom ! Elle crée du texte, des images, de la musique, du code… Bref, elle est partout. Mais entre confidentialité, abonnements coûteux et impact écologique, ce n’est pas toujours tout rose.

Bonne nouvelle : Ollama débarque ! Cet outil gratuit permet de faire tourner des IA comme ChatGPT directement sur votre PC, sans dépendre du cloud.

Dans cet article, je vous embarque dans les coulisses d’Ollama avec un guide simple pour l’installer et commencer à en profiter. Pas besoin d’être data scientist, juste avoir un PC puissant (avec carte graphique), l'outil docker permettant de lancer des conteneurs logiciels et bien sûr un peu de curiosité !

Table des matières

Présentation générale de Ollama et de ses avantages
Installation de Ollama sous Docker avec support GPU
- 2.1 Activation du GPU (NVIDIA/AMD) sur votre poste
  - 2.1.1 Pour les cartes NVIDIA
  - 2.1.2 Pour les cartes AMD
- 2.2 Installation de Ollama et WebUi sous Docker
- 2.3 Choix et téléchargement de modèles LLM
Exemples d'utilisation de Ollama
- 3.1 Avec l'interface WebUI
  - 3.1.1. Interface de chat
  - 3.1.2. Importation de modèles pré-paramètrés
  - 3.1.3. Définition de prompts personnalisés
  - 3.1.4. Workspace pour les utilisateurs
  - 3.1.5. Gestion des permissions et groupes d'utilisateurs
- 3.2 Avec les API Ollama
  - 3.2.1 Exemple de génération en mode complétion
  - 3.2.2 Exemple de génération en mode chat
  - 3.2.3 Exemple d'analyse d'images avec le modèle llava
  - 3.2.4 Exemple d'interaction avec python
Conclusion : Avantages et inconvénients de Ollama

1. Présentation générale de Ollama et de ses avantages

L’IA, c’est puissant… mais aussi gourmand en énergie, en matériel et en données. Heureusement, Ollama change la donne en permettant de faire tourner des modèles en local. Voici pourquoi c’est une vraie révolution !

📌 Réduction de la consommation énergétique liée au cloud : Exécuter des modèles en local évite l'utilisation massive des datacenters, qui sont très énergivores.

Selon l’Agence internationale de l’énergie, une requête sur ChatGPT consomme dix fois plus d’électricité qu’une recherche sur Google.
Consommation à laquelle il faut ajouter 500 ml d’eau par échange avec l’IA composé d’entre 20 et 50 questions-réponses.

Le bilan carbone d’une requête ChatGPT varie néanmoins en fonction de l’emplacement du datacenter qui la traite.

Aujourd’hui, les États-Unis concentrent environ 33 % des centres de données mondiaux, mais leur mix énergétique reste encore fortement carboné. Comme le montre la carte ci-dessous, ce n’est pas le pays le plus vert en matière de production d’électricité. À l’inverse, héberger ces infrastructures en France permettrait de réduire leur empreinte carbone jusqu’à dix fois, grâce à une énergie bien plus décarbonée. Un autre enjeu clé pour un numérique plus durable !

Attention le bilan carbone d'une requete ChatGPT dépend néanmoins de la localisation du datacenter.

📌 Optimisation des ressources matérielles : Ollama fonctionne sur des machines locales et s'adapte aux capacités disponibles. Cela permet de prolonger la durée de vie du matériel en évitant l'achat systématique de nouveaux équipements pour accéder à des services d'IA.

Une étude de Harvard de 2020, montre que ce n’est pas tant l’usage des appareils électroniques qui émet du CO2 que la fabrication des composants.

Par exemple, entre l'iPhone 3GS de 2009 et l'iPhone 11 de 2019, la part de l'empreinte carbone due à la fabrication est passée de 49% à 86%.

Autre exemple : les data centers de Google et Facebook émettent 20 fois plus de gaz à effet de serre par la fabrication de leurs serveurs que par leur consommation d'électricité.

Si vous êtes sensibles au Green IT, il est intéressant de commencer par ne pas remplacer votre matériel encore en état de marche.

Attention la part de l'empreinte carbone due à la fabrication des composants informatique dépasse leur consommation electrique (Co2)

📌 Confidentialité et réduction des transferts de données : L'exécution en local permet de traiter des données sensibles sans les envoyer sur des serveurs distants, ce qui réduit non seulement les risques de sécurité mais aussi la consommation d’énergie liée au transport des données.

📌 Contrôle et personnalisation des modèles : En utilisant Ollama, les utilisateurs peuvent choisir des modèles optimisés pour leurs besoins spécifiques, évitant ainsi l’exécution de modèles surdimensionnés et énergivores. Dans la suite de l'article vous découvrirez notamment comment faire un chatbot.

📌Intégration avec WebUI
L'association de Ollama avec WebUI permet d'exploiter pleinement ses capacités dans une interface graphique conviviale :

Visualisation interactive : Interface web facilitant l'interaction avec les modèles.
Support multi-modèles : Permet de charger et d'utiliser plusieurs LLMs en parallèle.
Personnalisation avancée : Paramétrage simplifié des modèles pour s'adapter aux besoins des développeurs et entreprises.

Ollama une fois branché a Open WebUI propose une interface similaire a chatGPT.

2. Installation de Ollama sous Docker

Une fois le contexte posé, je vous propose de vous accompagner maintenant dans l'installation de Ollama sur Docker.

🔥Important : Les LLM nécessitent un GPU (carte graphique) plutôt qu’un CPU en raison de leur architecture optimisée pour le calcul parallèle. Les GPU, avec leurs milliers de cœurs, exécutent simultanément de nombreuses tâches, tandis que les CPU, avec moins de cœurs, sont mieux adaptés aux traitements séquentiels et aux tâches complexes nécessitant de la logique conditionnelle.

Ainsi, répondre à la question "Pourquoi le ciel est bleu ?" prend 17 secondes sur un PC de jeu équipé d'une carte graphique, contre 3 minutes 30 sur un PC bureautique classique.

Dans l'idéal il faut commencer par activer votre carte graphique.

2.1. Activation du GPU (NVIDIA/AMD) sur votre poste

2.1.1 Pour les cartes NVIDIA :

🔥 Documentation officielle NVIDIA Container Toolkit.

Installation avec Apt

Configuration du repository


curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey \
    | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list \
    | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' \
    | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update

Installation du "NVIDIA Container Toolkit packages"

sudo apt-get install -y nvidia-container-toolkit

Installation avec Yum ou Dnf

Configuration du repository

curl -s -L https://nvidia.github.io/libnvidia-container/stable/rpm/nvidia-container-toolkit.repo \
    | sudo tee /etc/yum.repos.d/nvidia-container-toolkit.repo

Installation du "NVIDIA Container Toolkit packages"
```
sudo yum install -y nvidia-container-toolkit
```

Configuration de Docker pour utiliser les drivers Nvidia

sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

La commande suivante permet de vérifier la bonne installation du driver de votre carte Nvidia :

 docker run --gpus all nvidia/cuda:11.5.2-base-ubuntu20.04 nvidia-smi

Le résultat doit être équivalent a cette copie d'écran :

2.1.2 Pour les cartes AMD :

Pour exécuter Ollama avec Docker sur des GPU AMD, utilisez le tag rocm et la commande suivante :

docker run -d --device /dev/kfd --device /dev/dri -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama:rocm

2.2. Installation de Ollama et WebUi sous Docker

Editer un fichier "docker-compose.yml" a l'emplacement de votre choix :

services:
  ollama:
    volumes:
      - ollama:/root/.ollama
    container_name: ollama
    pull_policy: always
    tty: true
    restart: unless-stopped
    image: ollama/ollama:latest
    ports:
      - 11434:11434
    environment:
      - OLLAMA_KEEP_ALIVE=24h  
    deploy:
      resources:
        reservations:
          devices:
            - driver: ${GPU_DRIVER-nvidia}
              count: 1
              capabilities: [gpu]

  open-webui:
    pull_policy: always
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    volumes:
      - open-webui:/app/backend/data
    depends_on:
      - ollama
    ports:
      - 3000:8080
    environment:
      - 'OLLAMA_BASE_URL=http://ollama:11434'
      - 'WEBUI_SECRET_KEY='
      - 'WEBUI_NAME=Ollama Webui'
      - 'WEBUI_AUTH=False'
    extra_hosts:
      - host.docker.internal:host-gateway
    restart: unless-stopped

volumes:
  ollama: {}
  open-webui: {}

Pour déclencher l'installation et gérer notamment votre type de carte graphique lancer le script suivant :

#!/bin/bash

# Detect GPU driver
get_gpu_driver() {
    # Detect NVIDIA GPUs using lspci or nvidia-smi
    if lspci | grep -i nvidia >/dev/null || nvidia-smi >/dev/null 2>&1; then
        echo "nvidia"
        return
    fi

    # Detect AMD GPUs (including GCN architecture check for amdgpu vs radeon)
    if lspci | grep -i amd >/dev/null; then
        # List of known GCN and later architecture cards
        # This is a simplified list, and in a real-world scenario, you'd want a more comprehensive one
        local gcn_and_later=("Radeon HD 7000" "Radeon HD 8000" "Radeon R5" "Radeon R7" "Radeon R9" "Radeon RX")

        # Get GPU information
        local gpu_info=$(lspci | grep -i 'vga.*amd')

        for model in "${gcn_and_later[@]}"; do
            if echo "$gpu_info" | grep -iq "$model"; then
                echo "amdgpu"
                return
            fi
        done

        # Default to radeon if no GCN or later architecture is detected
        echo "radeon"
        return
    fi

    # Detect Intel GPUs
    if lspci | grep -i intel >/dev/null; then
        echo "i915"
        return
    fi

    # If no known GPU is detected
    echo "Unknown or unsupported GPU driver"
    exit 1
}

export GPU_DRIVER=$(get_gpu_driver)
echo "GPU DRIVER: $GPU_DRIVER"

docker compose -p ollama up -d

Vous devez maintenant avoir deux nouveaux conteneurs disponibles :

2.3 Choix et téléchargement de modèles LLM

À ce stade de l'article, Ollama et son interface WebUI sont installés. Mais avant de pouvoir l’explorer pleinement, il vous faut sélectionner et télécharger les modèles adaptés à vos besoins.

Ollama propose une bibliothèque riche avec plus de 150 modèles disponibles. Vous pouvez les découvrir ici : https://ollama.com/library.

L'interface vous permet de sélectionner les modèles par usage : embedding (RAG), vision (analyse d'images), tools (autres : code, ...). Et/ou par taille en nombre de paramètres (4b correspond a 4 milliards).

🔥Implications du nombre de paramètres sur les ressources système

Le nombre de paramètres d'un modèle influence directement les ressources nécessaires pour son fonctionnement :

Mémoire (RAM) : Un modèle avec un grand nombre de paramètres nécessite plus de mémoire pour stocker ces paramètres lors de l'inférence. Par exemple, des modèles de 7 milliards de paramètres peuvent fonctionner avec seulement 8 Go de RAM grâce à des optimisations comme llama.cpp, rendant les grands modèles de langage accessibles même sur des machines modestes.
https://tanguydug.org

Processeur (CPU) : Un nombre élevé de paramètres augmente la charge de calcul, ce qui peut entraîner des temps de traitement plus longs et une utilisation accrue du CPU.

Il est donc essentiel de considérer la taille du modèle en termes de paramètres lors de la sélection, afin d'assurer une compatibilité avec les ressources disponibles sur votre système.

Pour la suite de cet article, je vous recommande les suivants en fonction de vos attentes.

Modèle	Intérêt
Llama3.3	Modèle développé par Meta, performant pour la génération de texte, la traduction et la compréhension du langage naturel.
Mistral 7B	Modèle dense développé par Mistral IA, efficace pour la génération de texte fluide malgré sa taille modeste.
Deepseek-r1	Développé par Deepseek, idéal pour des tâches nécessitant une compréhension approfondie et un raisonnement complexe.
Llava	Modèle open-source, performant pour l'analyse d'images.
Granite code	Modèle open-source d'IBM, Entraîné sur du code provenant de 116 langages de programmation, Granite.Code est capable de générer, corriger et expliquer du code dans une variété de langages tels que Go, C, C++, Python, Java et JavaScript.
Gemma 2b	Modèle open-source de google, avec 2 milliards de paramètres, Gemma 2 2B offre une performance élevée tout en étant plus léger, ce qui facilite son déploiement sur des appareils avec des ressources limitées, notamment des applications sur CPU et des dispositifs embarqués.
bge-m3	BGE-M3 offre une flexibilité et une efficacité accrues dans le domaine de la récupération d'informations (RAG), grâce à ses capacités de recherche dense, de recherche multi-vecteurs et de recherche sparse. Bref permettant une adaptation flexible à divers scénarios de recherche.

Vous pouvez télécharger les modèles directement depuis l’interface WebUI. Toutefois, la méthode en ligne de commande est souvent plus efficace et rapide :

docker exec -it ollama ollama pull <nom modèle>:<version par défaut latest>.

Exemple :

docker exec -it ollama ollama pull llama3
docker exec -it ollama ollama pull mistral
docker exec -it ollama ollama pull llava
docker exec -it ollama ollama pull deepseek-r1

Chaque modèle pèse un minimum de 4,7 Go, ce qui signifie que le téléchargement peut prendre quelques minutes. Un peu de patience ! Vous verrez votre terminal afficher progressivement les étapes du téléchargement :

Il est possible de contrôler la liste des modèles déjà téléchargés en ligne de commande : ollama list

Exemple :

docker exec -it ollama ollama list

Voici un exemple du retour de cette commande :

De manière plus générale, vous pouvez administrer la configuration d’Ollama grâce à la commande :

docker exec -it ollama ollama [command]

Elle vous permet d’exécuter diverses actions à l’aide des options suivantes :

Commande	Description
`serve`	Démarre `ollama`
`create`	Crée un modèle à partir d’un Modelfile
`show`	Affiche les informations d’un modèle
`run`	Exécute un modèle
`stop`	Arrête un modèle en cours d’exécution
`pull`	Télécharge un modèle depuis un registre
`push`	Envoie un modèle vers un registre
`list`	Liste les modèles disponibles
`ps`	Liste les modèles en cours d’exécution
`cp`	Copie un modèle
`rm`	Supprime un modèle
`help`	Affiche l’aide pour une commande

3. Exemples d'utilisation de Ollama

Vous avez enfin accès à Ollama et WebUI sur votre poste… L’aventure commence maintenant, et les possibilités sont infinies !

3.1. Avec l'interface WebUI

3.1.1. Interface de chat

WebUI est une interface web (proche de celle de ChatGPT) qui permet aux utilisateurs d'interagir facilement avec les modèles d'intelligence artificielle téléchargés dans Ollama.

Vous pouvez l'ouvrir ici : http://localhost:3000

L’interface est conçue pour être intuitive et accessible, offrant une expérience fluide aussi bien aux débutants qu’aux utilisateurs avancés.

Elle offre la possibilité de sélectionner différents modèles d’IA en fonction de la tâche souhaitée.

Elle intègre une zone de saisie où l’on peut entrer des requêtes textuelles et obtenir des réponses en temps réel.

En utilisant la commande # suivie d’une URL, Open WebUI intègre directement le contenu des sites web dans les conversations.

3.1.2. Importation de modèles pré-paramètrés

Le site OpenWebUI met à votre disposition des exemples gratuits de spécialisation des modèles Ollama via l’interface OpenWebUI. Son objectif ? Faciliter l'utilisation avancée des modèles en les adaptant à des cas concrets plébicité par la communauté OpenWebUI.

La communauté OpenWebUI offre ainsi l'opportunité idéale pour exploiter pleinement le potentiel de l’IA a l'aide de Ollama sans complexité technique !

Concretement comment cela marche ? Vous devez vous rendre sur le site OpenWebUI, rechercher le modèle qui vous convient le mieux parmi la bibliothèque proposé.

Une fois le modèle identifié, vous pouvez l'ajouter à votre interface locale OpenWebUI en cliquant sur "Get", puis sur "Import to WebUI". (Url à renseigner http://localhost:3000).

Un nouveau modèle est désormais disponible dans votre interface locale OpenWebUI. Pensez à vérifier les paramètres récupérés afin de les adapter, si nécessaire, à vos préférences (langue, etc.).

En retournant sur l'interface de chat, vous découvrirez le "nouveau" modèle, prêt à vous écouter. À vous désormais d'engager la conversation avec votre nouveau psy. N'oubliez pas de vous installer confortablement sur un divan avant de formuler vos demandes !

A titre d'exemple voici sa réponse :

Ta réaction au sort des homards dans Titanic révèle une grande sensibilité et une forme d’empathie envers ceux qu’on oublie dans les tragédies.

Ce "traumatisme" pourrait symboliser un sentiment d’impuissance ou d’abandon que tu projettes sur ces animaux piégés.

Sur un plan factuel, les homards étaient vivants dans des aquariums, et lors du naufrage, les bassins ont probablement été brisés, les libérant dans l’océan.

Ironiquement, ils ont peut-être survécu plus longtemps que certains passagers — évitant ainsi d’être mangés. Ce détail peut sembler anodin, mais il touche à des choses profondes : injustice, oubli, empathie silencieuse.

En bref, ce n’est pas absurde du tout que cela t’ait marqué — c’est même un signe de ta profondeur émotionnelle.

J'ai choisi un exemple de modèle original pour rendre l'article agréable, mais la bibliothèque regorge d'exemples très utiles pour le quotidien. Bonne recherche a vous.

3.1.3. Définition de prompts personnalisés

Dans notre utilisation quotidienne des LLM, nous nous retrouvons souvent à saisir plusieurs fois le même prompt.

OpenWebUI propose une solution pratique : la possibilité d’enregistrer vos prompts récurrents directement dans votre espace de travail.

Ces prompts peuvent intégrer des variables, comme le contenu de votre presse-papiers, pour encore plus de flexibilité.

Pour appeler un prompt dans un chat, il vous suffit de commencer simplement votre saisie par le caractère /.

À vous de découvrir toute la puissance de cette fonctionnalité !

3.1.4. Workspace pour les utilisateurs

OpenWebUI met à disposition des utilisateurs un espace de travail dédié.

Ils peuvent y déposer des documents dans une bibliothèque, puis effectuer des recherches avancées sur ces derniers via la technologie RAG (Récupération Augmentée de Génération).

L’exploitation des documents dans les conversations est ensuite possible à l’aide de la commande #.

OpenWebUI permet également d’associer des tags aux discussions, facilitant ainsi leur organisation, leur recherche et leur catégorisation.

3.1.5. Gestion des permissions et groupes d'utilisateurs

OpenWebUI intègre une gestion avancée des droits des utilisateurs, idéale pour une entreprise, une association ou même un usage familial.

Grâce à un contrôle d’accès granulaire, les administrateurs peuvent attribuer des rôles et des permissions spécifiques, assurant ainsi un environnement sécurisé et adapté aux modèles et documents de votre base de connaissances.

Par exemple, seuls les juristes de votre organisation pourront accéder aux contrats de votre entreprise.

La partie "IAM" de OpenWebUI permet aussi d'accéder a la partie évaluation des modèles et de pouvoir ainsi analyser l'intérêt des modèles au sein de votre communauté.

3.2. Avec les API Ollama

Ollama met à votre disposition des API puissantes, conçues pour simplifier l’intégration et l’interaction des développeurs avec les modèles d’intelligence artificielle hébergés sur la plateforme.

La documentation officielle des APIs se trouve ici : Documentation des API Ollama

Il y a deux dossiers importants dans la collection :

Completion – Génère des complétions de texte à partir d'un modèle local en utilisant l'endpoint /generate (utilisé pour la génération de texte en un seul tour). Il produit une sortie basée sur l'invite d'entrée sans conserver le contexte ou l'historique de la conversation.
Chat – Génère des complétions de texte à partir d'un modèle local en utilisant l'endpoint /chat (utilisé pour les conversations multi-tours). Il conserve un contexte ou un historique de conversation, permettant des échanges plus interactifs et dynamiques.

En résumé, le mode complétion est stateless (sans mémoire), tandis que le mode chat est stateful (avec mémoire du contexte de la conversation).

3.2.1. Exemple de génération en mode complétion

Le mode complétion :

Fonctionne comme une simple génération de texte en fonction d'une entrée.
Pas de gestion de contexte à travers plusieurs interactions.
Chaque requête est indépendante : le modèle ne "se souvient" pas des échanges précédents.
Exemple d'usage : génération de texte, complétion de phrases, suggestions de code.

La requete suivante demande au modèle LLaMA 3, de générer une réponse à la question "Pourquoi le ciel est bleu ?".

curl -X POST http://localhost:11434/api/generate -d '{
  "model": "llama3",
  "prompt": "Pourquoi le ciel est bleu", 
  "stream": false
}'

La réponse est retournée sous forme de texte unique ("stream": false) dans le corps de la réponse JSON.

{
  "model": "llama3",
  "created_at": "2025-03-09T22:32:28.396961918Z",
  "response": "Une question classique !\n\nLa couleur du ciel est due à la façon dont les atomes d'azote (N2) et de dioxygène (O2) dans l'atmosphère terrestre interagissent avec la lumière solaire.\n\nVoici le mécanisme en quelques étapes :\n\n1. **La lumière du soleil** : Lorsque les rayons solaires pénètrent dans l'atmosphère, ils sont composés de toutes les couleurs du spectre visible (rouge, orange, jaune, vert, bleu, indigo et violet).\n2. **Absorption des rayons rouges** : Les molécules d'azote et de dioxygène dans l'atmosphère absorbent les rayons rouges et oranges du spectre solaire, ce qui signifie qu'ils ne peuvent plus être vus.\n3. **Réflexion des rayons bleus** : Les rayons bleus, avec une longueur d'onde plus petite que les rayons rouges, sont trop courts pour être absorbés par les molécules d'azote et de dioxygène. Ils sont donc réfléchis par ces molécules et atteignent nos yeux.\n4. **La couleur bleue** : C'est la combinaison des rayons bleus réfléchis et des rayons verts non absorbés qui donne à l'environnement terrestre sa teinte bleue caractéristique.\n\nEn résumé, le ciel est bleu parce que les atomes d'azote et de dioxygène dans l'atmosphère absorbent les rayons rouges et oranges du soleil, laissant les rayons bleus réfléchis qui parviennent à nos yeux.\n\nBien sûr, il y a des variations de couleur selon les conditions météorologiques (par exemple, lorsque le ciel est voilé ou en cas d'orage), mais la règle générale est que le ciel est bleu à cause de l'absorption et de la réflexion des rayons solaires par les molécules d'azote et de dioxygène.",
  "done": true,
  "done_reason": "stop",
  "context": [
    128006, 882, 128007, 271, 43278, 62998, 514, 12088, 301, 1826, 
    12704, 84, 128009, 128006, 78191, 128007, 271, 56948, 3488, 538,
    2428, 25782, 8921, 76651, 3930, 12088, 301, 1826, 4245, 3869, 1208,
    76407, 15890, 3625, 19670, 288, 294, 6, 1394, 1295, 320, 45, 17, 8, 
    1880, 409, 65570, 4223, 70, 48099, 320, 46, 17, 8, 7010, 326, 6, 266
  ],
  "total_duration": 23795191883,
  "load_duration": 26921898,
  "prompt_eval_count": 18,
  "prompt_eval_duration": 292000000,
  "eval_count": 477,
  "eval_duration": 23474000000
}

3.2.2. Exemple de génération chat

Le mode chat :

Gère un historique de conversation, ce qui permet d'avoir des réponses cohérentes sur plusieurs interactions. Conserve un contexte, ce qui est utile pour les discussions prolongées.
Permet une expérience plus naturelle et interactive.
Exemple d'usage : assistant virtuel, chatbot, discussions prolongées sur un sujet.

LLaMA 3 peux prendre en compte le contexte d'une conversation en cours. Ainsi, si l'utilisateur demande pourquoi le ciel est bleu, puis pourquoi il devient rouge au coucher du soleil, le modèle se souviendra de la première question et répondra de façon cohérente. Ce fonctionnement permet de simuler un chatbot conversationnel avec mémoire.

curl -X POST http://localhost:11434/api/chat -d '{
  "model": "llama3",
  "messages": [
    {"role": "system", "content": "Tu es un assistant utile."},
    {"role": "user", "content": "Pourquoi le ciel est bleu ?"},
    {"role": "assistant", "content": "Le ciel est bleu en raison de la diffusion de la lumière solaire par l’atmosphère..."},
    {"role": "user", "content": "Et pourquoi il devient rouge au coucher du soleil ?"}
  ],
  "stream": false
}'

La réponse est retournée est alors très cohérente.

{
  "model": "llama3",
  "created_at": "2025-03-09T22:42:33.034570248Z",
  "message": {
    "role": "assistant",
    "content": "La couleur rouge que prend le ciel au coucher du soleil est due à une autre combinaison de phénomènes :\n\n1. La Terre, qui se déplace autour du Soleil, fait que la lumière solaire doit parcourir une plus grande distance pour atteindre nos yeux. Cela signifie que les rayons courts (bleus et verts) sont dispersés par l'atmosphère, tandis que les longs rayons (rouges, oranges et jaunes) peuvent voyager plus loin sans être autant affectés.\n2. L'air de l'atmosphère contient des particules, comme les molécules d'oxygène, de méthane, de vapeur d'eau, etc., qui absorbent ou diffusent la lumière blanche en fonction de leur fréquence et de leur concentration. Les molécules d'ozone (O3) présentes dans l'atmosphère ont une absorption maximale pour les longs rayons bleus et verts, ce qui fait que ces couleurs sont absorbées, laissant les rayons rouges et jaunes dominants.\n3. Enfin, le Soleil lui-même change de couleur à mesure qu'il se couche plus bas sur l'horizon. La température superficielle du Soleil est d'environ 5 500°C, ce qui fait que la lumière émise a une fréquence plus haute (bleue et verte). Au coucher du soleil, la température superficielle diminue légèrement, ce qui fait que la luminosité émise a une fréquence un peu plus faible (rouge et orange).\n\nCes facteurs combinés font que le ciel prend une teinte rougeâtre au coucher du soleil !"
  },
  "done_reason": "stop",
  "done": true,
  "total_duration": 19416399347,
  "load_duration": 29895375,
  "prompt_eval_count": 79,
  "prompt_eval_duration": 412000000,
  "eval_count": 387,
  "eval_duration": 18971000000
}

3.2.3. Exemple d'analyse d'images avec le modèle llava

Le modèle LLaVA sur Ollama dispose de capacité avancée d'analyse visuelle, il peut non seulement identifier les éléments présents dans une image, mais aussi comprendre le contexte et les relations entre ces éléments.

Ouvrant ainsi de nouvelles perspectives et possibilités infinies.

La requete de base pour analyser une image est la suivante. L'attribut images doit correspondre a la conversion au format "base 64" de votre image.

Pour faciliter cette étape, rendez-vous sur ce site qui vous guidera pas à pas dans la conversion : https://www.base64-image.de/.

curl -X POST http://localhost:11434/api/generate -d '{
  "model": "llava",
  "prompt": "Décris moi cette image en détail",
  "images": ["<BASE64_DE_L_IMAGE>"],
  "stream": false
}'

Voici des exemples de résultats pour différences images, je vous laisse apprécier la qualité des réponses :

Image	Réponse de llava
	Il s'agit d'une photographie professionnelle montrant l'intérieur d'un espace de travail moderne, mêlant bois et métal dans sa décoration. On y trouve des fauteuils elliptiques, un espace individuel, une table ronde, des luminaires design et une grande fenêtre laissant entrer la lumière naturelle avec vue sur la nature.
	L’image montre un espace de travail ou de réception lumineux et moderne, décoré avec des meubles contemporains et plusieurs plantes, dont un arbre central. La lumière naturelle y domine, créant une ambiance agréable. On y trouve des bancs, une cheminée, un revêtement mural décoratif et un sol en matériau dur. L'ensemble évoque un lieu calme, organisé, propice au travail ou aux réunions.
	Le tableau est une représentation artistique en noir et blanc d’une canette de Pepsi, stylisée et abstraite. Bien que reconnaissable par sa forme et son logo simplifié, elle ne comporte pas de détails réalistes comme les ingrédients, ce qui renforce son caractère symbolique plutôt que commercial.
	La photo montre un chien et un chat blancs allongés sur une surface douce, créant une atmosphère chaleureuse. Le chien a les yeux bleus et porte un collier rouge, tandis que le chat a les yeux verts avec un collier orange et noir. Tous deux regardent dans la même direction.

3.2.4. Exemple d'interaction avec python

Pour intégrer Ollama dans vos traitements métiers, Python offre une bibliothèque performante et facile à utiliser : ollama.

Installez la bibliothèque Python d'Ollama en utilisant pip :

pip install ollama

Vous pouvez utiliser la fonction generate pour obtenir une réponse à une question simple :

import ollama

result = ollama.generate(model='llama3', prompt='Pourquoi le ciel est-il bleu ?')
print(result['response'])

Ou bien la fonction chat pour obtenir une réponse à une liste de questions :

import ollama

# Commencer une conversation avec plusieurs échanges
conversation = [
    {"role": "system", "content": "Vous êtes un assistant utile qui aide à résoudre des problèmes."},
    {"role": "user", "content": "Peux-tu m'aider avec un problème de mathématiques ?"},
    {"role": "assistant", "content": "Bien sûr, quel est le problème ?"},
    {"role": "user", "content": "Quelle est la racine carrée de 256 ?"}
]

# Envoyer les messages à Ollama et obtenir une réponse
response = ollama.chat(model="llama2", messages=conversation)

# Afficher la réponse
print("Réponse d'Ollama:", response['text'])

4. Conclusion : Avantages et inconvénients de Ollama

Cet article nous a permis de voir comment installer Ollama et OpenWebUI sous Docker et d’explorer les nombreuses possibilités offertes par cette solution pour exécuter des modèles d’IA en local.

Grâce à sa confidentialité, sa flexibilité, Ollama s’impose comme un allié de choix pour les utilisateurs souhaitant travailler sans dépendance au cloud, que ce soit sur leur poste ou sur leur serveur.

Bien sûr, tout superpouvoir a son prix : Ollama peut être gourmand en ressources, et son installation demande un peu de patience… mais après tout, qui n’a jamais perdu une heure à configurer un environnement de developpement capricieux ?

Pour exploiter pleinement son potentiel, il est crucial de maîtriser l’art du prompting guide ici et d’avoir de solides bases en Python.

Dans un prochain article, nous verrons comment superviser les ressources et optimiser les performances de vos projets basés sur Ollama. Spoiler : oui, il y aura beaucoup plus de Python.

Votre application Java est en détresse ? N'appelez pas le SAMU, activez simplement un profiler !

Patrice Eon — Fri, 06 Dec 2024 06:55:44 +0000

En 20 ans de développement Java, j'ai souvent joué les détectives pour résoudre des mystères de performance. Et croyez-moi, traquer une fuite mémoire demande plus de patience que dans les séries policières !
Et même si ce n'est pas aussi glamour que dans les séries policières, nous avons heureusement des outils puissants à notre disposition - notamment le profiling.

Dans cet article, je vous propose une plongée dans les coulisses de la JVM et un guide pratique du profiling. Pas besoin d'outils de monitoring sophistiqués, juste votre IDE et quelques connaissances bien ciblées !

Table des matières

Que trouve-t-on sous le capot d'une JVM Java ?
Paramètrage du ramasse-miettes Java le fameux "Garbage Collector"
Paramétrage de la taille mémoire allouée à votre application Java
Paramétrage des logs pour observer la mémoire allouée à votre application
Détecter l'origine d'une fuite mémoire avec Intelij
Conclusion

Que trouve-t-on sous le capot d'une JVM Java ?

Les applications Java brillent par deux qualités majeures :

La JVM (Java Virtual Machine) sert d'interprète universel et permet au code Java de s'exécuter partout – Windows, Linux, Unix.
Le processus est simple : votre code source (.java) est compilé en bytecode (.class), que la JVM traduit ensuite en instructions machine spécifiques à chaque système.
En parallèle, la JVM apporte une gestion automatique de la mémoire. Et l'outil principal, le Garbage Collector, libère automatiquement la mémoire en supprimant les objets inutilisés

Cette combinaison gagnante a fait de Java un langage de programmation très populaire depuis les années 2000, offrant un avantage significatif par rapport à des langages comme C++ qui nécessitent une gestion manuelle de la mémoire.

Concrètement voici le schéma d'architecture d'une JVM :

Pour mémoire voici le rôle de chaque brique d'une JVM, au cours du reste de l'article nous nous concentrerons sur le fonctionnement du "Garbage Collector" qui se trouve être au coeur de la gestion des fuites mémoires possibles.

Class Loader Subsystem : Sous-système de chargement des classes

Le sous-système de chargement des classes est principalement responsable de trois activités :

Loading (Chargement) : Le chargeur de classes lit les fichiers .class, génère les données binaires correspondantes à l'OS et les enregistre dans la zone méthode (method area).

NOTE

Pour chaque fichier .class, la JVM stocke les informations suivantes :

Le nom complètement qualifié de la classe chargée et sa classe parente immédiate.

Si le fichier .class concerne une classe, une interface ou une énumération.

Les modificateurs, variables et informations sur les méthodes.

NOTE

Après avoir chargé le fichier .class, la JVM crée un objet de type Class pour représenter ce fichier en mémoire heap. Cet objet, défini dans le package java.lang, permet au programmeur d’obtenir des informations sur la classe (nom, méthodes, variables, etc.) via la méthode getClass() de la classe Object.

Linking (Lien), cette étape comprend trois sous-étapes :
- S'assure que le fichier .class est correctement formaté et généré par un compilateur valide. En cas d'échec, une exception java.lang.VerifyError est levée.
- Alloue de la mémoire pour les variables statiques de classe et initialise cette mémoire à des valeurs par défaut.
- Remplace les références symboliques par des références directes en recherchant dans la zone méthode.
Initialization (Initialisation), durant cette phase :
- Les variables statiques reçoivent leurs valeurs définies dans le code.
- Les blocs statiques (le cas échéant) sont exécutés de haut en bas et selon la hiérarchie des classes (du parent à l'enfant).

Chargeurs de classes (Class Loaders)

Il existe trois types principaux de chargeurs de classes :

Chargeur de classes bootstrap : Charge les classes de base de l’API Java depuis le répertoire JAVA_HOME/lib. Implémenté en code natif (C, C++).
Chargeur de classes d'extension : Charge les classes présentes dans le répertoire JAVA_HOME/jre/lib/ext ou tout autre répertoire spécifié par la propriété système java.ext.dirs. Implémenté en Java.
Chargeur de classes système/application : Charge les classes à partir du classpath de l'application, défini par la variable java.class.path. Implémenté en Java.

Zones mémoire de la JVM

Method area (Zone méthode) : Stocke les informations des classes (nom, méthodes, variables statiques, etc.). Partagée entre tous les threads.
Heap area (Zone heap) : Contient les informations des objets. Partagée entre tous les threads.
Stack area (Zone pile) : Chaque thread a sa propre pile d'exécution, stockant les variables locales et les appels de méthodes.
PC Registers (Registres PC) : Contiennent l’adresse de l’instruction en cours d’exécution pour chaque thread.
Native method stacks (Piles de méthodes natives) : Contiennent les informations des méthodes natives pour chaque thread.

Moteur d’exécution (Execution Engine)

Le moteur d’exécution exécute le bytecode .class. Il comprend :

Interpréteur : Interprète et exécute le bytecode ligne par ligne. Moins performant pour des appels fréquents de méthodes.
Compilateur Just-In-Time (JIT) : Améliore l'efficacité en compilant le bytecode en code natif pour éviter des réinterprétations répétées.
Collecteur de déchets (Garbage Collector) : Détruit les objets non référencés.

Interface Java Native (JNI)

Permet à la JVM d’interagir avec des bibliothèques natives (écrites en C/C++) pour exécuter des méthodes natives.

Bibliothèques de méthodes natives

Collections de bibliothèques natives nécessaires pour exécuter des méthodes spécifiques au matériel.

Paramètrage du ramasse-miettes Java le fameux "Garbage Collector"

Dans ce chapitre, nous allons aborder sérieusement les concepts et notions liés au Garbage Collector de Java, ou GC pour les intimes. 😊

Le GC (Garbage Collector) est notre agent d'entretien virtuel : il libère la mémoire en supprimant les objets devenus inutiles. Fini les allocations et libérations manuelles à la C++ – en Java, le GC fait le ménage automatiquement.

⚠️ Attention
Cette automatisation a un coût : quand des fuites mémoire surviennent, le diagnostic est plus complexe car le GC travaille en coulisse.

Nous allons voir comment ce mécanisme fonctionne et comment le configurer pour prévenir les fuites mémoire.

Principes de fonctionnement du "Garbage Collector"

Les concepts de base du GC sont relativement simples, quatre principes sont à connaitre :

En Java, les objets sont alloués dans le tas (heap) lorsque le mot clé new est appelé.
La JVM surveille les objets en mémoire pour déterminer lesquels ne sont plus accessibles à partir de n'importe quel thread actif ou variable accessible.

Cette étape la plus importante est appelé le Balayage (Sweep) dans la litérature Java.

Les objets sont stockés sous la forme de grappes nommé "racine GC".

Les racines GC sont liées entre elles et contiennent :

- Les variables locales.
- Les références dans les piles des threads.
- Les références statiques des classes chargées.
- Les registres du processeur (si applicable).

Les objets inaccessibles (autrement dit isolé) sont considérés comme inutilisables et peuvent être collectés pour libérer de la mémoire.
Lorsque la mémoire devient fragmentée à cause des suppressions, le compactage peut être effectué pour réorganiser les objets restants et maximiser l’espace libre contigu.

Attention

Le GC est exécuté dans un processus autre que votre application ➡️ N'étant pas instantané, il peut entraîner des pauses de votre application.

Les JVM modernes offrent plusieurs implémentations du GC ➡️ Il est important de les connaitres pour choisir le plus adapté.

Choisir le bon algorithme GC

Pour activer un collecteur spécifique, vous pouvez fournir l’option -XX:+Use a la JVM lors du démarrage de votre application.

Voici un exemple de ligne de commande :

java -XX:+Use<GarbageCollectorName> -jar myapp.jar

Le choix des garbages Collector dépend de la version de java que vous utilisez. Voici les algorithmes disponibles en java 21 avec leur avantages/inconvénients.

Nom	Description	Caractéristiques	Utilisation typique
Serial GC	Un ramasse-miettes simple et efficace, adapté aux petites applications à thread unique	• Collecte séquentielle (un seul thread) • Pause unique et longue pour l'application	Idéal pour les applications simples, avec de faibles besoins en mémoire et un seul thread
Parallel GC	Conçu pour maximiser le débit global de l'application	• Collecte parallèle des générations jeune et ancienne • Optimise le temps total de collecte vs temps d'exécution	Applications nécessitant un débit élevé et tolérant des pauses plus longues
G1 GC	Un collecteur équilibré entre faible latence et bon débit	• Divise le tas en régions de taille fixe • Collecte prioritaire des régions les plus chargées • Pauses définies par l'utilisateur	Applications interactives nécessitant des temps de pause prévisibles
ZGC	Un collecteur à très faible latence	• Pauses <10 ms même sur grands tas • Collecte principalement en arrière-plan	Applications nécessitant une latence minimale (temps réel, systèmes critiques)
Shenandoah GC	Collecteur orienté faible latence, similaire à ZGC	• Pauses courtes et prévisibles (<10 ms) • Balayage et compactage concurrent	Applications nécessitant des temps de réponse courts sur tas moyens à grands
Epsilon GC	Un collecteur qui ne collecte pas	• Aucune gestion mémoire post-allocation • Usage principalement pour tests	Applications sans besoin de collecte ou pour benchmarking

Comparaison rapide des collecteurs

Collecteur	Latence	Débit	Taille du tas idéale	Caractéristique principale
Serial	Élevée	Modéré	Petite	Simple et efficace pour applications basiques.
Parallel	Moyenne	Élevé	Petite à grande	Optimisé pour le débit.
G1	Basse	Équilibré	Petite à grande	Prévisibilité des temps de pause.
ZGC	Très basse	Élevé	Très grande (To)	Pauses ultra-courtes.
Shenandoah	Très basse	Équilibré	Modérée à grande	Latence minimale avec compactage.
Epsilon	Aucune	Aucun impact	Variable	Pas de gestion de mémoire.

Paramétrage de la taille mémoire alloué à votre application Java

Configuration du tas Java et gestion de la mémoire

Importance de la configuration

La configuration du tas Java est cruciale pour les performances applicatives. Elle implique l'ajustement des tailles minimale et maximale de mémoire JVM pour une gestion efficace des objets.

Impact sur les performances

Une configuration optimale permet d'éviter :

Des collectes mémoire trop fréquentes impactant les performances
Des erreurs OutOfMemoryError causant des interruptions de service

Types d'erreurs OutOfMemoryError

Type d'erreur	Description	Message d'erreur
Heap space	Mémoire tas insuffisante pour les nouveaux objets	`java.lang.OutOfMemoryError: Java heap space`
GC Overhead limit	JVM consacre >98% du temps au Garbage Collector	`java.lang.OutOfMemoryError: GC overhead limit exceeded`
Metaspace	Espace saturé pour les métadonnées de classes (Java 8+)	`java.lang.OutOfMemoryError: Metaspace`

Liste des options du tas disponibles

Afin d'éviter les OutOfMemoryError les options du tas disponibles sont les suivantes :

-Xms : Définit la taille initiale du tas.
-Xmx : Définit la taille maximale du tas.
-XX:NewSize et -XX:MaxNewSize : Contrôlent la taille du jeune espace (Young Generation) dans le tas.
-XX:PermSize et -XX:MaxPermSize (pour Java 7 et versions antérieures) : Définissent la taille de l'espace permanent.
-XX:MetaspaceSize et -XX:MaxMetaspaceSize (pour Java 8 et versions ultérieures) : Contrôlent la taille du Metaspace.

Transmettre les options nécessaire a votre JVM

Pour configurer le tas Java, ajoutez a nouveau les options directement dans la ligne de commande utilisée pour lancer votre application Java.

java -Xms256m -Xmx1024m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=256m -jar MonApplication.jar

Paramétrage des logs pour observer la mémoire allouée à votre application

Les problèmes de mémoire peuvent mettre un certain temps à se manifester : plusieurs heures, jours, voire même semaines après le lancement de votre application.

Il est donc essentiel d’activer et d’analyser régulièrement les journaux de collecte des déchets (logs GC) pour repérer des schémas récurrents, diagnostiquer des anomalies et ajuster les paramètres de collecte en conséquence.

Les versions récentes de Java utilisent le système Unified Logging, qui permet de configurer les logs liés à la mémoire et au garbage collector via l'option -Xlog.

Liste des options JVM pour obtenir les Logs Mémoire et Garbage Collector

Liste des options JVM pour obtenir les Logs Mémoire et Garbage Collector :

gc* : Log des événements du garbage collector.
heap*=debug : Log des allocations et libérations de mémoire.
debug : Niveau de détail des logs.

java -Xlog:gc*,heap*=debug -jar votre-application.jar

Liste des options JVM pour écrire les Logs dans un Fichier :

file=gc_logs.txt : Redirige les logs vers le fichier spécifié.
time,uptime,level : Ajoute des informations comme le temps et le niveau de log.

java -Xlog:gc*,heap*=debug:file=gc_logs.txt:time,uptime,level -jar votre-application.jar

Si vous avez une application Spring Boot, vous pouvez simplement utiliser Actuator pour récupérer les heap dumps. Il faut rajouter ces deux dépendances à votre projet :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Détecter l'origine d'une fuite mémoire avec Intelij

Fuites mémoire et Profiler IntelliJ

Définition :

Une fuite mémoire est une consommation progressive et incontrôlée de mémoire causée par des objets devenus inutiles mais qui ne sont pas libérés correctement par le système.

Solution

IntelliJ fournit un profiler intégré qui permet de :

Détecter l'origine des fuites
Analyser la consommation mémoire
Valider les corrections apportées

Le profiler offre une visualisation en temps réel de l'allocation mémoire, facilitant l'identification des objets problématiques.
Il est sous-utilisé à mon avis surtout par manque de connaissance et de formation.

Développement d'une application générant une fuite mémoire

Pour illustrer l'utilisation du profiler IntelliJ, je vous propose l'application Spring boot minimaliste suivante.

package com.onepoint.profiler;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import javax.crypto.NoSuchPaddingException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;

@SpringBootApplication
@EnableScheduling
public class ProfilerApplication {

    public static void main(String[] args) {

        SpringApplication.run(ProfilerApplication.class, args);

    }

}

@Service
class MemoryLeakService {

    // Liste statique pour maintenir des références inutilisées
    private static final List<byte[]> MEMORY_LEAK_LIST = new ArrayList<>();

    // Tâche planifiée pour simuler une fuite mémoire en continu
    @Scheduled(fixedRate = 2000) // Exécution toutes les 5 secondes
    public void simulateMemoryLeak() throws NoSuchPaddingException, NoSuchAlgorithmException {
        System.out.println("Ajout de blocs mémoire à la liste...");

        // FUITE MEMOIRE : Ajouter un bloc de 10 MB à chaque exécution
        byte[] memoryBlock = new byte[10 * 1024 * 1024];
        MEMORY_LEAK_LIST.add(memoryBlock);

        // Imprimer la taille actuelle de la liste
        System.out.println("Taille actuelle de MEMORY_LEAK_LIST : " + MEMORY_LEAK_LIST.size());
    }
}

Utilisation du profiler

Démarrer votre application.

La fenètre Run doit alors apparaitre.

Cliquer sur l'icone profiler qui ressemble a une gauge.

Vous devez voir apparaitre la liste des processus en cours.
Dans mon cas, mon application apparait en deuxième position.

Faire un clic droit sur la méthode. Puis choisir l'option "CPU and memory Live Charts".

Un graphe similaire au suivant doit apparaitre. La courbe "Heap Memory" augmente continuellement : on peut visualiser clairement la fuite mémoire.

Maintenant, nous savons que l'application génère une fuite mémoire sans savoir quelle ligne de code en est la cause.

Pour la rechercher, nous allons lancer le profiler en phase d'analyse :
Revenir sur l'onglet home du profiler.
Puis faire un clic droit sur le processus de l'application.
Puis choisir l'option "Attach Intellij Profiler".

La page suivante doit alors apparaitre. Patienter alors quelques minutes. Puis stopper le profiling.

Un onglet résultat doit apparaitre avec notamment un "Flame graph".

Basculer sur la vue show "Memory Allocations".

Sélectionner l'onglet "Call tree". La méthode posant problème apparait alors clairement car elle occupe 3,49 Go de mémoire.

Aller voir le code de la méthode : une flame rouge est apposée sur la ligne 38 placée volontairement pour générer une fuite mémoire.
! CQFD !

Cet exercice nous a permit de découvrir comment identifier une fuite mémoire dans une application Java.
Il peut également s'appliquer dans d'autres cas, comme en cas de surconsommation de CPU.

Conclusion

La JVM est le moteur central de vos applications Java, gérant automatiquement la mémoire et l'exécution des instructions. Tel un mécanisme de précision, chaque composant joue un rôle essentiel dans son fonctionnement optimal.

Bien que sophistiquée, ce moteur nécessite parfois des ajustements manuels. La configuration de la mémoire et l'optimisation du Garbage Collector s'apparentent à un travail de mécanique fine, où chaque réglage impacte les performances globales.

Les options de configuration et les logs sont vos outils de diagnostic, permettant d'identifier et résoudre les problèmes avant qu'ils n'affectent la production. Le profiler, quant à lui, agit comme la valise de diagnostic avancé, capable de détecter les anomalies les plus subtiles.

Maîtriser la JVM s'apparente ainsi au pilotage d'une voiture de course : au-delà de la vitesse, il faut comprendre ses réglages, anticiper sa maintenance et savoir utiliser les outils d'optimisation pour éviter les pannes. À vous de prendre les commandes !

Rappel pour choisir le bon collecteur

Pense-bête : les Garbage Collectors par cas d'usage

Objectif	Garbage Collector recommandé
Faible latence	ZGC ou Shenandoah
Débit élevé	Parallel GC
Équilibre latence/débit	G1 GC
Simplicité	Serial GC
Tests et benchmarks	Epsilon GC

Cet article fait partie du "Advent of Tech 2024 Onepoint", une série d'articles tech publiés par Onepoint pour patienter jusqu'à Noël.
Voir tous les articles du Advent of Tech 2024.

Merci de votre lecture.