LernIX Solutions

Course Overview

EXCLUSIVE: This hands-on course will teach you all aspects of Microservice architecture.

Microservices thrive on independent services to provide flexibility, autonomous processes, and communication through APIs. In this course, you’ll examine the differences between Microservices and monolithic applications and their architectures, the benefits of using the Microservice Architecture and transitioning to microservices. Learn how to map technical practices to the business strategy behind microservices, and its different tools, and communicate with the stakeholders to explain microservices’ needs. You will conceptualize container technologies such as use Docker, Kubernetes, and Jenkins and learn how DevOps can benefit from microservices adoption.

Course Objectives

Adopt, plan, or improve your transition to microservices
Map technical practices to the business strategy behind microservices
Navigate different tools for enabling microservices and how to use them
Communicate with stakeholders, management, and teams regarding needs and expectations around microservices
Get hands-on practice with Docker, Kubernetes, Jenkins for core microservices architecture
Get hands-on practice with the toolchain in our real-world application labs
Build more mature DevOps practices through microservice adoption
Understand how to refactor monolithic systems into more modular, component-based systems
Apply microservice use cases to continuous integration, delivery, and testing
Enable more automated testing and self-service QA capability

Course Content

Containers and Container Orchestration
- Containers
  - Docker Introduction
    - Docker Architecture and use cases
    - Managing images and containers using Docker(docker cli tool)
    - Working with Dockerfile
    - Building CI\CD pipeline with Docker
  - Lab: Build and push an Docker image from Dockerfile
  - Quiz – Quiz on Docker
- Container Orchestration
  - Introduction to Kubernetes , kubectl command
  - Lab: Kubernetes – Hello World
  - Core Kubernetes concepts and Architecture
  - Lab: Kubernetes – Stateless web app
  - Kubernetes Features
  - Lab: Kubernetes – Guestbook app
  - Quiz: Quiz on kubernetes
Microservices Design and Implementation
- Monolithic and Microservice architecture
  - Monolithic Architecture
    - Case study for Monolithic application
  - Monolithic vs Microservices
  - Service-Oriented Architecture
    - SOA – Suggested Case study
  - Microservices Architecture
  - Quiz – Quiz on Microservice and Monolithic architectures
- Microservice Implementation
  - Uber case study
  - Domain-oriented Microservices Architecture
  - Traditional Development and Deployment Challenges
  - Deploying Microservices as Containers
  - Lab: Containerize Microservices
  - Lab: Deploy Microservices
  - Implementing CI/CD pipeline using Jenkins
  - Lab: Create a simple CI/CD pipeline using Jenkins
  - Quiz – Quiz on Microservice and Monolithic architectures implementation
Microservices in Production
- Production Grade Microservices
  - Spotify case study
  - Service Discovery
  - Security Concepts
  - Lab: Kubernetes – Store database credentials in cluster
  - Monitoring using Prometheus
  - Managing state in Microservices
  - Improving and Monitoring Microservices Performance
  - Netflix Microservice – case study
  - Kubernetes Advanced Resources
  - Openshift/Rancher/Other PaaS platforms
  - Lab: Customize Microservice App
  - Lab: Scale up/down based on demand (Simulation)
  - Review of Microservice Challenges
  - Quiz: Quiz on Production Grade Microsercies

Course Overview

This class centers on developing the skills and knowledge needed for Day-1 Kubernetes operations for managing applications. Using best practices as guiding principles, students will engage in topics pertaining to the Kubernetes architecture to make informed decisions for production workloads. Topics include configuring resource availability for applications, implementing advanced scheduling for applications, and administering user roles and permissions for the Kubernetes cluster. Kubernetes Operations and System Integration teams will benefit greatly as they plan and deploy their Kubernetes production environments.

Course Content

Kubernetes High Availability

Review the basic architecture of a Kubernetes cluster
Install a well-validated HA Kubernetes cluster on a collection of hosts
Load balance kubectl commands across an HA Kubernetes cluster

Managing Application Deployment

Review how pods are scheduled on worker nodes
Examine the node selector
Discuss implementing the impact of taints and tolerations for Kubernetes workloads
Review both pod and node affinity and anti-affinity

Releasing Application Updates

Discuss releasing updates to applications running on the Kubernetes platform
Explore native tooling for updating application
Examine how Helm manages updating applications

Application High Availability

Review the architecture required to achieve high availability for applications
Discuss best practices for using liveness and readiness probes
Explore Kubernetes auto-scaling of applications
Discuss how to prioritizing Kubernetes workloads

Routing Network Traffic

Discuss network routing options within Kubernetes
Discuss the benefits of the Ingress controller and object
Examine the Ingress object and controller pattern

Provisioning Storage

Review available storage options for applications
Discuss constraints of persistent storage in a standard Kubernetes cluster deployment
Examine the storageClass object

Kube Security: Implementing RBAC

Discuss RBAC implementation within Kubernetes
Examine Kubernetes RBAC components
Review Auditing within Kubernetes
Determine how to enable Auditing within a Kubernetes cluster

Kubernetes Network Security

Review the the Kubernetes Networking Model
Discuss how Network Security is managed within the Kubernetes cluster
Examine managing network security with native and non-native Kubernetes tooling
Explain the native method of creating Network Policies

Securing an Application Workload

Identify security mechanisms available to security between containers, pods, and the Kubernetes cluster
Discuss strategies for enabling flexibility within security policy while maintaining security compliance
Examine how to enable Pod Security Policies

Multi-Tenancy in Kubernetes

