Course Overview

This Kubernetes Fundamentals Developer training is especially suitable for developers who are (partly) responsible for designing and building software that has to run on Kubernetes. The training offers students a deepening of how to use Kubernetes within a development function and how to build applications for a Cloud-Native world. The training is hands-on and offers knowledge and skills based on exercises and examples that you do yourself in your own Kubernetes cluster.

Does your organization start embracing Kubernetes? Do you want to take the next step in the world of Kubernetes and become the specialist? Then this training is perfect for you.

Course Objectives

Hands-on learning of Kubernetes in the basics and on bare metal. In accordance with the theory as expected by the Cloud Native Foundation for certification. The objectives of this training are:

• After this training, the participant will be able to make a start with Kubernetes in his/her organization.
• After this training, the participant has the basic knowledge to set up and use Kubernetes on both on-premise and managed hosting.
• Learning the Kubernetes basis, as formulated by the CNCF, from a hands-on approach and based on the Kubernetes architecture (to provide understanding and context).
• This training lays the foundation needed for certification and deepening so that follow-up training can build on this.

On the basis of this training, the participant gets insight into Kubernetes and an overview on the level of application, microservice, and ‘modern application architecture:

1. So that a participant can find his way better and on the basis of insight (at a general level) to build applications on, and automate applications on, Kubernetes hosting. Partly due to the choice of options related to the available technology in the Cloud Native Landscape for the benefit of building, managing, and automating the applications and the application lifecycle;
2. Based on working and elaborated expert examples, the participant can start with Kubernetes expert parts in their own organization after the training or build a solution based on obtained examples.

Course Content

Fundamentals:

The fundamentals follow the content as prescribed for the CKAD exams for certification. The training consists of a part theory in presentation form plus performing some 30 to 40 detailed exercises.

Topics being taught:

• History IT
• Virtualization: what is a Virtual Machine and what is a Container. And what is the difference between the two?
• The Microservices paradigm
• What is Kubernetes, what is Cloud Native? And why is this development important;
• Kubernetes architecture
• Kubernetes principles
• Kubernetes components
• Kubernetes Resources (deployment, replicaset, pods);
• Basic concepts of Kubernetes: control plane, resources in detail, services, draining nodes, setting limits, tolerations, affinity/anti-affinity, horizontal scaling, deployments, release management & canary releases, startup/liveliness & readiness checks, rollbacks, configsmaps & secrets, lifecycle-hooks & init containers, logging, monitoring, troubleshooting, bootstrapping, DNS-networking, static pods, tls: communicating with apiserver, multi-containers, sidecar containers (adaptor pattern, ambassador pattern), pod-policies, application troubleshooting, service accounts, horizontal pod autoscaling on CPU
• Storage
• Kubernetes use principles: Helmet, Ingress Controller
• Kubernetes network security: Role-Based Access Control (RBAC).

Selection of Modules:

The number of topics available in the training as choice modules is more than can be covered during the training. For each training, the trainer decides, in consultation with the group, which topics will be covered in the training. Sometimes this can mean that the group decides on day 5 to work with different components.

• Local development: KIND, Warp, Telepresence, Visual Studio Code, Lens, Octant
• Role-Based Access Control (RBAC) and Single Sign-On (with Keycloak) for Applications
• Observability: Central Logging: ELK Stack
• Observability: Central Monitoring and Application Chain Monitoring via Prometheus and Graphana
• Service Mesh: SMI, LinkerD, Istio, OSM, horizontal scaling based on latency (monitoring information)
• Microservices Automated CI/CD: Gitlab
• Scalable WordPress Architecture (from monolith to micro-service)
• Build your own WordPress CRD/Operator/Controller (application lifecycle automation)

The choice of modules goes into depth on Expert parts, by means of exercises that connect to the daily practice of working with Kubernetes, using working examples.

Course Overview

If you are a Developers/Programmer and DevOps Engineer and want to work from the perspective of Cloud-Native and build to run in and with Kubernetes this training is for you. In addition to hands-on and working examples, the training looks at how to deal with Cloud-Native at the level of architecture and build your own architecture, taking into account:

• a cloud-native approach
• safety
• access
• full automation (DevOps)
• existing applications
• application chain monitoring
• build on Kubernetes (operators);

By doing everything in the training on and with bare-metal Self Hosted clusters, you will learn things at their core. After that, you will be better equipped and able to work with any Kubernetes variant and translate the examples in the training itself to any other Kubernetes variant, such as Openshift, Tanzu, Rancer, or Managed Hosting such as GKE, AKS and EKS.

Course Objectives

• Hands-on learning of Kubernetes and Cloud-Native principles on bare metal, with working examples.
• After this training, the participant has the basic knowledge to use Kubernetes on both on-premise and managed-hosting.
• On the basis of this training the participant gets insight into Kubernetes and an overview at the level of application, microservice, and ‘modern application architecture’:
  – So that a participant knows his way around building applications on, and automating applications on, Kubernetes hosting better and on the basis of insight (at a general level); 
  – The choice of options related to the available technology in the Cloud Native Landscape for the benefit of building, managing, and automating the applications and the application lifecycle;
  – By explaning and showing with examples and best-practices, at an architectural level, creating a better understanding of Cloud-Native and how to build solutions with a Cloud-Native ‘philosophy’;

After the training based on working and elaborated expert examples the participant can start with Kubernetes expert parts in their own organization or building solutions, partly based on obtained examples in the exam.

Course Content

The number of topics available in the training as choice modules is more than can be covered during the training. For each training, the trainer decides in consultation with the group which topics will be covered in the training. Sometimes this can mean that the group decides on day 2:

• to start working with different parts
• or that they want to continue less hand-on, in order to cover more ground

The following choice modules are available in this training:

• Local development: KIND, Warp, Telepresence, Visual Studio Code, Lens, Octant
• Role-Based Access Control (RBAC) and Single Sign-On (via Keycloak) for Applications;
• Application Logging & Centralized Logging
• Observability: Central Monitoring and Application Chain Monitoring through Prometheus and Graphana;
• Service Mesh: SMI, LinkerD, Istio, OSM, horizontal scaling based on latency (monitoring information);
• DevOps – Microservices Automated CI/CD: Principles, Architecture, Gitlab, Tekton
• Scalable WordPress Architecture (from monolith to Cloud-Native app)
• Build your own WordPress CRD/Operator/Controller (application lifecycle automation)
• Release Management: your own Helm (packages, libraries) and scripting (Kustomize)

Course Overview

This Kubernetes Fundamentals training is very suitable for IT Administrators (engineers) and offers participants a deep inside in the architecture, use, and management of Kubernetes. The training is based on teaching Kubernetes for self-hosting. Each participant gets their own (simulated) bare-metal cluster, which the participant initiates himself.

The training is hands-on and offers knowledge and skills based on exercises and examples you perform. The idea here is, if you understand Kubernetes and can work with it at this level, you will be able to work with any other possible variant.

This training consists of two parts:

1. The first part deals with the Kubernetes Administrator Fundamentals;
2. the second part consists of expert choice modules for Kubernetes Administrators.

Are you or will you become an Engineer, System-Administrator, or DevOps Engineer (partially or fully) responsible for one or more Kubernetes clusters, or you would like to be able to manage or set up Kubernetes for your organization? Then this training is perfect for you.

Course Objectives

Hands-on learning of Kubernetes in the base and on bare metal. In line with the theory expected by the Cloud Native Foundation for Certified Kubernetes Administrator (CKA) certification.

The starting point of this training is:

• that after this training the participant is able to make a start with Kubernetes in his/her organization;
• the participant has the basic knowledge needed to set up, use, and manage Kubernetes on on-premise, managed hosting or any Kubernetes variant out there;
• the participants learn the Kubernetes basis, as formulated by the CNCF, from a hands-on approach and based on the Kubernetes architecture;
• this training lays the foundation needed for certification so that in subsequent exam training courses can build on this.

On the basis of this training, the participant gets insight into Kubernetes and an overview at the level of the Kubernetes application and  the Kubernetes hosting architecture:

1. So that a participant knows his way around the technical hosting architecture (for Enterprises) and choices related to the Cloud Native Landscape better and on the basis of insight (on a general level);
2. Based on working and elaborated expert examples after the training, Kubernetes can start by introducing Kubernetes expert parts in their own organization or building a solution based on obtained working examples.

Course Content

Fundamentals:

This training follows the contents as prescribed for the CKA exam for certification by offering the theory in presentation form and performing 30 to 40 detailed exercises.

Topics as they pass:

• Some IT history;
• Virtualization: what is a Virtual Machine and what is a Container. And what is the difference between the two?
• What is Kubernetes, what is Cloud Native? And why is this development important;
• Kubernetes architecture;
• Kubernetes principles;
• Kubernetes components;
• Kubernetes Resources (deployment, replicaset, pods);
• Basic concepts of Kubernetes: control plane, resources in detail, services, draining nodes, setting limits, tolerations, anti-affinity, horizontal scaling, deployments, release management & canary releases, liveliness checks, readiness checks updates, rollbacks, configsmaps & secrets, lifecycle-hooks & init containers, logging, monitoring, troubleshooting, bootstrapping, component configuration, DNS-networking, static pods, tls: communicating with apiserver, multi-containers, sidecar containers, pod-policies, Linux-capabilities, privileges and access control, application troubleshooting, network policies, service accounts;
• Storage
• Kubernetes use principles: Helmet, Ingress Controller;
• Kubernetes networks security: Role-Based Access Control (RBAC).

Selection of modules:

The number of topics available in the training as choice modules is more than can be covered during the training. For each training, the trainer decides, in consultation with the group, which topics will be covered in the training. Sometimes this can mean that the group decides on day 5 to work with different components. The choice of modules goes into depth on Administration Expert parts, by means of exercises that are in line with the daily practice of working with Kubernetes, using working examples.

• Granulair Role-Based Access Control (RBAC) with, Keycloak, Single Sign-On
• Auditing, Policies & API-Server Central Security: validating & mutating webhooks, OPA, KRails
• Central Logging: ELK Stack
• Central Monitoring: Prometheus, Graphana;
• External (Federated) Storage: Rook, OpenEBS
• Advanced Security: Encryption at Rest, Sealed Secrets, KMS, Vault, Harbor, Notary, Falco
• Service Mesh: SMI, LinkerD, Istio, OSM, horizontal scaling based on latency (monitoring information)
• Operator & Controllers (Software) Overview
• Own Custom Resources: advanced WordPress, build your own WordPress operator
• Creating your own secure helm registry
• Cluster backup & Generic State Management
• High Available Kubernetes Cluster
• Infrastructure as Code with Terraform

Course Overview

This Kubernets CKA Professional course is a Kubernetes Fundamentals and CKA exam theory training.

The training covers the Kubernetes Fundamentals for engineers as defined by the Cloud Native Computing Foundation (CNCF) and tested in the CKA exam:

• based on an understanding of the Kubernetes Architecture
• in the context of IT development, Microservices, and Cloud-Native so that you, at the end of this course, can start using Kubernetes as Engineer based on understanding, and insight into Kubernetes,

The training is hands-on:

• every participant has their own bare-metal cluster
• the training is loaded with exercises and examples (which you carry out yourself), so Kubernetes will be taught by doing, at the level of CKA.

The experiences you gain during the training will give you tools to use Kubernetes in practice and prepares you, for the theoretical part, for the CKA exam.

Course Objectives

Hands-on learning of Kubernetes in the base and on bare metal. In line with the theory expected by the Cloud Native Computing Foundation for certification.

The aim of this training is that after this training the participant is able to start using Kubernetes in his/her organization as an Engineer:

• After this training, the participant has the basic knowledge to set up and use Kubernetes on both on-premise (self-hosting) and managed-hosting.
• Learning the Kubernetes basis, as formulated by the CNCF, from a hands-on approach and based on the Kubernetes architecture.
• This training lays the foundation needed for certification so that subsequent exam training courses can build on this.
• This training gives participants inside in Kubernetes as an application, at the hosting architecture level, and as a hosting platform.

Course Content

