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.

Course Overview

In this learning path, you practice deploying containers, container orchestration, and managing clusters on Azure Kubernetes Service. The skills validated include deploying, configuring, and scaling an Azure Kubernetes Service cluster. Also, deploying an Azure Container Registry instance and deploying an application into an Azure Kubernetes Service cluster.

Course Content

Module 1 Plan an Azure Kubernetes Service deployment

In this module, you learn about the core Kubernetes infrastructure components, including control plane nodes, node pools, and workload resources such as pods, deployments, and sets.

Module 2 Deploy and use Azure Container Registry

Learn how to create a private registry service for building, storing, and managing container images and related artifacts.

Module 3 Deploy an Azure Kubernetes Service cluster

In this module, you learn how to create an Azure Kubernetes Service cluster, configure its components, and connect to it using kubectl commands.

Module 4 Configure an Azure Kubernetes Service cluster

Use Azure Policy to enforce policies and safeguards on your Kubernetes clusters at scale. Azure Policy Ensures that your cluster is secure, compliant, and consistent across your organization.

Module 5 Deploy applications to Azure Kubernetes Service

This module covers how to provision an Azure Kubernetes Service cluster and validate the effect of Azure Policy.

Module 6 Configure scaling in Azure Kubernetes Service

This module covers the scaling applications in Azure Kubernetes Service (AKS), including manually scaling pods or nodes and integrating with Azure Container Instances (ACI).

Module 7 Guided Project – Deploy applications to Azure Kubernetes Service

Welcome to this interactive skills validation experience. Completing this module helps prepare you for the Deploy and manage containers with Azure Kubernetes Service assessment.

Course Overview

CN251 is an intensive cloud native training bootcamp for IT professionals looking to develop skills in deploying and administering containerized applications in Kubernetes. Over the course of five days, students will start with learning about first principles for application containerization followed by learning how to stand up a containerized application in Kubernetes, and, finally, ramping up the skills for day-1 operating tasks for managing a Kubernetes production environment. CN251 is an ideal course for those who need to accelerate the development of their IT skills for a rapidly-changing technology landscape.

Course Content

This course combines all topics of CN100, CN120, and CN220

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.

Kubernetes Application Essentials

• 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

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

This is a 1-day course packaged with the perfect balance of theory and hands-on activities that will help you learn Docker from scratch.
 
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 the next level.

Course Objectives

If you are interested in gaining a good grasp of Docker in a systematic and hands-on way by working through a real-world project, then this course is for you.

The course will provide enough knowledge of the following:

• Docker and DevOps, why and how they integrate
• What containers are, how to create and manage them
• Scaling a delivery pipeline and multiple deployments with Docker
• Orchestration and delivery of containerized applications

Course Content

Course Outline
 
Lesson 1: Images and Containers

• How Docker Improves a DevOps Workflow
• Basic Docker Terminal Commands
• Dockerfile Syntax
• Building Images
• Running Containers From Images
• Versioning Images and Docker Hub
• Deploying a Docker Image to Docker Hub

Lesson 2: Application Container Management

• The docker-compose Tool
• Overview of a Multi-Container Application Setup
• Managing Multiple Containers and Distributed Application Bundles
• Networking with docker-compose

Lesson 3: Orchestration and Delivery

• An Overview of Docker Swarm
• Using Docker Engine to Create a Swarm
• Managing Services and Applications in a Swarm
• Scaling Services Up and Down

Course Overview

In this cloud native 5-day bootcamp, you will quickly learn the core skills you need to develop high performance, secure containerized applications and orchestrate them on Kubernetes before deep diving into advanced techniques for streamlining the container development process, instrumenting containers for production systems, and building fully containerized continuous integration pipelines. This bundle is meant to accelerate the containerization journey for developers and devops teams, by helping them take full advantage of all the opportunities containerization offers.

Course Content

This course combines all topics of CN100, CN120, and CN230

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.

Kubernetes Application Essentials

• 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

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

Do you work as a Business Analyst or do you have a role in the organisation where you are expected to write requirements? We all know how important it is to correctly articulate the needs of users, end-users and the customer (business) and to document these in such a way that all relevant parties (stakeholders) can find the requirements drafted and understand what the requirements mean.

Based on research and hard data, it has been established that not capturing the right requirements correctly formulated contributes to a project or product development not being successful, even though we met the deadline and stayed within budget.

How do I write good requirements, how do I know they are written correctly. Do the stakeholders understand what is written and does the requirement really express the needs of the stakeholder?

During this two-day workshop we will discuss writing correct requirements in the traditional way with many exercises. Which words can I use and which not? What do I have to pay attention to? What agreements do we make within the organisation?  The workshop consists of a number of modules in which we go a step further into the subject matter, all supported by many exercises.

From the traditional way of writing, we take the step to writing User Stories, based on identified Users/Users (User groups). We will pay attention to the level of detail in a User Story.

Target Audience

Deze training is voor iedereen die met requirements te maken krijgt:

• Business Analisten
• Product managers
• Project managers
• Product owners,
• en ook zeker andere stakeholders

Course Content

During the first day, we discuss the meaning of requirements, which types we distinguish and why this distinction is important. We think about how we can set up and structure requirements as efficiently and effectively as possible so that we can properly follow the lifecycle of a requirement. We start right away with assessing and writing requirements.

On the second day, we continue with what agreements we need to make in order to write the right requirements correctly, and we also make the step to using User Stories.

Day 1:

Introduction

What are requirements?            

Which types of requirements do we know,
Which templates we can use.
What is the need for requirments.
What are attributes

which type of attributes do we know
what is the necessity of attributes

Module 1:

Overarching aspects
Exercises
Per aspect max. 5 exercises
Per module multiple choice exercise, and rewrite actions.

Module 2:

Focused aspects
Exercises
Per aspect max. 5 exercises
Per module multiple choice exercise, and re-write actions.

Module 3:

On semantics (language) level – which words to use
Exercises
Per aspect max. 5 exercises
Per module multiple choice exercise, and rewrite actions.

Day 2:

Short review

Module 4:

On semantics level – continuation
Exercises
Per aspect max. 5 exercises
Per module multiple choice exercise, and rewrite actions.

Module 5:

Semantic level, overarching and psychological
Exercises
Per aspect max. 5 exercises
Per module multiple choice exercise, and re-write actions.

Module 6:

Tips and tricks – Models, Reviews, techniques (which ones in High Level)
User Stories – splits, models, approach…