The complete guide to running Java in Docker and Kubernetes

Name: The complete guide to running Java in Docker and Kubernetes
Rating: 4.4 (152 reviews)

Running JVMs in containers, the hard bits explained! Everything you need to know to run containers in production

Last updated 5/2020

English

What you'll learn

8 sections • 31 lectures • 4h 38m total length

What is Docker13:16
Discover how Docker packages applications into portable, versioned containers that run on a single host, offering isolation and easy deployment with images, Dockerfile, and registries.
Installing Docker5:00
Docker components9:11
Learn to write a dockerfile, build a java image from openjdk, and run it as a container with an end-to-end demo, covering image versus container and key docker commands.

Introduction to images1:54
Picking a base image9:36
Choose a small, official base image to minimize build time, transfer time, and attack surface when shipping Java containers; compare OpenJDK and AdoptOpenJDK, and target Java 11 with slim variants.
JDK vs JRE base image5:45
Multi stage builds12:15
Master multi-stage docker builds to produce lean production images by building inside docker, copying artifacts between stages, and extracting tar files to keep the final image small.
JVM modules and JLink10:25
Graceful shutdown and handling signals14:59
Handling signals in containers6:03
Debugging inside containers7:58
Speeding up startup with Class Data Sharding (CDS)9:17
Going distroless: in search of smaller images9:19
Lightning fast containers with Ahead Of Time (AOT) compilation8:15
GraalVM native image introduction9:20
Explore GraalVM native image, an ahead-of-time compiler that creates small, fast Java binaries for Docker in a containerized environment, with caveats around dynamic reflection and startup benefits.
GraalVM multi stage builds7:34
Build GraalVM native images inside Docker with a two-stage workflow to produce small production binaries. Use a base image, copy the jar, and enable static linking for a seven-megabyte image.

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.

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:

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:

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

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.