DevNation Deep Dive Menu

Edson Yanaga
Lead, Red Hat Developer Experience
yanaga@redhat.com
Deep Dives
● 1-hour sessions on developer
technologies delivered by
Developer Advocates
● Gated content that is tracked and
tied to OKRs
○ Available on YouTube
post-event to registrants only
● Public schedule
● Kubernetes I & II, III
● Quarkus I & II
● Istio Service Mesh
● Kafka
● Knative Serverless
● Tekton Pipelines
● Argo CD GitOps
● Operator SDK I & II
● Containers
● Spring Boot on Kubernetes
● Linux I & II
Deep Dive : Kubernetes I
What you will learn:
● Why use Kubernetes?
● What Kubernetes is
● Kubernetes installation
● Kubernetes CLI with kubectl
● Pod, ReplicaSet, and Deployment
● Logs and stern
● Debugging with kubectl exec
● Applications as a Service
● Rolling update delivery
Duration : 1 hour
Audience : For developers and hands-on architects
Don’t be the last one to board the Kubernetes train!
Even if you’re not deploying apps to Kubernetes now,
you might be soon. So hurry up, take this deep dive
with us, and learn from recognized CodeCasters
about the fundamentals of Kubernetes.
Be prepared to interact with other attendees and the
instructor on this journey that includes the open
hybrid cloud, Kubernetes, tooling, terminology,
concepts, and practical exercises of how you can
apply, deploy, and use Kubernetes to fulfill your
cloud-native requirements.
Deep Dive : Kubernetes II
What you will learn:
● Building images
● Resource Limits
● Rolling update delivery
● Liveness and readiness probes
● Environment variables and ConfigMaps
Duration : 1 hour
Audience : For developers and hands-on architects
You learned the Kubernetes basics, so what’s next?
Deploying successfully, of course! Limit the
resources you app can consume, perform smooth
rolling updates with proper health and readiness
probes, and master the configuration of your apps.
Be prepared to interact with other attendees and
your CodeCaster on this journey that includes the
open hybrid cloud, Kubernetes, tooling, terminology,
concepts, and practical exercises of how you can
apply, deploy, and use Kubernetes to fulfill your
cloud-native requirements.
Deep Dive : Kubernetes III
Duration : 1 hour
Audience : For developers and hands-on architects

Application deployed to Kubernetes! Now that we

deployed it, what else do we need to be successful in
production? Let's look at how features like volumes,
secrets, and operators can help us deploy stateful
applications like databases into our Kubernetes
What you will learn: clusters.

● Secrets Be prepared to interact with other attendees and

● Operators your CodeCaster on this journey that includes the
● Volumes open hybrid cloud, Kubernetes, tooling, terminology,
● Taints
concepts, and practical exercises of how you can
● Jobs
apply, deploy, and use Kubernetes to fulfill your
● DaemonSet
cloud-native requirements.
● StatefulSet
Deep Dive : Quarkus I: Basics
Duration : 1 hour
Audience : Spring, Java EE, and Enterprise Java developers

Is your Java app consuming the server’s whole

memory and taking minutes to boot? And then, even
more time to redeploy? Get rid of your 25-year-old
Java jokes and learn Quarkus, the supersonic,
subatomic Java.

What you will learn: Join this deep dive session to learn how Java apps
can have small memory footprints, boot in
● Quarkus setup
milliseconds, and help you have instantaneous
● CRUD and RDBMS
save/refresh coding sessions. Interact with our
● JVM and native deployment
CodeCasters and other attendees while learning the
● Custom configuration
● Quarkus deployment to Kubernetes/OpenShift superpowers that Quarkus brings to next-generation
● Spring compatibility extensions apps. The world has changed, and Java changed with
Quarkus, too. Upgrade your skills with us!
Deep Dive : Quarkus II: Kubernetes Native
Duration : 1 hour
Audience : Spring, Java EE, and Enterprise Java developers

You have already learned to be superfast and

