Red Hat Cloud-native Microservices Development with Quarkus e-Learning

Red Hat DO378R Certification

Learn to develop micro service-based applications with Quarkus and Open Shift through the 40-hour/90-day Red Hat Cloud-native Microservices Development eLearning course. Our accredited trainers cover all the relevant aspects while preparing you for the Red Hat Cloud-Native Developer credential.


  210 Ratings

               520 Participants

Group Discount

Upto 15% OFF

Highly Experienced Trainers

Course Designed According To Requirements

Post Training Assistance

Customized training

Red Hat (DO378R) Cloud-native Microservices Development Course Overview

Vinsys' authorized Red Hat eLearning course explains architectural principles and enables you to implement microservices based on Quarkus/OpenShift. In addition, it allows you to build on your application development fundamentals while focusing on developing, monitoring, testing, and deploying modern microservices applications.

Our in-depth Cloud-native Microservices training also prepares you for the EX378 exam necessary for securing Red Hat's Cloud-Native Developer certification. 

Course Curriculum

Course Objectives

  • Deploying microservice applications on Red Hat® OpenShift Container Platform.
  • Building a microservice application with Quarkus.
  • Implementing unit/integration tests for microservices.
  • Using the config specification for injecting data into a microservice.
  • Securing a microservice using OAuth.
  • Implementing health checks, tracing, and monitoring of microservices.
  • Building and deploying native Quarkus applications.


  • Java Application Developers.
  • Individuals willing to complete the Red Hat Cloud-Native Developer accreditation. 


  • Application development experience, or should have attended the AD183 Red Hat Application Development I Programming in Java EE training. 
  • Proficiency in using IDEs like Red Hat Developer Studio or VSCode.
  • Recommended: Experiences with Maven, version control & OpenShift (or DO101 Introduction to OpenShift Applications).  

About the Exam

Exam:                           EX378.                       

Skills Tested:                Coding the Server Side of Kubernetes-native Java Apps  using the Quarkus Framework.                     

Certification Awarded:  The Red Hat Cloud-Native Developer.

Exam Format:               Hands-on Practical Testing of Real-world Tasks.                                          

Internet Access:            Not Provided. 

Hard Copies:                Prohibited. 

Duration:                       3 Hours. 

Cost:                             $400 (Region-specific).

Read More..

Get in touch

By providing your contact details, you agree to our Privacy policy

Training Options


Virtual Instructor-led Sessions

  • Instructor led Online Training
  • Experienced Subject Matter Experts
  • Approved and Quality Ensured training Material
  • 24*7 learner assistance and support


Virtual Instructor-led Sessions

  • Customized Training Across Various Domains
  • Instructor Led Skill Development Program
  • Ensure Maximum ROI for Corporates
  • 24*7 Learner Assistance and Support

Course Outline

  • Explaining the components and patterns of microservice-based application architectures.
  • Describing the specifications in Quarkus.
  • Implementing a microservice with some of the specifications and deploying it to an OpenShift cluster.
  • Deploying Quarkus microservices to a Red Hat OpenShift cluster.
  • Building a persistent/configurable distributed quarkus microservices application.
  • Implementing fault tolerance in a microservice architecture.
  • Explaining Quarkus in native mode.
  • Describing its deployment on the OpenShift Container Platform.
  • Implementing unit and integration tests for microservices.
  • Creating a health check for a microservice.
  • Securing microservice endpoints and communication.
  • Monitoring the operation of a microservice using metrics and distributed tracing.

Course Reviews


Quarkus is a new technology appropriate for enterprises looking to take advantage of cloud-native architectures. It provides reliability, familiarity, and maturity of Java Enterprise with a container-ready fast deployment time.

Quarkus helps developers in quickly building/testing/deploying their applications and improving the application time-to-market.

A large number of organizations wish to move from monolithic applications to those based on microservices and reorganize their development paradigm to utilize the benefits of microservice development in a DevOps economy. At the same time, many are invested in the familiarity of Java frameworks and the stability/benefits of Red Hat's OpenShift Container platform. 