This training follows the contents as prescribed for the CKA exam for certification by offering the theory in presentation form and performing 30 to 40 detailed exercises.

Topics taught:

• A History of IT
• Virtualization: what is a Virtual Machine and what is a Container. And what is the difference between the two?
• What is Kubernetes, what is Cloud Native? And why is this development important?
• Kubernetes architecture
• Kubernetes principles
• Kubernetes components
• Kubernetes Resources (deployment, replicaset, pods)
• Basic concepts of Kubernetes: control plane, resources in detail, services, draining nodes, setting limits, tolerations, anti-affinity, horizontal scaling, deployments, release management & canary releases, liveliness checks, readiness checks updates, rollbacks, configsmaps & secrets, lifecycle-hooks & init containers, logging, monitoring, troubleshooting, bootstrapping, component configuration, dns-networking, static pods, tls: communicating with apiserver, multi-containers, sidecar containers, pod-policies, linux-capabilities, privileges and access control, application troubleshooting, network policies, service accounts
• Storage
• Kubernetes use principles: Helmet, Ingress Controller
• Kubernetes security: Role Based Access Control (RBAC).

Course Overview

This Kubernetes CKA Advanced training takes a deeper look at the design, management, and control of a Kubernetes cluster landscape:

1. at the level of an enterprise;
2. on the basis of self-hosting;
3. from a Cloud-Native perspective.

The training is based on working examples, which are executed as much as possible by the participants themselves.

The training is very suitable for Kubernetes Administrators and Engineers who are interested in how to deal with business issues at the enterprise level:

• Kubernetes & Cloud-Native architecture choices;
• Policies and Auditing;
• Monitoring and Logging;
• Security: both broadly and with regard to advanced topics;
• Automation;
• and Control over Kubernetes;

By learning generic Kubernetes for Self-Hosting you are taught skills and understanding of Kubernetes that a participant can easely self reapply, or translate to: other kubernetes platforms, or managed hosting.  Were the platforms are Openshift, Tanzu, Rancer, and Managed-Hosting is hosting on CKE, AKS and EKS.

Course Overview

Whether your focus is on developing containerized applications or managing a container-centric infrastructure, CN120 introduces Kubernetes container orchestration for everyone involved in the software development life cycle. Through a real-world approach for design and deployment considerations, students can expect to learn about the foundational Kubernetes components required for application workloads. Specifically, students will examine Kubernetes architecture, explore how Kubernetes objects work together for running an application, and learn how Kubernetes makes use of compute, networking, and storage resources.

Course Content

• Make effective use of pod architecture
• Deploy workloads as Kubernetes controllers
• Provision configuration at runtime to Kubernetes workloads
• Network pods together across a cluster using native services
• Provision highly available storage to Kubernetes workloads
• Package an application as a Helm chart

Course Overview

This course is designed for developers who create and run big data applications on HPE Container Platform 5.0. Although the platform provides a rich set of standard application images, This course guides developers on how to create, deploy and maintain additional application-specific images. The course consists of 50% lecture and 50% lab exercises.

Course Objectives

• Obtain in-depth knowledge of HPE

Container Platform 5.0 EPIC Application

Workbench

• Learn best practices to help accelerate the

development of new application images

• Learn how to maintain and optimize

application images

Course Content

HJ7L4S (hpe.com)

Introduction 

• Introduction

• Learning objectives review

• Course schedule review

HPE Container Platform 5.0 EPIC

Applications and Workbench Overview

• Components of HPE Container Platform 5.0 applications

• Application Workbench overview

• Introduction to cluster and tenant metadata

• Big data application classification

• Application integration patterns

Training Environment Overview • Installation

• Credentials and access walkthrough

• Building a sample application (e.g., Hello World)

– Application creation process

• Custom base Images

• Running Action and Bootstrap scripts

• Docker Registry and usage

Building a Single and Multiple Role

Application

• Developing a single role single service application (e.g,. Spark)

• Developing a single role multiple services application (e.g., Spark)

• Developing a multi-role multiple services application (e.g,.

Spark/Jupyter)

Building an Advanced Multi-Role

Hadoop-Based Application

