The complete guide to running Java in Docker and Kubernetes
4.7 (9 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
77 students enrolled

The complete guide to running Java in Docker and Kubernetes

Running JVMs in containers, the hard bits explained! Everything you need to know to run containers in production
4.7 (9 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
77 students enrolled
Created by Christopher Batey
Last updated 5/2020
English
English [Auto]
Current price: $16.99 Original price: $24.99 Discount: 32% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 4.5 hours on-demand video
  • 1 downloadable resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • In depth knowledge of how Java works in a Container
  • Kubernetes & Docker
  • Containers in depth: Linux cgroups & namespaces
  • How to build a production-quality Docker image for JVM applications
Course content
Expand all 31 lectures 04:38:45
+ Docker for Java developers
3 lectures 27:27
Installing Docker
05:00
Docker components
09:11
+ Containers in depth
4 lectures 54:08
Introduction to namespaces and cgroups
14:15
Container CPU quota
12:50
Container memory
12:05
+ Kubernetes
7 lectures 01:03:25
Kubernetes introduction
16:21
Installing minikube
08:07
Running the samples in Kubernetes
13:03
Kubernetes resources
05:57
Memory in Kubernetes
03:27
Liveness, readiness, and rolling deployments
07:53
+ Production-ready Java images
13 lectures 01:52:40
Picking a base image
09:36
JDK vs JRE base image
05:45
Multi stage builds
12:15
Graceful shutdown and handling signals
14:59
Handling signals in containers
06:03
Debugging inside containers
07:58
Speeding up startup with Class Data Sharding (CDS)
09:17
Lightning fast containers with Ahead Of Time (AOT) compilation
08:15
GraalVM native image introduction
09:20
GraalVM multi stage builds
07:34
+ Conclusion
1 lecture 00:49
Questions and feedback
00:49
Requirements
  • Basic Java is helpful but not mandatory. This course is applicable to any JVM language (Scala, Kotlin, Groovy, Clojure) though the samples are in Java.
Description

If you need to learn how to run, tune, and maintain JVM applications that run in Docker and/or Kubernetes then this is the course for you.

This course is very different from other Java/Docker/Kubernetes courses. It focuses on all the skills that you need to succeed in production.

All of the examples are in Java but the content is applicable for any JVM language including Scala, Groovy, and Kotlin.

We'll start with introductions for Docker and Kubernetes then we'll get into the fun stuff. We'll learn:

  • What a container is under the covers

  • Linux cgroups

  • Linux namespaces

Then we will go into how the JVM and your Java application behave differently in Kubernetes when running inside cgroups and namespaces. We'll cover:

  • JVM ergonomics

  • How CPU Shares and Quota work

  • How Kubernetes manages CPU and Memory

Then we will teach you all the techniques needed to build production-ready images:

  • Selecting a base image

  • JDK vs JRE based images

  • Multi-stage Docker builds

  • GraalVM

  • Class data sharing

  • Ahead of time compilation

We will experiment with different JVM versions and settings.

By the end of this course you'll know how to:

  • Build a production-ready image

  • Select between using CPU limits, quotas, or both in Kubernetes

  • Select memory limits and tune the JVM for running in Kubernetes

  • Understand CPU usage in Kubernetes and know why it is different to VMs and physical machines.



Who this course is for:
  • JVM developers interested in understanding how the JVM behaves in a container
  • Java developers using Docker
  • Java developers using Kubernetes
  • JVM developers using containers