supersmall with Quarkus: Subatomic, Subatomic
Java. What’s next? Adding more Cloud/Kubernetes
Native capabilities, of course!

Join this deep dive session to learn how to add fault

What you will learn: tolerance, metrics, security, and much more that you
need to develop, deploy, and run your Java apps
● Kafka and MicroProfile Reactive Messaging
successfully in the Cloud. Interact with the
● Microservices architecture
CodeCasters and other attendees while learning the
● Fault tolerance
superpowers that Quarkus brings to your
● Health checks
● Metrics Cloud/Kubernetes Native apps. The world has
● Security with JWT RBAC changed, and Java changed with Quarkus, too.
Upgrade your skills with us!
Deep Dive : Istio Service Mesh
Duration : 1 hour
Audience : For Kubernetes-experienced developers

Service mesh, in general, helps developers solve

typical problems they find when moving to
cloud-native infrastructure and building applications
out of microservices. Some of these challenges
include how to consistently monitor and collect
What you will learn: statistics, tracing, and other telemetry; how to add
resiliency in the face of unexpected failure; how to do
● Why microservices and the service mesh?
powerful feature routing (i.e., canary releases and
● Installation and setup
shadowing traffic); and much more, like securing your
● Observability
services correctly. In this session, we'll show you how
● Traffic shaping
● Smart dark canaries to take advantage of service mesh capabilities so you
● Resiliency can start using them right after the session.
● Security
Deep Dive : Kafka
Duration : 1 hour
Audience : For Java developers and hands-on architects

Have you been dreaming of streaming? Apache

Kafka has taken over the async messaging world and
is now a required skill for every Java developer. Stop
using batch processes to analyze your data, and start
doing it in real time with Kafka Streams.
What you will learn:
Be prepared to interact with other attendees and
● How to install Kafka for a Developer workstation your CodeCaster on this journey that includes
● How to install Kafka in a Kubernetes cluster Apache Kafka & AMQ Streams, tooling, terminology,
● Topics/Partitions concepts, and practical exercises of how you can
● Messages
apply, deploy, and use Kafka in your next
● Producers/Consumers
cloud-native application architecture.
● Kafka Streams
● Windowing
Deep Dive : Knative Serverless
Duration : 1 hour
Audience : For Kubernetes-experienced developers

Kubernetes-native serverless with Knative grants you

the “magical” ability to scale to zero if your
application component is underutilized. Perhaps
more importantly, the skills and code you craft with
Knative and Kubernetes are portable to all of the big
What you will learn: cloud providers.

● Knative installation and setup In this session, we will show you how to get started
● Your first Knative Serverless service and how to keep rocking with the interesting
● Traffic distribution with Blue/Green capabilities of Knative Serving and Knative Eventing.
● Traffic distribution with Canary
● Auto-scaling behavior modification
● Event sources and sinks
● Apache Kafka events
Deep Dive : Tekton Pipelines
Duration : 1 hour
Audience : For Kubernetes-experienced developers

Automation of your end-to-end pipeline, from code

commit, through “docker build,” to running in your
cluster, is now possible with Tekton
(Kubernetes-native Pipelines). In this session, we will
present a tutorial on how to leverage Tekton for your
What you will learn: pipeline automation.

● Tekton Pipelines installation and setup