• Hadoop distributions review (e.g., Cloudera, Hortonworks, MapR)

• Lecture

• Building an advanced multi-role application—CDH

• Building an advanced multi-role application—HDP

Training Environment Overview—Lab

Exercise

Building a Sample Application (e.g.,

Hello World)—Lab Exercise

Building a Single Role & Single Service

Application —Lab Exercise

Building a Single Role & Multiple

Service Application —Lab Exercise

Multiple Role & Multiple Service

Application —Lab Exercise

Building an Advanced Multi-Role Hadoop[1]Based Application —Lab Exercise

Course Overview

In this course, you’ll learn what a containerized application looks like when orchestrated by Docker Swarm. We’ll cover scheduling workloads across a cluster, networking stateless and stateful applications, provisioning dynamic configuration and persistent storage, and scaling highly available applications in this course intended to set a strong foundation in orchestration for all technical roles.

Course Content

Setting up and configuring a Swarm

• Operational priorities of container orchestration
• Containerized application architecture
• Swarm scheduling workflow & task model
• Automatic failure mitigation
• Swarm installation & advanced customization

Deploying workloads on Swarm

• Defining workloads as services
• Scaling workloads
• Container scheduling control
• Rolling application updates and rollback
• Application healthchecks
• Application troubleshooting
• Deploying applications as Stacks

Networking Swarm workloads

• Swarm service discovery and routing implementation
• Routing strategies for stateful and stateless workloads
• Swarm ingress traffic

Provisioning dynamic configuration

• Application configuration design
• Environment variable management
• Configuration file management
• Provisioning sensitive information

Provisioning persistent storage

• Storage backend architecture patterns
• NFS backed Swarms

Monitoring Swarm

• What to monitor in production-grade Swarms
• Potential Swarm failure modes & mitigations
• Swarm workload monitoring

Course Overview

In this course, you’ll learn how to create and manage individual containers using the Docker Engine. We’ll cover best practices in container image design and container deployment and auditing, as well as an introduction to single-node container networking and storage. This course is best practices focused, and is designed to enable rapid successful adoption of containerization from first principles.

Course Content

Containerization motivations and implementation

• Usecases
• Comparison to virtual machines

Creating, managing and auditing containers

• Container implementation from the Linux kernel
• Container lifecycle details
• Core container creation, auditing and management CLI

Best practices in container image design

• Layered filesystem implementation and performance implications
• Creating images with Dockerfiles
• Optimising image builds with multi-stage builds and image design best practices

Single-host container networking

• Docker native networking model
• Software defined networks for containers
• Docker-native single-host service discovery and routing

Provisioning external storage

• Docker volume creation and management
• Best practices and usecases for container-external storage.

Course Overview

Develop the skills necessary to configure a secure deployment solution for cloud-native apps. Learn how to build, deploy, scale, and manage containerized cloud-native apps using Azure Container Apps, Azure Container Registry, and Azure Pipelines.

Course Content

Module 1 Get started with cloud native apps and containerized deployments

This module provides an introduction to cloud-native applications, the benefits of containerized deployments, the options for containerized deployments on the Azure platform, and the features of Azure Container Apps.

Module 2 Configure Azure Container Registry for container app deployments

This module teaching users how to set up and configure an Azure Container Registry for deploying containerized applications to Azure Container Apps.

Module 3 Configure a container app in Azure Container Apps

This module examines the features and capabilities of Azure Container Apps, and then focuses on how to create, configure, scale, and manage container apps using Azure Container Apps.

Module 4 Configure continuous deployment for container apps

This module explores deployment options for containerized apps. It reviews the features of Azure DevOps and examines automated deployments to Container Apps using Azure Pipelines.

Module 5 Scale and manage deployed container apps

This module reviews the concept of revisions in Azure Container Apps and examines options for application lifecycle management. It also examines options for scaling and traffic splitting using Azure Container Apps.

Module 6 Guided project – Deploy and manage a container app using Azure Container Apps

This module guides learners through the end-to-end process of building, deploying, and managing containerized applications using Azure Container Apps, Azure Container Registry, Azure Pipelines, and other tools and resources.