The DO378R online training leads to the efficient building, testing, and deploying of applications. Moreover, it facilitates leveraging microservice application development with Quarkus for streamlining deployment on OpenShift clusters.

Yes, the Red Hat course enhances your professional capabilities for:

  • Designing a microservices-based architecture for an enterprise application.
  • Quickly building/testing microservices with Quarkus and deploying them to OpenShift Container Platform.
  • Implementing fault tolerance and health checks for microservices.
  • Securing microservices to prevent unauthorized access.
  • Monitoring/Tracing microservices.

Internet access is a must.

The exam tests your abilities to perform the following tasks:

  • Providing/Obtaining Configuration Properties via Environment-aware Sources Made Available through Dependency Injection or Lookup
    • Externalize data into configured values.
    • Inject configured values into beans using the Inject/ConfigProperty qualifier.
    • Access/Create a configuration.
    • Understand default/custom ConfigSource and ConfigSource ordering.
  • Building Fault-tolerant Quarkus-based Microservices using Microprofile Fault Tolerance Strategies
    • Understand the relationship to MicroProfile Config.
    • Async/Sync execution types.
    • Use Timeout.
    • Understand Retry policies and apply using Retry.
    • Define Fallback.
    • Understand/Apply CircuitBreaker and Bulkhead.
    • Understand/Set up fault tolerance configuration.
  • Probing the State of a Quarkus Application from Another Machine using MicroProfile Health Check
    • Understand/Implement the HealthCheck interface.
    • Apply Liveness and Readiness annotation.
    • Understand HealthCheckResponse.
    • Construct human-friendly HealthCheckResponse.
  • Exporting Monitoring Data to Management Agents from a Running Quarkus Application using Microprofile Metrics
    • Understand/Use three sets of sub-resource (scopes): Base, vendor, and application.
    • Tags (labels).
    • Metadata.
    • Metric registry and @Metric.
    • Expose metrics via REST API.
    • Know required metrics.
    • Understand the Quarkus application metrics programming model.
  • MicroProfiling 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.
  • Implementing a Quarkus Application & Exposing REST Service Endpoints with JAX-RS
    • Understand REST concepts and the application/use of HTTP PUT, DELETE, GET, and POST methods.
    • Know/Use standard HTTP return codes.
    • Implement RESTful root resource class.
    • Expose a REST service using JAX-RS.
    • Understand/Use @Path, Produce, and Consume.
    • Use CDI to integrate components.
    • Bean validation to ensure data format and consistency.
  • Simplifying JPA Mapping with Panache
    • Understand the difference between the Active Record Pattern and the Repository Pattern.
    • Use basic JPA to create/read/update/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.
  • Microprofiling 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 remote service endpoints.
    • Understand producing default/custom OpenAPI documents to JAX-RS endpoints.
  • Interacting with REST APIs in Quarkus using the MicroProfile REST Client
    • Understand the type-safe approach to invoke RESTful services over HTTP using the JAX-RS APIs.
    • The REST concepts and the application/use of HTTP PUT, DELETE, GET, and POST methods.
    • Demonstrate the ability to create/use a REST client to connect with a remote service.
    • Parameterize/Configure the REST client URI to invoke a specific remote microservice.
    • Understand/Use special additional client headers.

It also counts towards achieving the Red Hat Certified Architect (RHCA®) accreditation. 

As Red Hat training partners are not permitted to reveal results to candidates directly, you will receive your official EX378 exam scores from the Red Hat Certification Central portal. 

Besides being a globally-respected Individual/Corporate IT training provider, Vinsys is also admired as the top Red Hat eLearning partner. Its unmatchable offerings, accredited course content, customizable skilling programs, and round-the-clock learner support ensure the most detailed upskilling experiences, a must for capitalizing on valuable cloud-native architecture opportunities.