136 termes définis
Annotation JPA permettant de définir explicitement les relations à charger en une seule requête, évitant ainsi le problème N+1. Elle est utilisée pour optimiser les requêtes de chargement des entités.
Annotation hypothétique proposée pour JDK 26, permettant de marquer une exception checked comme optionnelle, c’est-à-dire ignorable sans wrapper.
Flag NodeJS qui force l’utilisation de l’ancien provider OpenSSL pour contourner les incompatibilités. Désactivé par défaut dans NodeJS 25.5.0.
Fonctionnalité de QUIC qui permet d’envoyer des données dès la première requête, sans attendre la fin du handshake, réduisant ainsi la latence.
Ensemble de règles et de processus visant à standardiser la conception des APIs dans Kubernetes, y compris les CRDs, pour éviter les conflits et les breaking changes.
Un composant générique qui orchestrer des workflows déclaratifs pour gérer des ressources Kubernetes, souvent piloté par des modèles de langage ou des moteurs de règles.
Un programme capable d’interagir avec une interface (ex : un navigateur) de manière autonome, souvent piloté par une IA.
Algorithmes cryptographiques considérés comme non sécurisés (ex : SHA1, MD5). Désactivés par défaut dans OpenSSL 3.x.
Un modèle dans Argo Rollouts qui définit des métriques et des seuils pour valider automatiquement un déploiement (ex : taux d’erreur < 1%). Si les métriques ne sont pas respectées, le déploiement est interrompu.
Une ressource ArgoCD qui permet de déployer automatiquement des Applications sur plusieurs clusters ou environnements, en utilisant des générateurs (ex: liste de clusters, Git files).
Un opérateur Kubernetes qui étend les stratégies de déploiement (blue-green, canary) et s’intègre avec ArgoCD pour des déploiements progressifs et contrôlés.
Composant léger déployé sur chaque cluster Kubernetes qui se connecte à un serveur ArgoCD central pour synchroniser les manifests, éliminant le besoin d'instances ArgoCD complètes sur chaque cluster.
Syntaxe permettant d'itérer sur des objets asynchrones (comme les streams) avec une boucle `for await...of`, simplifiant la gestion des flux de données.
Mécanisme qui permet à un stream consommateur de signaler à un stream producteur qu'il ne peut plus traiter les données aussi vite qu'elles sont générées, évitant ainsi une surcharge mémoire.
Code répétitif et peu expressif, souvent nécessaire pour respecter des contraintes du langage, mais qui n’apporte pas de valeur métier.
Modification d’une API qui casse la compatibilité avec les versions précédentes, entraînant des erreurs ou des dysfonctionnements dans les workloads.
Un espace mémoire temporaire utilisé par Node.js pour stocker des données binaires. Les streams manipulent souvent des buffers pour traiter les données par morceaux.
Technique consistant à regrouper plusieurs modules ou outils JavaScript en un seul fichier optimisé pour une exécution côté serveur, améliorant les performances et la maintenabilité.
Mécanisme de sécurité des navigateurs qui contrôle les requêtes HTTP cross-origin. Configurable dans NestJS via `app.enableCors()`.
Un mécanisme Kubernetes qui permet de définir des types de ressources personnalisées, étendant ainsi les fonctionnalités natives du cluster.
Un algorithme de cryptographie post-quantique, sélectionné par le NIST pour résister aux attaques des ordinateurs quantiques. Il sera intégré dans Java 27.
Mécanisme où chaque agent ArgoCD maintient une copie locale des manifests, permettant des synchronisations même en cas de perte de connectivité avec le serveur central.
Phénomène où plusieurs requêtes tentent de régénérer la même entrée de cache simultanément après son expiration, provoquant une surcharge de la base de données.
Technique permettant d’associer des tags à des entrées de cache pour les invalider de manière groupée (ex : invalider toutes les entrées liées à un utilisateur).
Un anti-pattern où les callbacks sont imbriqués les uns dans les autres, rendant le code illisible et difficile à maintenir. Résolu par les promesses et les streams.
Une stratégie de déploiement où une nouvelle version d’une application est déployée progressivement à un sous-ensemble d’utilisateurs avant une bascule complète. Permet de détecter les régressions avant qu’elles n’impactent tous les utilisateurs.
Type d’exceptions en Java qui doivent être déclarées dans la signature d’une méthode ou capturées avec un bloc `try-catch`. Exemples : `IOException`, `SQLException`.
L'approche traditionnelle où le client (ex: `kubectl` ou ArgoCD) fusionne les champs localement avant d'envoyer une requête au serveur Kubernetes. CSA est moins fiable que SSA pour les ressources complexes ou multi-acteurs.
Un projet Kubernetes qui permet de gérer le cycle de vie des clusters (création, mise à jour, suppression) de manière déclarative, comme on gère des Pods avec des Deployments.
Un critère personnalisé (ex : pilote GPU chargé, daemon CNI opérationnel) qui doit être satisfait pour qu’un nœud soit considéré comme prêt à accueillir des workloads.
Technique qui consiste à isoler une application et ses dépendances dans un conteneur (ex : Docker) pour éviter les conflits de version ou d’environnement.
Mécanisme où le client et le serveur négocient le format des données échangées (ex : JSON vs TOON) via des en-têtes HTTP comme `Accept`.
Outil de signature et vérification d’images conteneurisées pour garantir leur authenticité.
Mécanisme permettant d’étendre l’API Kubernetes pour ajouter de nouveaux types de ressources personnalisées, comme des opérateurs ou des configurations spécifiques.
La deuxième version du système de contrôle des groupes (cgroups) dans Linux, qui gère l’allocation des ressources (CPU, mémoire) pour les conteneurs. Kubernetes a adapté ses mécanismes pour mieux supporter cette version.
Une pratique consistant à verrouiller les versions exactes des dépendances dans un projet (via `package-lock.json` ou `yarn.lock`) pour éviter les mises à jour non contrôlées qui pourraient introduire des vulnérabilités.
Processus de génération de documentation à partir du code source, souvent intégré dans les pipelines CI/CD pour garantir sa fraîcheur et sa précision.
Un mode de déploiement qui permet de valider une configuration sans l’appliquer réellement, utile pour tester des changements sans risque.
Outil ultra-rapide de bundling et de minification pour JavaScript et TypeScript, devenu un standard pour le bundling backend en 2026.
Pattern architectural où chaque changement d'état est enregistré comme un événement immuable. Cela permet de reconstruire l'état à tout moment et offre une auditabilité complète, mais ajoute de la complexité.
Outil open-source de sécurité runtime pour Kubernetes qui surveille les appels système et détecte les comportements anormaux en temps réel.
Adaptateur NestJS pour utiliser Fastify comme serveur HTTP au lieu d'Express. Offre de meilleures performances pour les APIs avec gros payloads ou streaming.
Un mécanisme Kubernetes qui permet à un contrôleur de retarder la suppression d'une ressource jusqu'à ce que certaines conditions soient remplies (ex: nettoyage des ressources dépendantes). Les finalizers peuvent bloquer la suppression des namespaces ou des ressources.
Une visualisation qui montre où le CPU passe son temps dans une application, permettant d'identifier rapidement les goulots d'étranglement.
Un collecteur de mémoire moderne pour la JVM, optimisé pour les applications nécessitant une faible latence (ex : systèmes financiers ou jeux en ligne).
Composant du runtime qui libère automatiquement la mémoire allouée aux objets qui ne sont plus utilisés par le programme.
Un ensemble de CRDs (Custom Resource Definitions) pour gérer le routage réseau dans Kubernetes, remplaçant progressivement Ingress. Il sépare les responsabilités (ex : infrastructure réseau vs routage des requêtes).
Une méthodologie où Git est utilisé comme source unique de vérité pour l’état souhaité des infrastructures. Les outils comme ArgoCD synchronisent automatiquement les clusters avec l’état défini dans Git.
Framework de communication inter-services utilisant HTTP/2 et Protocol Buffers pour réduire la latence et la taille des payloads. Il supporte le streaming bidirectionnel et est particulièrement adapté aux architectures microservices.
La troisième version du protocole HTTP, conçue pour fonctionner au-dessus de QUIC. HTTP/3 réduit la latence, gère mieux les réseaux instables, et évite les problèmes de "head-of-line blocking" présents en HTTP/2.
Un score attribué par la plateforme HackerOne pour évaluer la qualité d’un rapport de vulnérabilité. Il prend en compte la clarté, la reproductibilité et l’impact du signalement.
Problème où un paquet perdu dans un flux TCP bloque tous les autres flux multiplexés sur la même connexion. QUIC l’élimine en gérant chaque flux indépendamment.
Règle définie dans ArgoCD pour vérifier que une application est fonctionnelle au-delà de l’application des manifests.
Job Kubernetes exécuté avant ou après une synchronisation ArgoCD, versionné dans Git.
Un composant Kubernetes qui ajuste automatiquement le nombre de pods d’un déploiement en fonction de métriques comme l’utilisation CPU ou le nombre de requêtes par seconde. Essentiel pour gérer les pics de trafic des serveurs MCP.
API standard de Java pour effectuer des requêtes HTTP, désormais compatible avec HTTP/3 via QUIC. Introduit en Java 11, il a été étendu pour supporter UDP en Java 26.
Propriété d’une opération qui produit le même résultat qu’elle soit exécutée une ou plusieurs fois. Essentielle pour les APIs exposées à des clients externes.
Une fonctionnalité de Cluster API v1.12 qui permet de mettre à jour les nœuds d’un cluster Kubernetes sans les recréer, réduisant ainsi les downtimes.
Une ressource Kubernetes qui gère l’accès externe aux services dans un cluster, souvent couplée à un contrôleur comme l’AWS Load Balancer Controller pour créer des load balancers cloud.
Une ressource Kubernetes qui définit le type de contrôleur d’ingress à utiliser (comme AWS ALB ou NGINX), remplaçant les annotations obsolètes pour une meilleure portabilité.
Technique de cache qui invalide uniquement les entrées concernées par une mise à jour (via des tags ou des métadonnées).
Document formel décrivant une proposition d’amélioration pour Java, soumis au Java Community Process (JCP) pour validation.
Technique utilisée dans les reconnexions réseau pour éviter les tempêtes de reconnexion. Ajoute un délai aléatoire aux tentatives de reconnexion pour lisser la charge sur le serveur.
Un wrapper SQL léger pour NestJS qui permet d'écrire du SQL natif et d'intégrer des abonnements en temps réel sans configuration externe.
Un framework open source pour déployer et gérer des agents Kubernetes, souvent utilisé pour prototyper des workflows déclaratifs.
Une distribution Kubernetes légère, optimisée pour les environnements edge, IoT ou les workloads simples, avec une empreinte mémoire réduite.
Bibliothèque et ensemble d’outils pour valider et manipuler les APIs Kubernetes, intégrant désormais des vérifications de conformité aux règles d’API Governance.
Outil officiel de Kubernetes pour générer des CRDs et des contrôleurs conformes aux bonnes pratiques, y compris les nouvelles règles d’API Governance.
Fonctions anonymes introduites en Java 8, permettant d’écrire du code plus concis et fonctionnel. Exemple : `(x) -> x + 1`.
Une librairie JavaScript pour construire des workflows IA complexes en orchestrant des enchaînements de tâches entre plusieurs outils (NestJS, Python, APIs externes, etc.). Elle permet de modéliser ces workflows sous forme de graphes exécutables.
Anciennes interfaces de programmation qui utilisent des callbacks et ne bénéficient pas des optimisations modernes comme les promesses ou les streams.
Mécanisme Kubernetes permettant de vérifier si un conteneur est en cours d'exécution. Si la sonde échoue, Kubernetes redémarre automatiquement le conteneur.
Protocole ouvert développé par Anthropic pour connecter des outils externes (APIs, bases de données, etc.) aux assistants IA. Standardise les intégrations backend et permet de nouveaux modèles de monétisation.
Un champ dans les ressources Kubernetes qui suit quels acteurs (ex: ArgoCD, un contrôleur) modifient quels champs. Utilisé par SSA pour gérer les conflits et les permissions.
File d'attente prioritaire dans Node.js qui traite les opérations asynchrones critiques (comme les promesses) avant les callbacks classiques, améliorant la réactivité.
Outil permettant de déployer un cluster Kubernetes localement sur une machine de développement. Utilisé pour tester et valider des applications avant leur déploiement en production.
Un standard ouvert développé par Anthropic pour permettre aux assistants IA de se connecter à des outils externes (comme des serveurs NestJS) via des appels HTTP standardisés. Il transforme les serveurs backend en « plugins » pour agents conversationnels.
Un dépôt de code unique contenant plusieurs projets ou packages interdépendants, géré avec des outils comme `npm workspaces` ou `pnpm`.
Un projet CNCF qui vise à intégrer les agents dans l’écosystème Kubernetes, permettant une gestion unifiée des workloads sur plusieurs clusters.
Technique Docker qui permet de créer des images légères en séparant les étapes de build (ex : compilation) et d'exécution (ex : runtime).
Paramètre qui limite la taille du buffer utilisé par un microservice NestJS pour stocker les messages en attente de traitement. Une valeur trop élevée peut provoquer des crashes mémoire.
Un gestionnaire de paquets dédié aux serveurs MCP. Il permet de versionner, configurer et surveiller les outils MCP comme des dépendances npm, évitant ainsi la gestion manuelle des fichiers JSON.
Implémentation expérimentale de QUIC pour le framework Netty, utilisée par des frameworks comme Quarkus pour supporter HTTP/3.
Un contrôleur Kubernetes qui gère dynamiquement les taints des nœuds en fonction de conditions de readiness personnalisées, évitant ainsi le scheduling de pods sur des nœuds non entièrement opérationnels.
Erreur Kubernetes qui se produit quand un pod dépasse sa limite de mémoire et est tué par le système pour éviter de saturer le nœud.
Outil qui transforme automatiquement un dépôt GitHub en documentation, diagrammes et présentations, en analysant le code de manière sémantique.
Version majeure d’OpenSSL qui introduit un nouveau système de providers et déprécie certains algorithmes legacy. Intégrée dans NodeJS 25.5.0, elle peut casser des applications qui dépendent de ces algorithmes.
Un framework open source pour instrumenter, générer et exporter des données de télémétrie (traces, métriques, logs) afin d'analyser les performances et le comportement des applications.
Un contrôleur custom écrit en Go qui étend l’API Kubernetes pour gérer des ressources spécifiques (ex : bases de données, caches).
Modèle de connexion où les clients (ici les agents) initient la connexion vers le serveur, contrairement au modèle classique où le serveur doit pouvoir joindre les clients. Élimine les problèmes de firewall et NAT traversal.
Une fonctionnalité Java qui permet de vérifier le type d’un objet et d’extraire ses valeurs en une seule expression, réduisant ainsi le *boilerplate* (ex : `case Integer i -> ...`).
Une fonction qui compose plusieurs streams ensemble, gérant automatiquement les erreurs et la fermeture des flux. Permet de créer des chaînes de traitement de données efficaces.
Suite automatisée de processus (build, test, déploiement) qui s'exécute à chaque modification du code, intégrant désormais des étapes comme la génération de documentation et l'analyse de bundles.
Un mécanisme Kubernetes (déprécié en faveur des Pod Security Admission) pour contrôler les paramètres de sécurité des pods, comme l’exécution en root.
Problème de performance courant dans les applications ORM (ex : JPA/Hibernate) où une requête initiale (1) déclenche N requêtes supplémentaires pour charger les relations, entraînant une explosion du nombre de requêtes et une latence élevée.
Projet OpenJDK visant à introduire des améliorations incrémentales au langage Java, comme les patterns matching, les records, ou les sealed classes.
Un projet OpenJDK visant à introduire des *virtual threads* (threads légers gérés par la JVM) pour simplifier la programmation concurrente, notamment pour les applications I/O-bound.
Format de sérialisation binaire développé par Google, utilisé dans NestJS pour les communications entre microservices. Plus efficace que JSON pour les gros volumes de données.
Une vulnérabilité JavaScript où un attaquant modifie le prototype d’un objet natif (comme `Object` ou `Array`), ce qui peut entraîner des comportements inattendus ou des exécutions de code arbitraire.
Système modulaire introduit dans OpenSSL 3.x qui permet d’activer ou désactiver dynamiquement des algorithmes cryptographiques. Remplace l’ancien système monolithique.
Un modèle économique où des suggestions ou liens publicitaires sont intégrés aux réponses des outils MCP. Adapté aux serveurs appelés par des agents IA, où les modèles SaaS traditionnels ne s’appliquent pas.
Un protocole de transport basé sur UDP, conçu pour réduire la latence et améliorer la résilience des connexions réseau. QUIC intègre nativement le chiffrement (TLS 1.3) et est utilisé par HTTP/3.
Niveau de fiabilité pour la livraison des messages dans les protocoles comme MQTT. QoS 0 = "au mieux", QoS 1 = "au moins une fois", QoS 2 = "exactement une fois".
Modèle de gestion des permissions où les règles d'accès sont définies au niveau d'un serveur central plutôt que localement sur chaque instance. Permet une gouvernance unifiée des accès dans les architectures distribuées.
Mécanisme de limitation de requêtes qui ajuste dynamiquement les seuils en fonction du comportement du client.
Une boîte à outils modulaire pour NestJS qui centralise les opérations Redis (cache, locks, rate limiting) sur une seule connexion, avec des fonctionnalités avancées comme la protection contre le cache stampede.
Une CRD de Gateway API qui contrôle les accès entre namespaces, permettant à un `HTTPRoute` d’un namespace d’accéder à un service dans un autre namespace.
Un objet Kubernetes qui limite la quantité de ressources (CPU, mémoire) qu’un namespace peut consommer, évitant ainsi les surutilisations.
Standard de sécurité garantissant l’intégrité et la provenance des artefacts logiciels via des attestations signées.
Une technique d’isolation qui limite les ressources accessibles à un processus (fichiers, réseau, mémoire). Utilisée pour contenir les effets d’une vulnérabilité exploitée.
Une fonctionnalité expérimentale (introduite dans Java 20+) permettant de partager des valeurs immuables entre threads de manière sûre et efficace, sans utiliser de variables statiques ou de *ThreadLocal*.
Un outil qui permet de chiffrer des secrets Kubernetes pour les stocker en toute sécurité dans Git, puis de les déchiffrer au runtime dans le cluster.
Une fonctionnalité d’ArgoCD qui détecte et corrige automatiquement les divergences entre l’état d’un cluster et l’état Git, sans intervention humaine.
Pratique consistant à héberger et gérer soi-même des composants logiciels (APIs, services, etc.) plutôt que de dépendre de solutions SaaS externes. Permet un meilleur contrôle des coûts et des données.
Une méthode d’application des manifests Kubernetes où c’est le serveur (API Kubernetes) qui gère les mises à jour des champs, réduisant les conflits et améliorant la traçabilité.
Une méthode de synchronisation dans Kubernetes où le serveur API gère les conflits et les permissions, plutôt que le client. SSA améliore la fiabilité des déploiements en évitant les écrasements de champs et les finalizers bloquants.
Plugin Maven qui génère automatiquement une stack Spring Boot complète (entités, repositories, services, contrôleurs, tests) à partir d’une spécification YAML ou JSON.
Une stratégie de cache qui permet de servir des données obsolètes pendant une fenêtre de temps tout en les rafraîchissant en arrière-plan.
Ressource Kubernetes utilisée pour gérer des applications stateful (ex : bases de données) en garantissant un ordre de déploiement et des identifiants stables pour les pods.
Un flux de données traité par morceaux, permettant de lire ou écrire des données sans les charger entièrement en mémoire. Essentiel pour les opérations I/O lourdes dans Node.js.
Format de données compact conçu pour réduire le nombre de tokens dans les réponses API, idéal pour les appels LLM.
Un format de sérialisation compact pour les APIs, réduisant la taille des réponses de 30 à 60 % par rapport au JSON, ce qui permet de réduire les coûts des appels aux APIs LLM.
Un mécanisme Kubernetes qui permet de marquer un nœud pour empêcher le scheduling de certains pods, sauf si ceux-ci tolèrent explicitement le taint.
Ensemble d’outils open source qui visualisent en temps réel les étapes de compilation Java (tokenization, parsing, analyse sémantique), utile pour déboguer des problèmes complexes.
Mécanisme introduit dans le JDK 21 permettant de gérer des centaines de milliers de tâches concurrentes sans les coûts mémoire et CPU des threads natifs. Ils simplifient la programmation concurrente en évitant les pools de threads complexes.
Un mécanisme introduit en Java pour gérer des centaines de milliers de tâches concurrentes avec une empreinte mémoire minimale, en évitant la création coûteuse de threads système.
Problème où plusieurs requêtes simultanées tentent de reconstruire la même entrée de cache après son expiration, provoquant une surcharge du système.
Temps écoulé entre l’envoi d’une requête HTTP et la réception du premier octet de la réponse. HTTP/3 réduit significativement ce délai grâce à QUIC.
Un type de stream qui modifie les données qui le traversent (ex: conversion JSON, compression). Utilisé pour créer des pipelines de traitement.
Un format standardisé pour décrire l’exploitabilité d’une vulnérabilité, son impact, et les correctifs disponibles. Il facilite la communication entre les mainteneurs et les utilisateurs de logiciels.
Une API introduite en Java 9 pour accéder et manipuler des variables de manière sûre et performante, en remplacement des méthodes dépréciées de `sun.misc.Unsafe`.
Un outil open-source pour sauvegarder et restaurer les ressources Kubernetes, y compris les données persistantes, utile pour le disaster recovery.
Un outil Kubernetes qui ajuste automatiquement les requests et limits de CPU/mémoire des pods en fonction de leur utilisation réelle.
Mécanisme permettant à une application d'envoyer des données en temps réel à une autre application via une requête HTTP. Souvent utilisé pour les notifications ou les intégrations d'APIs.
Un fichier YAML ou JSON qui décrit une séquence d’actions à exécuter par un agent, sans nécessiter de code impératif.
Un garbage collector low-latency introduit en Java 11, optimisé pour les applications avec des heaps de grande taille. Java 26 active son mode générationnel par défaut.