● The Tekton CLI (tkn)
● Nexus for Maven dependencies
● Pipeline resources
● Task creation (e.g., mvn and docker build)
● Pipeline crafting
● Pipeline execution and monitoring
Deep Dive : Argo CD GitOps
What you will learn:
● The fundamentals of GitOps and Argo CD
● How to install and manage Argo CD in Kubernetes and
Red Hat OpenShift
● Deploying and syncing applications
● Using Kustomize with Argo CD
● Using sync waves and hooks with Argo CD
Duration : 1 hour
Audience : For Kubernetes-experienced developers
Having Git repositories as a single source of truth
allows development teams to store the entire state of
the cluster configuration in Git so that the trail of
changes are visible and auditable. Argo CD is a
declarative, GitOps continuous delivery tool for
Kubernetes. It follows the GitOps pattern of using
Git repositories as the source of truth for defining
the desired application state. It automates the
deployment of the desired application states in the
specified target environments. Application
deployments can track updates to branches, tags, or
pinned to a specific version of manifests at a Git
commit.
Deep Dive : Kubernetes Operator SDK I
What you will learn:
● What is meant by the term “Kubernetes Operator”
● Background information on Kubernetes Custom
Resource Definitions (CRDs)
● How to deploy an existing operator and use it to install
an application
● How to build an operator from an existing Helm chart
● How to build an operator from an existing Ansible
playbook
Duration : 1 hour
Audience : Kubernetes application developers
Deploying simple applications to Kubernetes is easy.
Deploying applications that consist of multiple
microservices with complex interactions and
configurations is not. Keeping those applications
running is an entirely different story all together.
This deep dive session introduces the concept of
Kubernetes Operators and how they bring
domain-specific knowledge about installing and
maintaining your application into the cluster. This
course will use the Operator SDK to rapidly build and
test operators that leverage existing technologies
such as Ansible and Helm.
Deep Dive : Kubernetes Operator SDK II
Duration : 1 hour
Audience : Kubernetes application developers

This deep dive session builds on the fundamentals

introduced in part 1 to build more advanced
operators. Using the Operator SDK, an operator will
be built from the ground up in Go, including fleshing
out its custom resource definitions and RBAC
What you will learn: permissions.

● Background information on how operators tie into Kubernetes

● How to use the Operator SDK to generate an operator
scaffold project
● Techniques and best practices on implementing operators in
Go
● How custom resource definitions can define their own
validation schema
● How the Operator SDK facilitates the developer inner loop of
rapid testing of code changes
Deep Dive : Containers
What you will learn:
● Containers vs Images
● Running with Red Hat Universal Base Image
● Installing software into a working container
● Positioning files into a working container
● Committing your container image
● Creating a container and running in interactive command
● Creating a detached container with a mapped port
● Attaching to a detached container
● Stopping a container
● Mapping some host storage to your container
● Managing images (pushing and pulling) and containers
Duration : 1 hour
Audience : Developers and Linux administrators
Imagine you’re developing an application. You do
your work on a laptop and your environment has a
specific configuration. Other developers may have
slightly different configurations. Meanwhile, your
business has development and production
environments that are standardized with their own
configurations You want to emulate those
environments as much as possible locally, but without
all the overhead of recreating the server
environments. So, how do you make your app work
across these environments, pass quality assurance,
and get your app deployed without massive
headaches, rewriting, and break-fixing? The answer:
containers.
Deep Dive : Spring Boot on Kubernetes
Duration : 1 hour
Audience : Java developers and hands-on architects

Are you struggling to deploy and run your Spring

Boot applications on Kubernetes? Then join us on
this informative and helpful Deep Dive. We can all
agree that Spring Boot is great, and you'll learn how
to make the best of it when running on Kubernetes:
from source code to container, to pod, to production!
What you will learn:

● How to containerize a Spring Boot application with Jib

● How to deploy it to a Kubernetes cluster with JKube
● Spring Actuators to implement health checks and provide
metrics
● Spring Resiliency
● Spring Cloud Kubernetes Config to inject ConfigMaps as
Spring configuration properties
Deep Dive : Helm
What you will learn:
● The fundamentals of Helm charts
● How to install, upgrade and uninstall Helm charts in
Kubernetes
● Customizing, replicating and syncing applications
● Practical Helm chart per microservice approach
● Practical leader chart approach with Helm
Duration : 1 hour
Audience : Developers that want to streamline operations
with Kubernetes resources
Deploying your application in Kubernetes can very
quickly become a blend of YAML files containing
many dependencies, configuration variables, and
general confusion. Helm mitigates these concerns by
bundling parameterizable YAML resources so that
you no longer have to decipher which of the YAML
files need to be changed and instead can focus on
one application at a time. Helm makes it easy to start
using Kubernetes with real applications. Helm Charts
are useful for addressing the installation complexities
and simplifying upgrades of stateless applications
like web apps.
Deep Dive : OpenShift for Developers
Duration : 1.5 hour
Audience : Developers that want to learn OpenShift and
Kubernetes

