EX378

Exam description

The Red Hat Certified Cloud-Native Developer exam (EX378) tests your skills and knowledge with regard to coding the server side of Java applications using the Quarkus framework. The exam focuses on the basic skills required to create a complete microservice using a persistent data store.

By passing this exam, you become a Red Hat Certified Cloud-native Developer, which also counts toward earning a Red Hat Certified Architect (RHCA®) certification.

This exam is based on Red Hat Build of Quarkus v3.8.

Audience for this exam:

These audiences may be interested in becoming a Red Hat Certified Cloud-Native Developer:

• Java developers who are implementing services using Quarkus
• Developers who are developing any kind of Java applications and want to be more productive using a faster, dynamic and composable Java framework
• Red Hat Certified professionals who wish to pursue Red Hat Certified Architect (RHCA) certification

Prerequisites for this exam:

• Student should have taken the Red Hat Cloud-native Microservices Development with Quarkus (DO378) course or have comparable hands-on experience
• Familiarity with using Visual Code/VS Codium in a Red Hat Enterprise Linux environment
• Good experience with JSE, including a knowledge and understanding of the core Java concepts and APIs, is necessary for this exam.  For example, Exceptions, Annotations and the Collections API are all required during the exam
• Some familiarity with Openshift is beneficial but not required
• Some familiarity with Messaging and communication with Kafka is beneficial

In preparation

Study points for the exam

To help you prepare, these exam objectives highlight the task areas you can expect to see covered in the exam. Red Hat reserves the right to add, modify, and remove exam objectives. Such changes will be made public in advance.

You should be able to perform these tasks:

Provide and obtain configuration properties through several environment-aware sources made available through dependency injection or lookup

• Externalize data into configured values
• Inject configured values into beans using the @Inject and the @ConfigProperty qualifier
• Demonstrate ability to create and access a configuration mapping to a Java Object
• Understand the default ConfigSource ordering and how to extend the configuration support with custom ConfigSource
• Understand how to set custom configuration properties per target environment with Profiles

Build fault-tolerant Quarkus-based microservices using Microprofile Fault Tolerance strategies

• Understand the relationship to MicroProfile Config
• Understand async versus sync execution type
• Understand resilience using Timeouts
• Understand Retry policies and apply using @Retry annotation
• Understand and define Fallback strategy
• Understand and apply CircuitBreaker
• Understand and apply Bulkhead
• Understand and set up fault tolerance configuration

Probe the state of a Quarkus application from another machine using MicroProfile Health Check

• Understand and implement the HealthCheck interface
• Understand and apply @Startup, @Liveness and @Readiness annotation
• Understand and implement Reactive health checks
• Understand and implement HealthCheckResponse
• Construct human-friendly HealthCheckResponse
• Understand and use the Health UI
• Understand and apply Health Groups and the @HealthGroup annotation
• Understand and apply the @Wellness annotation

Observe, collect and measure data from a running Quarkus application using Micrometer Metrics

• Understand and use dimensional data aggregation with tags
• Understand and instrument the code with timers, gauges, counters, distribution summaries, and long task timers
• Understand micrometer annotations and the registry API
• Understand and use the exposed metrics via REST API
• Understand Quarkus application metrics programming model
• Understand how to export monitoring data to management agents

MicroProfile Interoperable JWT RBAC on Quarkus applications: OpenID Connect (OIDC)-based JSON Web Tokens(JWT) for role-based access control (RBAC) of microservice endpoints

• Understand token-based authentication
• Use JWT bearer tokens to protect services
• Mark a JAX-RS application as requiring MP-JWT access control
• Map MP-JWT tokens to Java EE container APIs

Implement a Quarkus application and expose RESTful service endpoints with Resteasy Reactive and Jakarta REST (formerly known as JAX-RS)

• Understand RESTful concepts, particularly the application and use of the HTTP PUT, DELETE, GET, and POST methods
• Know and use standard HTTP return codes and return response body
• Understand how to write JSON REST services with Quarkus
• Implement RESTful root resource class
• Expose a RESTful service using Jakarta REST (formerly known as JAX-RS)
• Understand and apply declaring endpoints: URI mapping and HTTP representation  and content types
• Understand and apply the async/reactive support to declare non-blocking endpoints
• Use CDI to integrate components
• Using bean validation to ensure data format and consistency

Simplified JPA mapping with Panache

• Understand the difference between the Active Record Pattern and the Repository Pattern
• Use basic JPA to create, read, update, and delete persistent objects and their relationships
• Map a bi-directional one-to-many relationship between two entities, including both sides of the association
• Demonstrate the ability to perform the most common Panache operations and add custom entity methods

Reactive messaging on Quakus applications

• Understand reactive programming
• Understand messaging core concept
• Understand Channels
• Understand Incoming and Outgoing
• Understand message acknowledgment

Microprofile OpenAPI specification to document RESTful APIs

• Understand OpenAPI documents and the Swagger UI to discover remote services APIs
• Demonstrate the ability to link to semantic versioning (semver) remote service endpoints
• Understand how to produce the default and custom OpenAPI document to JAX-RS endpoints

Interacting with REST APIs in Quarkus using the REST Client Reactive

• Understand the type-safe approach to invoke RESTful services over HTTP using the Jakarta REST And Microprofile annotations
• Understand REST concepts, particularly the application and use of the HTTP PUT, DELETE, GET, and POST methods
• Understand and use the non-blocking flavor of REST Client Reactive with async support
• Demonstrate the ability to create and use a REST client to connect with a remote service
• Parameterize and configure the REST client URI to invoke a specific remote microservice
• Understand and apply additional custom client headers to the client requests
• Demonstrate the ability to convert HTTP responses to handle exceptions
• Understand and use special additional client headers

Use OpenTelemetry (OTel) to instrument distributed tracing for interactive web applications

• Understand and implement distributed tracing across microservices using OpenTelemetry
• Demonstrate the ability to follow and understand the full path through your distributed application
• Understand the Tracer creates Spans and the Context Propagation assembled into a trace in the correlation identifiers
• Understand how contextual information is passed between Spans using the key-store Baggage

As with all Red Hat performance-based exams, configurations must persist after restart without intervention.

In preparation

Red Hat encourages you to consider taking Red Hat Cloud-native Microservices Development with Quarkus (DO378) to help you prepare. Attendance in these classes is not required; students can choose to take just the exam.

While attending Red Hat classes can be an important part of your preparation, attending class does not guarantee success on the exam. Previous experience, practice, and native aptitude are also important determinants of success.

Many books and other resources on system administration for Red Hat products are available. Red Hat does not endorse any of these materials as preparation guides for exams. Nevertheless, you may find additional reading helpful to deepen your understanding.

Exam format

The Red Hat Certified Cloud-Native Developer Exam is a hands-on, practical exam that requires you to undertake real-world tasks. Internet access is not provided during the exam, and you will not be permitted to bring any hard copy or electronic documentation into the exam. This prohibition includes notes, books, or any other materials. For most exams, the documentation that ships with the product is available during the exam.

Scores and reporting

Official scores for exams come exclusively from Red Hat Certification Central. Red Hat does not authorize examiners or training partners to report results to candidates directly. Scores on the exam are usually reported within 3 U.S. business days.

Exam results are reported as total scores. Red Hat does not report performance on individual items, nor will it provide additional information upon request.

Recommended next exams or courses:

Introduction to Containers, Kubernetes, and Red Hat OpenShift (DO180)

Red Hat OpenShift Development I: Containerizing Applications (DO288)

Building Resilient Microservices with Red Hat OpenShift Service Mesh (DO328)