Create And Deploy Java Ee 8 Apps On Docker And Kubernetes

Learn how to build, package, and deploy your Java EE 8 applications on Docker and Kubernetes

What you'll learn

Implement domain business logic using core Java EE components

Realize HTTP communication using JAX-RS

Configure enterprise applications using standard APIs

Package, distribute, and run applications in Docker containers

Install and configure containerized Java EE application servers

Deploy enterprise applications as Kubernetes pods, deployments, and services

Configure containerized and orchestrated applications

Requirements

Familiarity with Java is assumed.

Description

Java EE provides a standard set of specifications that can be used to develop standardized applications, independent of the vendor. Enterprise applications do not change that often, and hence we need a robust platform such as Java EE to ensure sustainability. A lot of enterprises migrate their runtime environments to platforms that are based on Docker and Kubernetes. Container technologies, in combination with orchestration, provide significant advantages in the way companies deploy and operate their enterprise software.


This comprehensive 2-in-1 course teaches you how to develop enterprise applications using the Java Enterprise platform and modern APIs. It covers each and every concept of the Java EE platform with the help of practical examples making it easy for you to understand and implement in your own applications. You will also learn to package and deploy Java EE 8 applications on Docker and Kubernetes.


This training program includes 2 complete courses, carefully chosen to give you the most comprehensive training possible.


The first course, Learning Java EE 8, course starts off by exploring the core Java EE components. You will then learn about HTTP endpoints. You will also learn how to map domain entities with JPA. Next, you will understand how interceptors realize technical cross-cutting concerns. You will learn to access external systems. Finally, you will learn about the asynchronous communication protocol.




The second course, Containerizing Java EE 8 Apps Using Docker and Kubernetes, begins with a practical approach to show you how you can use Docker in Java EE 8 and how to troubleshoot containers. You will then learn learn how to run Java EE in containers. You will also learn to configure containerized applications. Next, you will learn to orchestrate containers using Kubernetes. Finally, you’ll be able to integrate Java EE applications into Docker and Kubernetes.


By the end of this Learning Path, you'll be able to build, package, and deploy your Java EE 8 applications on Docker and Kubernetes.

Meet Your Expert(s):

We have the best work of the following esteemed author(s) to ensure that your learning journey is smooth:Sebastian Daschner is a Java freelancer working as a consultant, author, and a trainer. He is enthusiastic about programming and Java (EE). He is the author of the book Architecting Modern Java EE Applications. He participates in the JCP, helping to form the future standards of Java EE such as serving in the JAX-RS, JSON-P, and Config Expert Groups, and collaborating on various open source projects. For his contributions to the Java community and ecosystem, he was recognized as a Java Champion, Oracle Developer Champion, and double 2016 JavaOneRockstar. He is a regular speaker at international IT conferences such as JavaLand, JavaOne, or Jfokus.

Overview

Section 1: Learning Java EE 8

Lecture 1 The Course Overview

Lecture 2 Implementing domain business logic in Java EE

Lecture 3 EJBs and CDI managed beans

Lecture 4 CDI producers

Lecture 5 Qualifiers

Lecture 6 Scopes

Lecture 7 Events

Lecture 8 JAX-RS resources

Lecture 9 Integrating JSON-B

Lecture 10 Integrating JSON-P

Lecture 11 Custom HTTP responses

Lecture 12 Validating communication

Lecture 13 Exception handling

Lecture 14 Mapping domain entities with JPA

Lecture 15 Entity relations

Lecture 16 Datasources

Lecture 17 Transactions

Lecture 18 Interceptors

Lecture 19 Binding custom interceptors

Lecture 20 Configuring Java EE applications

Lecture 21 Caching

Lecture 22 Logging

Lecture 23 Asynchronous EJBs

Lecture 24 Asynchronous CDI events

Lecture 25 Managed threads

Lecture 26 Timers

Lecture 27 Asynchronous JAX-RS resources

Lecture 28 Accessing HTTP using JAX-RS

Lecture 29 Extended client usage

Lecture 30 Making HTTP clients resilient

Lecture 31 Asynchronous, reactive clients

Lecture 32 Implementing SSE resources with JAX-RS

Lecture 33 Server-sent event clients

Lecture 34 Implementing WebSocket server endpoints

Lecture 35 Accessing WebSocket endpoints

Section 2: Containerizing Java EE 8 Apps Using Docker and Kubernetes

Lecture 36 The Course Overview

Lecture 37 Starting Docker containers

Lecture 38 Life cycle of containers

Lecture 39 Images, tags & Dockerfiles

Lecture 40 Volumes

Lecture 41 Networking

Lecture 42 Distributing Docker images

Lecture 43 Troubleshooting containers

Lecture 44 Packaging Java EE applications

Lecture 45 Containerizing Java Enterprise

Lecture 46 Java in containers – challenges

Lecture 47 Leveraging Docker’s copy-on-write file system

Lecture 48 What to configure?

Lecture 49 Configuring dockerized application servers

Lecture 50 Configuring dockerized applications

Lecture 51 Communicating via Docker networks

Lecture 52 Deploying Docker images as Kubernetes pods

Lecture 53 Exposing pods via services and ingresses

Lecture 54 Kubernetes deployments

Lecture 55 Deploying applications with zero-downtime

Lecture 56 Example zero-downtime deployment

Lecture 57 Configuring environments using config maps and secrets

Lecture 58 Troubleshooting Kubernetes workloads

Lecture 59 Configuring enterprise applications in Kubernetes

Lecture 60 Managing application credentials

Lecture 61 Realizing persistence in Kubernetes

Lecture 62 Accessing services within clusters

Lecture 63 Defining workload resource limits

Lecture 64 Managing multiple application environments

This learning path targets software developers and architects who face the opportunity and challenge of creating and moving enterprise applications to modern, containerized environments. Developers who want to learn the nuts and bolts of putting applications into containers will also benefit from this course.