EX378

Cet examen teste vos compétences et connaissances en matière de création d'applications Java côté serveur à l'aide du framework Quarkus. Il est axé sur les compétences de base requises pour créer un microservice complet à l'aide d'un magasin de données persistant.

Si vous réussissez cet examen, vous obtiendrez la certification Spécialiste certifié Red Hat en développement cloud-native, qui compte également pour l'obtention de la certification RHCA (Architecte certifié Red Hat) en applications cloud-native.

Cet examen repose sur la version Red Hat de Quarkus 3.8.

Public ciblé

Les personnes suivantes peuvent être intéressées par l'obtention de la certification Spécialiste certifié Red Hat en développement cloud-native :

• Développeurs Java qui mettent en œuvre des services à l'aide de Quarkus
• Développeurs de tous types d'applications Java qui souhaitent gagner en productivité à l'aide d'un framework Java plus rapide, dynamique et modulable
• Professionnels certifiés Red Hat qui cherchent à obtenir la certification RHCA (Architecte certifié Red Hat)

Prérequis

• Avoir suivi le cours Développement de microservices cloud-native de Red Hat avec Quarkus (DO378) ou disposer d'une expérience pratique similaire
• Savoir utiliser Visual Code/VSCodium dans un environnement Red Hat Enterprise Linux
• Avoir une bonne expérience de Java SE, notamment des connaissances et une bonne compréhension des principaux concepts et API Java  (il faudra par exemple utiliser des exceptions, des annotations et l'API Collections dans le cadre de l'examen)
• Connaître les bases d'OpenShift (recommandé)
• Connaître les bases de la messagerie et de la communication avec Kafka (recommandé)

Points à étudier pour l'examen

Pour vous préparer, passez en revue les objectifs suivants, qui répertorient les types de tâches que vous devrez effectuer au cours de l'examen. Red Hat se réserve le droit d'ajouter, de modifier ou de supprimer des objectifs pour tout examen. Ces modifications seront publiées à l'avance.

Vous devez être capable d'effectuer les tâches suivantes :

Mise à disposition et obtention des propriétés de configuration via différentes sources dépendantes de l'environnement rendues accessibles par une injection de dépendances ou une recherche

• Externaliser les données sous forme de valeurs configurées
• Injecter des valeurs configurées dans des beans en utilisant les qualificatifs @Inject et @ConfigProperty
• Être capable de créer une configuration pointant vers un objet Java et d'y accéder
• Comprendre la commande ConfigSource par défaut et comment étendre la prise en charge de la configuration à l'aide d'une commande ConfigSource personnalisée
• Comprendre comment définir des propriétés de configuration personnalisées par environnement cible avec les profils

Création de microservices basés sur Quarkus résistants aux pannes à l'aide de stratégies MicroProfile Fault Tolerance

• Comprendre la relation avec MicroProfile Config
• Comprendre les exécutions asynchrones et synchrones
• Comprendre la résilience à l'aide des délais d'attente
• Comprendre les stratégies de nouvelles tentatives et les appliquer en utilisant l'annotation @Retry
• Comprendre et définir Fallback
• Comprendre et appliquer CircuitBreaker
• Comprendre et appliquer Bulkhead
• Comprendre et paramétrer une configuration de tolérance aux pannes

Interrogation de l'état d'une application Quarkus depuis un autre ordinateur à l'aide de MicroProfile Health Check

• Comprendre et mettre en œuvre l'interface HealthCheck
• Comprendre et appliquer les annotations @Startup, @Liveness et @Readiness
• Comprendre et mettre en œuvre les contrôles d'intégrité réactifs
• Comprendre et mettre en œuvre HealthCheckResponse
• Créer une solution HealthCheckResponse compréhensible par un être humain
• Comprendre et utiliser l'interface utilisateur Health
• Comprendre et appliquer les groupes Health et l'annotation @HealthGroup
• Comprendre et appliquer l'annotation @Wellness

Observation, collecte et mesure des données d'une application Quarkus en cours d'exécution à l'aide des indicateurs de mesure Micrometer

• Comprendre et utiliser l'agrégation dimensionnelle des données à l'aide de balises
• Comprendre et instrumenter le code à l'aide de minuteurs, de jauges, de compteurs, de résumés de distribution et de minuteurs de tâches longues
• Comprendre les annotations Micrometer et l'API de registre
• Comprendre et utiliser les indicateurs de mesure exposés via l'API REST
• Comprendre le modèle de programmation des indicateurs de mesure d'application Quarkus
• Comprendre comment exporter des données de surveillance vers des agents de gestion 

MicroProfile Interoperable JWT RBAC dans les applications Quarkus : utilisation des jetons JSON Web Token basés sur le dispositif OpenID Connect pour le contrôle d'accès basé sur les rôles des points de terminaison de microservices

