EX378

Description de l'examen

L'examen Développeur cloud-native certifié Red Hat (EX378) teste vos compétences et connaissances en matière de création d'applications Java côté serveur à l'aide du framework Quarkus. L'examen 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 Développeur cloud-native certifié Red Hat, qui compte également pour l'obtention de la certification RHCA® (Architecte certifié Red Hat).

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 Développeur cloud-native certifié Red Hat :

• Développeurs Java qui mettent en œuvre des services à l'aide de Quarkus
• Développeurs qui développent tous types d'applications Java et 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 pour cet examen

• Avoir suivi le cours Développement de microservices cloud-native 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, y compris 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é)

Préparation

Points à étudier pour l'examen

Pour vous aider à vous préparer, la section Objectifs répertorie les types de tâches que vous serez amené à 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 devriez ê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, jauges, compteurs, résumés de distribution et 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

Utilisation des jetons JSON Web Token basés sur le dispositif OpenID Connect de MicroProfile Interoperable JWT RBAC dans les applications Quarkus 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
• 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 (OTel) 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 en une 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

Nous vous recommandons de suivre le cours Développement de microservices cloud-native Red Hat avec Quarkus (DO378) pour vous préparer. La participation à ce cours n'est pas obligatoire. Vous pouvez donc vous contenter de passer l'examen.

Bien que la participation aux cours Red Hat puisse jouer un rôle important dans la préparation à l'examen, elle ne garantit en aucun cas la réussite de celui-ci. Une expérience et une pratique préalables, ainsi qu'une aptitude innée, constituent d'autres facteurs importants.

De nombreux livres et d'autres ressources sur l'administration système des produits Red Hat sont disponibles. Il n'existe pas de documentation de préparation aux examens approuvée par Red Hat. Des lectures complémentaires peuvent cependant vous permettre d'approfondir le sujet.

Format de l'examen

L'examen Développeur cloud-native certifié Red Hat 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.

Résultats et communication des notes

Les notes officielles attribuées pour les examens proviennent exclusivement du Centre de certification Red Hat. Red Hat n'autorise pas les examinateurs ou les partenaires de formation à donner directement leurs résultats aux candidats. Les notes d'examen sont généralement communiquées sous trois (3) jours ouvrables (aux États-Unis) après l'examen.

Les résultats d'examen sont communiqués sous forme de notes globales. Red Hat ne communique pas les résultats sur des points particuliers et ne fournit pas non plus d'informations complémentaires sur demande.

Examens ou cours recommandés pour la suite :

Présentation des conteneurs, de Kubernetes et de Red Hat OpenShift (DO180)

Développement avec Red Hat OpenShift I : conteneurisation d'applications (DO288)

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