Discuss multi-tenancy in a Kubernetes cluster
Examine native Kubernetes objects used for enabling multi-tenancy capability
Discuss multi-tenancy methods for Kubernetes

Course Overview

In this Cloud Native course, developers will learn how to build containerized applications targeted for enterprise-grade production environments. You’ll explore patterns in containerized application architecture, techniques for eliminating friction in the development process, how to test and debug containerized applications, and how to instrument applications with healthchecks, monitoring tools, and common container logging patterns. After mastering these techniques, we’ll turn our attention to devops and building container-native continuous integration pipelines powered by Jenkins and Kubernetes.

Course Content

Container Development Environments

Rapid development with code mounts and automatic reloading
Attaching debuggers to containerized processes
Installing Kubernetes development environments

Container Lifecycle

Optimizing image design to take advantage of the container lifecycle
Runtime operations to avoid or mitigate
Implementing logging, resource management and healthchecks for containers
Handling container exit
Introduction to developer-driven operational control

Containerizing Applications

Migrating preexisting applications from VMs to containers
Refactoring applications for microservices
Hybrid applications (containerized + uncontainerized)

Container Health & Monitoring

Implementing container healthchecks with Kubernetes
Integrating Prometheus monitoring with Kube applications

Introduction to Containerized Continuous Integration

Differences between traditional and containerized continuous integration
Tooling choices for CI chain components
Recommended CI chain architecture

CI Agent Deployment

Designing access control patterns for CI agents
Installing and integrating Jenkins with Kubernetes

Building Images in CI

Implementing build environments
Designing reusable image hierarchies

Testing in CI

Unit and integration testing in containers
Testing pipeline design
Integrating security scanning in a testing pipeline

Releasing Containerized Applications

Signing images with content trust
Packaging applications with Helm

Course Overview

This four-day course is the first step in learning about Containers and Kubernetes Fundamentals and Cluster Operations. Through a series of lectures and lab exercises, the fundamental concepts of containers and Kubernetes are presented and put to practice by containerizing and deploying a two-tier application into Kubernetes.

Course Objectives

By the end of the course, you should be able to meet the following objectives:

Build, test, and publish Docker container images
Become familiar with YAML files that define Kubernetes objects
Understand Kubernetes core user-facing concepts, including pods, services, and deployments
Use kubectl, the Kubernetes CLI, and become familiar with its commands and options
Understand the architecture of Kubernetes (Control plane and its components, worker nodes, and kubelet)
Learn how to troubleshoot issues with deployments on Kubernetes
Apply resource requests, limits, and probes to deployments
Manage dynamic application configuration using ConfigMaps and Secrets
Deploy other workloads, including DaemonSets, Jobs, and CronJobs
Learn about user-facing security using SecurityContext, RBAC, and NetworkPolicies

Course Content

1 Course Introduction

Introductions and objectives

2 Containers

What and Why containers
Building images
Running containers
Registry and image management

3 Kubernetes Overview

Kubernetes project
Plugin interfaces
Building Kubernetes
Kubectl CLI

4 Beyond Kubernetes Basics

Kubernetes objects
YAML
Pods, replicas, and deployments
Services
Deployment management
Rolling updates
Controlling deployments
Pod and container configurations

5 Kubernetes Networking

Networking within a pod
Pod-to-Pod Networking
Services to Pods
ClusterIP, NodePort, and LoadBalancer
Ingress controllers
Service Discovery via DNS

6 Stateful Applications in Kubernetes

Stateless versus Stateful
Volumes
Persistent volumes claims
StorageClasses
StatefulSets

7 Additional Kubernetes Considerations

Dynamic configuration
ConfigMaps
Secrets
Jobs, CronJobs

8 Security

Network policy
Applying a NetworkPolicy
SecurityContext
runAsUser/Group
Service accounts
Role-based access control

9 Logging and Monitoring

Logging for various objects
Sidecar logging
Node logging
Audit logging
Monitoring architecture
Monitoring solutions
Octant
VMware vRealize® Operations Manager™

10 Cluster Operations

Onboarding new applications
Backups
Upgrading
Drain and cordon commands
Impact of an upgrade to running applications
Troubleshooting commands
VMware Tanzu™ portfolio overview

Course Overview

This course complies with instructional designing principles for all the 3 lessons. This will ensure that you repeat and reinforce your gained knowledge at every step. Each and every minute spent during this 1-day course will incrementally take you to a next level.

Course Objectives

ensure that your container-based applications sail into production without hiccups, you need robust container orchestration. This course teaches you the art of container management with Kubernetes.

The course will provide enough knowledge of the following:

Understand and classify software designs patterns as per the cloud-native paradigm
Apply best practices in Kubernetes with design patterns
Access the Kubernetes API programmatically using client libraries
Extend Kubernetes with custom resources and controllers
Integrate access control mechanisms and interact with the resource lifecycle in Kubernetes
Develop and run custom schedulers in Kubernetes

Course Content

LESSON 1: KUBERNETES DESIGN PATTERNS

Software Design Patterns
Kubernetes Design Patterns

LESSON 2: KUBERNETES CLIENT LIBRARIES

Accessing Kubernetes API
Official Client Libraries
Community Maintained Client Libraries

LESSON 3: KUBERNETES EXTENSIONS

Kubernetes Extension Points
Extending Kubernetes Clients
Extending Kubernetes API
Kubernetes Dynamic Admission Control
Extending Kubernetes Scheduler
Extending Kubernetes Infrastructure

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:

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;
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:

The first part deals with the Kubernetes Administrator Fundamentals;
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:

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);
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:

at the level of an enterprise;
on the basis of self-hosting;
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.