• Comprendre l'authentification par jeton
• Utiliser des jetons du porteur JWT pour protéger des services
• Indiquer qu'une application JAX-RS nécessite un contrôle d'accès MP-JWT
• Mettre en correspondance des jetons MP-JWT avec des API de conteneur Java EE

Mise en œuvre d'une application Quarkus et exposition des points de terminaison du service RESTful avec Resteasy Reactive et Jakarta REST (anciennement JAX-RS)

• Comprendre les concepts RESTful, en particulier l'application et l'utilisation des méthodes HTTP PUT, DELETE, GET et POST
• Connaître et utiliser les codes de réponse HTTP et le corps de réponse standards
• Comprendre comment écrire des services REST JSON avec Quarkus
• Mettre en œuvre une classe de ressources racine RESTful
• Exposer un service RESTful à l'aide de Jakarta REST (anciennement JAX-RS)
• Comprendre et appliquer les points de terminaison déclaratifs : mise en correspondance des URI, représentation HTTP et types de contenus
• Comprendre et appliquer la prise en charge asynchrone/réactive pour déclarer des points de terminaison non bloquants
• Utiliser CDI pour intégrer des composants
• Utiliser l'API Bean Validation pour vérifier le format et la cohérence des données

Mise en correspondance simplifiée de JPA avec Panache

• Comprendre la différence entre les modèles Active Record et Repository
• Utiliser les fonctions de base de JPA pour créer, lire, mettre à jour et supprimer des objets persistants et leurs relations
• Mapper une relation bidirectionnelle un-à-plusieurs entre deux entités, en incluant les deux côtés de l'association
• Être capable d'effectuer les opérations les plus courantes avec Panache et d'ajouter des méthodes d'entité personnalisées

Messagerie réactive sur les applications Quarkus

• Comprendre la programmation réactive
• Comprendre le concept de base de la messagerie
• Comprendre les canaux de distribution
• Comprendre le trafic entrant et sortant
• Comprendre les accusés de réception des messages

Utilisation de la spécification MicroProfile OpenAPI pour la documentation des API RESTful

• Comprendre la documentation OpenAPI et l'interface utilisateur Swagger pour découvrir les API de services distants
• Être capable de lier des points de terminaison de services distants à la gestion sémantique des versions (SemVer)
• Comprendre comment produire la documentation OpenAPI par défaut et personnalisée sur les points de terminaison JAX-RS

Interaction avec les API REST dans Quarkus à l'aide du client REST Reactive

• Comprendre l'approche sécurisée pour invoquer des services RESTful via HTTP à l'aide des annotations Jakarta REST et Microprofile
• Comprendre les concepts REST, en particulier l'application et l'utilisation des méthodes HTTP PUT, DELETE, GET et POST
• Comprendre et utiliser la variante non bloquante du client REST Reactive avec prise en charge asynchrone
• Être capable de créer et d'utiliser un client REST pour se connecter à un service distant
• Paramétrer et configurer l'URI d'un client REST pour invoquer un microservice distant spécifique
• Comprendre et appliquer des en-têtes de clients personnalisés supplémentaires aux requêtes des clients
• Être capable de convertir les réponses HTTP pour gérer les exceptions
• Comprendre et utiliser des en-têtes de clients spécifiques supplémentaires

Utilisation d'OpenTelemetry pour instrumenter le traçage distribué pour les applications web interactives

• Comprendre et mettre en œuvre le traçage distribué sur des microservices à l'aide d'OpenTelemetry
• Être capable de suivre et comprendre le chemin complet à travers une application distribuée
• Comprendre comment Tracer crée des intervalles et la propagation du contexte assemblés sous forme de trace dans les identifiants de corrélation
• Comprendre comment les informations contextuelles sont transmises entre des intervalles à l'aide du keystore Baggage

Comme pour tous les examens Red Hat basés sur les performances, les configurations doivent persister sans intervention après un redémarrage.

Préparation

Pour préparer cet examen, nous recommandons de suivre le cours Développement de microservices cloud-native de Red Hat avec Quarkus (DO378).

Format de l'examen

Consultez le guide du programme de certification Red Hat pour connaître toutes les politiques officielles et les procédures d'examen avant de réserver une session.

L'examen Spécialiste certifié Red Hat en développement cloud-native est un examen pratique qui requiert l'exécution de tâches concrètes. Vous n'avez pas le droit d'accéder à Internet pendant l'examen, ni d'amener de la documentation papier ou électronique. Les notes, livres et autres documents sont interdits. La documentation fournie avec le produit est mise à disposition pour la plupart des examens.

Examens ou cours recommandés pour la suite

Administration de Red Hat OpenShift I : exploitation d'un cluster de production (DO180)

Développement avec Red Hat OpenShift II : création et déploiement d'applications cloud-native (DO288)

Création de microservices résilients avec Istio et Red Hat OpenShift Service Mesh (DO328)