Application delivery teams are under ever-growing

pressure to deliver more capabilities in their apps and
APIs. Regardless of your monolith, microservices, or
event-driven architecture ambitions - Linux
What you will learn: containers, Kubernetes orchestration, and OpenShift
Dev & Ops productivity enhancements will change
● Using the OpenShift command line client and web
the way you build & deliver better software, faster.
console.
● Deploying an application using a pre-existing container
image.
● Working with application labels to identify component
parts.
● Scaling up your application in order to handle web traffic.
● Exposing your application to users outside of the cluster.
● Viewing and working with logs generated by your
application.
Deep Dive : Linux I
Duration : 1 hour
Audience : Developers and non-Linux administrators

Get a quick overview of some Linux topics you may

run into when spinning up new applications or
containers on Red Hat Enterprise Linux. If you don’t
have a good foundation of Linux commands and
utilities, using products that run on top of Linux can
What you will learn: be difficult.

● Registering a Red Hat Enterprise Linux system

● Installing packaged software [yum]
● Installing Application Stream, modular, software [yum]
● Starting, controlling, monitoring services [systemctl]
● Installing unpackaged software [tar/zip/make(?)]
● Permissions & Ownerships [chmod, chown]
● File operations [cp, mv, rm, mkdir, rmdir]
Deep Dive : Linux II
Duration : 1 hour
Audience : Developers and non-Linux administrators

Get a quick overview of some Linux topics you may

run into when spinning up new applications or
containers on Red Hat Enterprise Linux. If you don’t
have a good foundation of Linux commands and
utilities, using products that run on top of Linux can
What you will learn: be difficult.

● Editors [vi, nano, cat -vet]

● How to find and kill a process [ps, grep, kill, kill -9]
● Gathering some OS stats [ip a, os-release, top, iotop,
ss, df -hP]
● Looking at open ports [nmap, /etc/services]
● Fancy ssh (ssh, scp, sftp, ssh-copy-id)
● Quick SELinux overview [setenforce, semanage,
setsebool, ls -Z, https://stopdisablingselinux.com]
 Red Hat Developer Deep Dives : Links to Content

Kubernetes Quarkus Istio Kafka

dn.dev/kube-tutorial dn.dev/quarkus-tutorial dn.dev/istio-tutorial dn.dev/kafka-tutorial
dn.dev/kubemaster1 dn.dev/quarkusmaster dn.dev/istiomaster dn.dev/kafkamaster
dn.dev/kubemaster2
dn.dev/kubemaster3

Knative Tekton Argo CD Operator SDK

dn.dev/knative-tutorial dn.dev/tekton-tutorial dn.dev/argocd-tutorial dn.dev/operators-homework
dn.dev/knativemaster dn.dev/tektonmaster dn.dev/argocd-workshop dn.dev/operatorsdk1
dn.dev/operatorsdk2

Containers Spring Boot Helm OpenShift

dn.dev/containers-tutorial dn.dev/springkube-tutorial dn.dev/helm-tutorial dn.dev/openshift-tutorial
dn.dev/containersmaster dn.dev/springkubedeepdive dn.dev/helmdeepdive dn.dev/openshift-workshop
Needs update
Thank you
Join the DevNation
linkedin.com/showcase/red-hat-developer
Red Hat Developer serves the builders. The problem solvers who

create careers with code. Let’s keep in touch!

youtube.com/redhatdevelopers
● Join Red Hat Developer at developers.redhat.com/register

● Follow us on any of our social channels

facebook.com/redhatdeveloperprogram
● Visit dn.dev/upcoming for a schedule of our upcoming events

twitter.com/rhdevelopers
Red Hat Developer
Build here. Go anywhere.