Course Overview

IBM Cloud Pak for AIOps deploys advanced, explainable AI across the IT Operations (IT Ops) toolchain so that you can confidently assess, diagnose, and resolve incidents across mission-critical workloads. IBM Cloud Pak for AIOps brings the depth and breadth of IBM’s enterprise expertise to managing complex, mission-critical IT environments. It helps you apply AI to IT operations to maximize efficiency, reduce costs, and maintain the resiliency and security you need to drive meaningful innovation.

This course is designed to teach you how to perform important post-installation administration and configuration tasks for the IBM Cloud Pak for AIOps v4.3 platform, such as user management, troubleshooting, importing topology, enriching event data, configuring self-monitoring, and making runbooks to expedite or automate solutions to IT problems.

Virtual Learning

This interactive training can be taken from any location, your office or home and is delivered by a trainer. This training does not have any delegates in the class with the instructor, since all delegates are virtually connected. Virtual delegates do not travel to this course, Global Knowledge will send you all the information needed before the start of the course and you can test the logins.

Course Objectives

After completing this course, you should be able to:

View runbook history

Understand how machine learning applies to IT operations problems

Explain the IBM Cloud Pak for AIOps architecture

Understand OpenShift concepts and terminology

Manage users and groups

Integrate the IBM Cloud Pak for AIOps console with an LDAP user repository

Create custom roles

Troubleshoot your environment

Monitor your IBM Cloud Pak deployment with the topology service

Course Content

Unit 1: IBM Cloud Pak for AIOps overview

Unit 2: Build connections to IBM Cloud Pak for AIOps

Unit 3. Essential troubleshooting skills

Unit 4. Configuring self-monitoring

Unit 5. Temporal, seasonal, and scope-based correlations

Unit 6. Topology import and event correlation’

Unit 7. Using runbooks, automations, and policies

Course Overview

During this four-day course, you learn about installing VMware Tanzu® Kubernetes GridTM in a VMware vSphere® environment and provisioning and managing Tanzu Kubernetes Grid clusters. The course covers how to install Tanzu Kubernetes Grid packages to provide services such as image registry, authentication, logging, ingress, multipod network interfaces, service discovery, image registry, and monitoring, in addition to day 2 operations such as backup, life cycle management, and application-specific tools. The concepts learned in this course are applicable for users who must install Tanzu Kubernetes Grid on supported clouds.

Course Objectives

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

  • Describe how Tanzu Kubernetes Grid fits in the VMware Tanzu® portfolio
  • Describe the Tanzu Kubernetes Grid architecture
  • Deploy and manage Tanzu Kubernetes Grid management and supervisor clusters
  • Deploy and manage Tanzu Kubernetes Grid workload clusters
  • Deploy, configure, and manage Tanzu Kubernetes Grid packages
  • Perform day 2 operations
  • Perform basic troubleshooting

Course Content


1 Course Introduction

  • Introductions and course logistics
  • Course objectives

2 Introducing Tanzu Kubernetes Grid

  • Describe Tanzu Kubernetes Grid
  • Describe VMware vSphere® with VMware Tanzu®
  • Describe VMware Tanzu® Mission ControlTM
  • Describe VMware Tanzu® for Kubernetes Operations
  • Describe the Tanzu Kubernetes Grid components
  • Discuss bootstrapping multiple Tanzu Kubernetes Grid instances
  • Describe vSphere Namespaces
  • Describe the benefits of registering with VMware Tanzu Mission Control

3 CLI Tools and Cluster API

  • Describe the Tanzu CLI and plug-ins
  • Describe the Kubernetes CLI Tools for vSphere
  • Describe the Carvel tool set
  • Describe Cluster API
  • List the infrastructure providers
  • Detail the Cluster API controllers
  • List the Cluster API custom resource definitions

4 Authentication

  • Define Kubernetes roles and RBAC API objects
  • Define Pinniped and OpenID Connect
  • Define Dex and LDAP authentication
  • Define VMware vCenter® Single Sign-On integration with Tanzu Kubernetes Grid
  • Identify the management cluster authentication components
  • Describe the Pinniped workflow in Tanzu Kubernetes Grid on a management cluster
  • Describe vSphere Namespace permissions and roles
  • Define authentication using vCenter Single Sign-On
  • Define authentication using external identity providers
  • Identify the authentication options for kubectl and the Tanzu CLI

5 Load Balancers

  • Explain load balancing in Tanzu Kubernetes Grid
  • Describe the different load balancers that integrate with Tanzu Kubernetes Grid
  • Describe the components of VMware NSX®Advanced Load BalancerTM
  • Explain how Tanzu Kubernetes Grid integrates with NSX Advanced Load Balancer

6 VMware Tanzu Kubernetes Grid on vSphere

  • Outline the requirements for deploying a supervisor cluster in a vSphere environment
  • Describe the different options for deploying the supervisor cluster
  • Describe the licensing requirements for supervisor clusters
  • List the steps to install a Tanzu Kubernetes Grid supervisor cluster and retrieve its status
  • Describe how to apply a full license to the supervisor cluster
  • List the requirements for deploying a management cluster in a vSphere environment
  • List the requirements for a bootstrap machine
  • List the requirements for Internet-restricted environments
  • Explain how the Tanzu Kubernetes Grid version relates to specific OVA versions
  • Describe the optional configuration for deploying a management cluster in a vSphere environment
  • List the steps to install a Tanzu Kubernetes Grid management cluster
  • Summarize the creation of a management cluster
  • Define the commands available for working with management clusters
  • List the steps to register Tanzu Kubernetes Grid management clusters with VMware Tanzu Mission Control

7 Tanzu Kubernetes Grid Workload Clusters

  • List the options for deploying Tanzu Kubernetes Grid workload clusters
  • Describe the different types of Tanzu Kubernetes Grid workload clusters
  • Explain how Tanzu Kubernetes Grid clusters are created
  • Describe the VMs that are included in a workload cluster
  • Describe the components of a workload cluster
  • Describe the difference between machine images and custom machine images
  • List the available customizations
  • Explain how to build custom images
  • Describe how to use custom images
  • Describe the commands available for working with workload clusters
  • Explain how to scale workload clusters
  • Describe machine health checks

8 Tanzu Kubernetes Grid Packages

  • Explain how Tanzu Kubernetes Grid uses packages
  • Identify the different package repositories
  • Describe the different types of packages and their dependencies
  • Define auto-managed packages
  • Identify the auto-managed packages that are installed to every cluster and those that are installed based on configuration
  • Explain how auto-managed packages are installed and configured
  • Define CLI-managed packages
  • Explain how CLI-managed packages are installed and configured
  • Use the Tanzu CLI to configure and install optional packages and repositories

9 Configuring and Managing Tanzu Kubernetes Grid Networking Packages

  • Describe cert-manager
  • Explain how to install cert-manager
  • Describe the Contour ingress controller
  • Explain how to install Contour
  • Describe service discovery
  • Describe ExternalDNS
  • Detail the configuration options for BIND servers
  • Explain how to install ExternalDNS
  • Describe Multus
  • Describe Multus pod configuration
  • Describe Whereabouts
  • Explain how to install Multus and Whereabouts

10 Configuring and Managing Tanzu Kubernetes Grid Operation and Analytics Packages

  • Describe Fluent Bit
  • Detail the logs that Fluent Bit collects
  • Describe basic Fluent Bit configuration
  • Explain how to install Fluent Bit
  • Describe Prometheus
  • Describe Grafana
  • Describe the Harbor image registry
  • Explain Harbor vulnerability scanning

11 Tanzu Kubernetes Grid Day 2 Operations

  • Explain the process of authenticating Tanzu Kubernetes Grid workload clusters
  • Identify the method of creating restricted role[1]based access to components inside a workload cluster
  • Explain how Tanzu Kubernetes Grid integrates with NSX Advanced Load Balancer for ingress
  • Describe VMware Tanzu® Application PlatformTM
  • List the steps to install Tanzu Application Platform on Tanzu Kubernetes Grid workload clusters
  • Describe the prerequisites and steps for upgrading Tanzu Kubernetes Grid instances
  • Describe the prerequisites and steps for updating Tanzu Kubernetes Grid workload clusters
  • Understand how VMware Tanzu Mission Control manages the life cycle of Tanzu Kubernetes Grid
  • Define Velero Plugin for vSphere and standalone Velero
  • Describe Velero Plugin for vSphere
  • Identify the steps to install Velero on workload clusters
  • Explain how to back up and restore workload clusters with the Velero CLI and VMware Tanzu Mission Control

12 Troubleshooting Tanzu Kubernetes Grid

  • Describe the various Tanzu Kubernetes Grid logs
  • Explain how to review the Cluster API controller Logs
  • Identify the location of the Tanzu Kubernetes Grid logs
  • Explain the purpose of Crash Diagnostics
  • Describe how to use SSH to connect to Tanzu Kubernetes Grid nodes
  • Explain how to troubleshoot package installation errors

Course Overview

The HPE Ezmeral Runtime Enterprise product certification course is an in-depth introduction to the platform offered by HPE. The course covers the key concepts and benefits of HPE Ezmeral Runtime Enterprise. In addition to lecture, this course contains labs for hands on experience with exploring and using HPE Ezmeral Runtime Enterprise.

Course Objectives

After you successfully complete this course,

you should be able to:

• Explain foundational concepts necessary for

understanding how HPE Ezmeral Runtime

Enterprise works

• Explain the HPE Ezmeral Runtime

Enterprise model, features and functions

• Perform installation and setup processes

• Configure various environments and

demonstrate key capabilities

Course Content

Container Foundations

• Container overview

• Key Docker concepts

• Key Kubernetes concepts

Introduction to HPE Ezmeral Runtime Enterprise

• Why HPE Ezmeral Runtime Enterprise

• HPE Ezmeral Runtime Enterprise architecture and deployment

options

• HPE Ezmeral Runtime Enterprise reference architectures and

configurations

Getting Started with HPE Ezmeral Platform

• Deployment planning

• Deployment planning for high availability

• Installing Ezmeral Runtime Enterprise

• Introduction to platform administration

HPE Ezmeral Data Fabric

• Introduction to HPE Ezmeral Data Fabric

• HPE Ezmeral Data Fabric architecture

• Introduction to using Ezmeral Data Fabric within Ezmeral

Runtime Enterprise

HPE Ezmeral Runtime Enterprise

Kubernetes Management

• Review of Kubernetes architecture in Ezmeral Runtime Enterprise

• Deploying an internal Kubernetes cluster

• Importing an external Kubernetes cluster

• Managing the cluster as a site admin or Kubernetes cluster

administrator

Deploying Kubernetes Applications on

the HPE Ezmeral Runtime Enterprise

• Introduction

• Running applications with deployment objects

• Adding services

• Deploying applications with Helm

• Deploying applications with KubeDirector

• Using FS Mounts and DataTaps with applications

• Using Apache Spark on HPE Ezmeral Runtime Enterprise

• Using Istio with HPE Ezmeral Runtime Enterprise

Using HPE Ezmeral MLOPs with

Kubernetes Clusters

• Introduction to MLOps

• Implementing ML projects on HPE Ezmeral Runtime Enterprise

• Setting up Kubeflow on HPE Ezmeral Runtime Enterprise

HPE Ezmeral Runtime Enterprise with EPIC

• Architecture review

• Installing EPIC hosts and setting up tenants

• Deploying applications

Operations

• Ezmeral Runtime Enterprise monitoring

• Using Nagios alerts

• Updates

Course Overview

In this course, you will learn how to use Amazon EKS to manage and orchestrate containers with Kubernetes. With Amazon EKS you can run Kubernetes on AWS without needing to install, operate, and maintain your own Kubernetes control plane. You will manage container images using Amazon Elastic Container Registry (Amazon ECR) and learn how to automate application deployment. You will deploy applications using continuous integration and delivery (CI/CD) tools. You will learn how to monitor and scale your environment by using metrics, logging, tracing, and horizontal and vertical scaling. You will  also manage storage for your containerized applications, configure AWS networking services to support  the cluster, and learn how to secure your Amazon EKS environment.

Activities

This course includes presentations, hands-on labs, demonstrations, and group exercises.

Course Objectives

In this course, you will learn to:

  • Describe the main components of Kubernetes, including the key objects and the core  components of the Kubernetes API.
  • Describe how Amazon EKS manages the Kubernetes control plane and parts of the data  plane.
  • Build and maintain an Amazon EKS cluster.
  • Deploy applications to an Amazon EKS cluster.
  • Manage applications running in enterprise-scale Amazon EKS clusters.
  • Configure efficient, secure communication both within the cluster and with outside services.
  • Configure observability in an Amazon EKS cluster.
  • Provision storage for applications running on Amazon EKS.
  • Secure an Amazon EKS cluster.

Course Content

Day 1

Module 1: Kubernetes Fundamentals

  • Benefits of containers
  • Container orchestration
  • Kubernetes internals
  • Pod scheduling
  • Kubernetes objects

Module 2: Amazon EKS Fundamentals

  • Introduction to Amazon EKS
  • Amazon EKS control plane
  • Amazon EKS data plane
  • Fundamentals of Amazon EKS security
  • Two APIs: Kubernetes and Amazon EKS
  • Hands-On Lab: Deploying Kubernetes Pods

Module 3: Building and maintaining an Amazon EKS cluster

  • Creating an Amazon EKS cluster
  • Deploying nodes
  • Planning for an upgrade
  • Upgrading your Kubernetes version

Module 4: Deploying Applications to Your Amazon EKS Cluster

  • Application deployment methods
  • Working with Amazon ECR
  • Deploying applications with Helm
  • Hands-On Lab: Deploying Applications

Day 2

Module 5: Managing Applications at Scale in Amazon EKS

  • Scale to meet demand in Amazon EKS
  • Continuous deployment in Amazon EKS
  • GitOps and Amazon EKS
  • Hands-On Lab: Continuous Deployment and GitOps

Module 6: Managing Networking in Amazon EKS

  • Review: Networking in AWS
  • Communicating in Amazon EKS
  • Improving Pod-level security
  • Load balancing with Services

Module 7: Configuring Observability in Amazon EKS

  • Configuring observability in an Amazon EKS cluster
  • Collecting metrics
  • Managing logs
  • Application tracing in Amazon EKS
  • Hands-On Lab: Monitoring Amazon EKS

Day 3

Module 8: Managing Storage in Amazon EKS

  • Design patterns for storage
  • Persistent storage in Kubernetes
  • Persistent storage with AWS storage services
  • Managing secrets
  • Hands-On Lab: Persistent Storage in Amazon EKS

Module 9: Managing Security in Amazon EKS

  • Cloud security fundamentals
  • Authentication and authorization
  • Managing IAM and RBAC
  • Managing Pod permissions using RBAC service accounts
  • Hands-On Lab: Capstone Exercis

Course Overview

A developer introduction to building and managing containers with Podman for deploying applications on Red Hat OpenShift.

Red Hat OpenShift Development I: Introduction to Containers with Podman (DO188) introduces students to building, running, and managing containers with Podman and Red Hat OpenShift Container Platform. This course helps students build the core skills for developing containerized applications through hands-on experience. The Red Hat Certified Specialist in Containers exam (EX188) is included in this offering.

This course is based on Red Hat® Enterprise Linux® 9, Podman 4.4 and Red Hat OpenShift® 4.14.

Virtual Learning

This interactive training can be taken from any location, your office or home and is delivered by a trainer. This training does not have any delegates in the class with the instructor, since all delegates are virtually connected. Virtual delegates do not travel to this course, Global Knowledge will send you all the information needed before the start of the course and you can test the logins.

Course Objectives

  • Introduction to containers
  • Run containers with Podman CLI and Podman Desktop
  • Build custom container images
  • Manage container images
  • Remote debugging with containers
  • Basic container networking
  • Persist data with containers
  • Run multi-container applications
  • Troubleshoot Container Deployments
  • Orchestrate containers with OpenShift and Kubernetes

Course Content

Introduction and overview of containers
Describe how containers facilitate application development.

Podman basics
Manage and run containers with Podman.

Container images
Navigate container registries to find and manage container images.

Custom container images
Build custom container images to containerize applications.

Persisting data
Run database containers with persistence.

Troubleshooting containers
Analyze container logs and configure a remote debugger.

Multi-container applications with compose
Run multi-container applications using Compose.

Container orchestration with Kubernetes and OpenShift
Orchestrate containerized applications with Kubernetes and OpenShift.

Course Overview

A developer introduction to building and managing containers with Podman for deploying applications on Red Hat OpenShift Container Platform.

Red Hat OpenShift Development I: Introduction to Containers with Podman (DO188) introduces students to building, running, and managing containers with Podman and Red Hat OpenShift Container Platform. This course helps students build the core skills for developing containerized applications through hands-on experience.

This course is based on Red Hat® Enterprise Linux® 8.6 and OpenShift® Container Platform 4.10.

Course Objectives

  • Introduction to containers
  • Run containers with Podman
  • Build custom container images
  • Manage container images
  • Remote debugging with containers
  • Basic container networking
  • Persist data with containers
  • Run multi-container applications
  • Troubleshoot Container Deployments
  • Orchestrate containers with OpenShift and Kubernetes

Course Content

Introduction and overview of containers
Describe how containers facilitate application development.

Podman basics
Manage and run containers with Podman.

Container images
Navigate container registries to find and manage container images.

Custom container images
Build custom container images to containerize applications.

Persisting data
Build persistent databases.

Container networking
Describe basic container networking and how to access containerized services.

Troubleshooting containers
Analyze container logs and configure a remote debugger.

Multi-container applications with compose
Run multi-container applications using Compose.

Container orchestration with Kubernetes and OpenShift
Orchestrate containerized applications with Kubernetes and OpenShift.

Course Overview

Design, build, and deploy containerized applications on Red Hat OpenShift

Red Hat OpenShift Development II: Containerizing Applications with exam (DO289) teaches you how to design, build, and deploy containerized software applications on an OpenShift cluster

Whether you are migrating existing applications or writing container-native applications, you will learn how to boost developer productivity powered by Red Hat® OpenShift Container Platform, a containerized application platform that allows enterprises to manage container deployments and scale their applications using Kubernetes.

The skills you learn in this course can be applied using all versions of Red Hat OpenShift, including Red Hat OpenShift on AWS (ROSA), Azure Red Hat OpenShift (ARO), and Red Hat OpenShift Container Platform.

This course is based on Red Hat OpenShift 4.12. The Red Hat Certified OpenShift Application Developer Exam (EX288) is included in this offering

Course Objectives

  • Features for developers in the Red Hat OpenShift web console
  • Building and publishing container images for Red Hat OpenShift
  • Managing container deployments on Red Hat OpenShift
  • Create and deploy multi-container applications on Red Hat OpenShift
  • Deploy multi-container applications using Helm Charts and Kustomize
  • Create health checks to monitor and improve application reliability
  • Creating CI/CD Workflows using Red Hat OpenShift Pipelines

Course Content

Red Hat OpenShift Container Platform for Developers

Define the Red Hat OpenShift architecture, concepts and terminology, and set up the developer environment.

Deploying Simple Applications

Deploy simple applications by using the Red Hat OpenShift web console and command-line tools.

Building and Publishing Container Images

Build, deploy and manage the lifecycle of container images by using a container registry.

Managing Red Hat OpenShift Builds

Describe the Red Hat OpenShift build process and build container images.

Managing Red Hat OpenShift Deployments

Describe the different Red Hat OpenShift deployment strategies and how to monitor the health of applications.

Deploying Multi-container Applications

Deploy multi-container applications by using Red Hat OpenShift templates, Helm charts, and Kustomize.

Continuous Deployment using Red Hat OpenShift Pipelines

Implement CI/CD workflows by using Red Hat OpenShift Pipelines.

Note: Course outline is subject to change with technology advances and as the nature of the underlying job evolves.

Course Overview

Course description

Plan, implement, and manage OpenShift clusters at scale

Red Hat OpenShift Administration III: Scaling Kubernetes Deployments in the Enterprise (DO380) expands upon the skills required to plan, implement, and manage OpenShift® clusters in the enterprise. You will learn how to support a growing number of stakeholders, applications, and users to achieve large-scale deployments.

This course is based on Red Hat® OpenShift Container Platform 4.10.

Note: This course is five days. Durations may vary based on the delivery. For full course details, scheduling, and pricing, select your location then “get started” on the right hand menu.

Course summary

– Manage OpenShift cluster operators and add operators.

– Automate OpenShift management tasks using Ansible® playbooks.

– Create and schedule cluster administration jobs.

– Implement GitOps workflows using Jenkins.

– Integrate OpenShift with enterprise authentication.

– Query and visualize cluster-wide logs, metrics, and alerts.

– Manage both shared, file-based storage and non-shared, block-based storage.

– Manage machine pools and machine configurations.

Course Objectives

This course builds upon the essential skills required to configure and manage an OpenShift 4.x cluster, teaching the enhanced skills needed to operate production environments at scale, including:

  • Automating Day 2 tasks to establish production clusters with higher performance and availability.
  • Integrating OpenShift with enterprise authentication, storage, CI/CD, and GitOps systems to improve productivity of IT operations and compliance with organization’s standards.
  • Troubleshooting techniques to identify issues with cluster operators and compute capacity.

Course Content

Move from Kubernetes to OpenShift

Demonstrate that OpenShift is Kubernetes by deploying Kubernetes-native applications on OpenShift.


Introduce automation on OpenShift

Automate OpenShift administration tasks using bash scripts and Ansible playbooks.


Manage operators with OpenShift

Deploy Kubernetes Operators and configure OpenShift cluster operators.


Implement GitOps with Jenkins

Implement a GitOps workflow using containerized Jenkins to administer an OpenShift cluster.


Configure enterprise authentication

Integrate OpenShift with enterprise identity providers.


Configure trusted TLS certificates

Configure OpenShift with trusted TLS certificates for external access to cluster services and applications.


Configure dedicated node pools

Configure a subset of the cluster nodes for special workloads.


Configure persistent storage

Configure storage providers and storage classes to ensure cluster user access to persistent storage.


Manage cluster monitoring and metrics

Configure and manage the OpenShift monitoring stack.


Provision and inspect cluster logging

Deploy, query, and troubleshoot cluster-wide logging.


Recover failed worker nodes

Inspect, troubleshoot, and remediate worker nodes in a variety of failure scenarios.


Note: Course outline is subject to change with technology advances and as the nature of the underlying job evolves. For questions or confirmation on a specific objective or topic, contact one of our Red Hatters..

Course Overview

Supporting the adoption of container technology through the development of container-native applications

The Container Adoption Boot Camp for Developers (DO720) immerses you in intensive, hands-on development of container-native applications deployed on Red Hat’s implementation of Kubernetes, Red Hat® OpenShift® Container Platform. As part of enrollment, you will receive one year of Red Hat Learning Subscription Standard, which gives you unlimited access to all of our courses online, plus up to five certification exams and two retakes. This boot camp is for those seeking to make a quantum leap in their journey toward digital transformation. Making this shift involves developing software in tight iterations so that business value can be realized sooner. In order to accomplish this goal, this offering can facilitate the adoption of container-native applications, including microservices.

This collection of courses is based on Red Hat OpenShift Container Platform 4.10.

Note: This course is five days. Durations may vary based on the delivery. For full course details, scheduling, and pricing, select your location then “get started” on the right hand menu.

Course content summary

– Introduction to containers, Kubernetes, and Red Hat OpenShift

– Deploy and manage applications on an OpenShift cluster

– Build and design containerized applications for OpenShift

– Create microservice-based applications with Quarkus

– Deploy microservices to an OpenShift cluster

– Build resilient services with Red Hat OpenShift Service Mesh

– Secure an OpenShift service mesh

Course Objectives

You should be able to demonstrate these skills:

  • Create and manage custom container images.
  • Deploy applications to OpenShift Container Platform.
  • Develop microservices using Quarkus.
  • Design container images to containerize applications.
  • Customize application builds and implement post-commit build hooks.
  • Create a multi-container application template.
  • Implement health checks to improve system reliability.
  • Implement unit and integration tests for microservices.
  • Use the Config specification to inject data into a microservice.
  • Implement fault tolerance in a microservice using OpenShift Service Mesh.
  • Secure an OpenShift Service Mesh.

Course Content

Introduction to container technology

Describe how software can run in containers orchestrated by OpenShift Container Platform.


Create containerized services

Provision a service using container technology.


Manage containers

Modify prebuilt container images to create and manage containerized services.


Manage container images

Manage the life cycle of a container image from creation to deletion.


Create custom container images

Design and code a Dockerfile to build a custom container image.


Deploy containerized applications

Deploy applications on OpenShift Container Platform.


Deploy multi-container applications

Deploy applications that are containerized using multiple container images.


Troubleshoot containerized applications

Troubleshoot a containerized application deployed on OpenShift.


Deploy and manage applications on an OpenShift cluster

Deploy applications using various application packaging methods to an OpenShift cluster and manage their resources.


Design containerized applications for OpenShift

Select a containerization method for an application and create a container to run on an OpenShift cluster.


Publish enterprise container images

Create an enterprise registry and publish container images to it.


Build applications

Describe the OpenShift build process, build triggers, and manage builds.


Create applications from OpenShift templates

Describe the elements of a template and create a multi-container application template.


Manage application deployments

Monitor application health and implement various deployment methods for cloud-native applications.


Implement continuous integration and continuous deployment pipelines in OpenShift

Create and deploy Jenkins pipelines to facilitate continuous integration and deployment with OpenShift.


Describe microservice architectures

Describe components and patterns of microservice-based application architectures.


Implement a microservice with Quarkus

Deploy Red Hat OpenShift Service Mesh on OpenShift Container Platform.


Test microservices

Implement unit and integration tests for microservices.


Deploy microservice-based applications

Deploy Quarkus microservice applications to an OpenShift cluster.


Build microservice applications with Quarkus

Build a persistent and configurable distributed quarkus microservices application.


Test microservices

Implement unit and integration tests for microservices.


Secure microservices

Secure a microservice using OAuth.


Monitor microservices

Monitor the operation of a microservice using metrics, distributed tracing, and log aggregation.


Introduction to Red Hat OpenShift Service Mesh

Describe the basic concepts of microservice architecture and OpenShift Service Mesh.


Observe a service mesh

Trace and visualize an OpenShift Service Mesh with Jaeger and Kiali.


Control service traffic

Manage and route traffic with OpenShift Service Mesh


Release applications with OpenShift Service Mesh

Release applications with canary and mirroring release strategies.


Test service resilience with chaos testing

Test the resiliency of an OpenShift Service Mesh with chaos testing.


Build resilient services

Use OpenShift Service Mesh strategies to create resilient services.


Secure an OpenShift Service Mesh

Secure and encrypt services in your application with OpenShift Service Mesh.

Course Overview

The Container Adoption Boot Camp (DO700) is for those seeking to make a quantum leap in their journey toward digital transformation. Making this shift involves developing software in tight iterations so that business value can be realized sooner. In order to accomplish this goal, this offering can facilitate the adoption of container-native applications, including microservices.

– Introduction to Containers, Kubernetes, and Red Hat OpenShift

– Configuring a Red Hat OpenShift cluster

– Describing advanced features of Red Hat OpenShift

– Containerizing software applications

– Developing microservices with MicroProfile

– Developing microservices with Red Hat® OpenShift Application Runtimes

Course Objectives

Impact on the organization

Microservices are a new alternative to designing modern applications, focused on working with less hardware resources and, therefore, reducing infrastructure costs. Many organizations are struggling with how to make the move from monolithic applications to applications based on microservices, as well as how to reorganize their development paradigm to reap the benefits of microservice development in a DevOps economy. In particular, many organizations are invested in Java programming frameworks and OpenShift.

This curriculum is intended to develop the skills needed to create microservices architectures using Red Hat OpenShift Container Platform, a cloud solution that leverages the usage of microservices running on containers. The curriculum develops the skills needed to install, configure, and manage OpenShift to deploy containerized applications that are highly available, resilient, and scalable. You will learn to containerize software applications and efficiently deploy them to an OpenShift cluster, allowing you to take advantage of a platform and architecture that fosters DevOps principles in your organization.

Red Hat has created this course in a way intended to benefit our customers, but each company and infrastructure is unique, and actual results or benefits may vary.

Impact on the individual

As a result of attending this course, you should be able to configure and manage a Red Hat OpenShift Container Platform cluster and know how to develop, monitor, test, and deploy microservice-based Java EE applications using Wildfly Swarm and OpenShift.

You should be able to demonstrate these skills:

  • Create containerized services using Docker.
  • Manage containers and container images.
  • Create custom container images.
  • Deploy containerized applications on Red Hat OpenShift.
  • Deploy multi-container applications.
  • Install Red Hat OpenShift Container Platform to create a simple cluster.
  • Configure and manage Red Hat OpenShift masters and nodes.
  • Secure Red Hat OpenShift with a simple internal authentication mechanism.
  • Control access to resources on Red Hat OpenShift.
  • Deploy applications on Red Hat OpenShift using source-to-image facility.
  • Configure and manage Red Hat OpenShift pods, services, routes, secrets, and other resources.
  • Deploy applications to a Red Hat OpenShift cluster and manage them with the command-line client and the web console.
  • Design and build containers for applications for successful deployment to a Red Hat OpenShift cluster.
  • Publish container images to an enterprise registry.
  • Build containerized applications using the source-to-image facility.
  • Create applications using Red Hat OpenShift templates.
  • Extract a service from a monolithic application and deploy it to the cluster as a microservice.
  • Migrate applications to run on a Red Hat OpenShift cluster.
  • Design a microservices-based architecture for an enterprise application.
  • Implement fault tolerance and health checks for microservices.
  • Secure microservices to prevent unauthorized access.

Course Content

Create custom container images

Create containers, manage containers, and manage container images.


Deploy containerized applications

Customize containers and deploy on Red Hat OpenShift.


Troubleshoot containerized applications

Troubleshoot Red Hat OpenShift deployments.


Explore Red Hat OpenShift networking concepts

Describe Red Hat OpenShift networking concepts and troubleshoot with CLI.


Manage Red Hat OpenShift resources

Control access to Red Hat OpenShift resources, implement persistent storage, and manage application deployments.


Containerize applications

Understand deployment methods, designing containers, and integrated registry and image streams.


Manage application deployments

Manage advanced application deployments and Red Hat OpenShift templates.


Design a highly available cluster

Design and install a highly available cluster, custom certificates, and log aggregation, in addition to gaining an understanding of Gluster container-native storage, managing system resources, and configuring advanced networking.


Implement microservice architecture

Describe microservice architectures, deploy microservices, and implement with MicroProfile.


Test microservices

Run microservices, inject configuration data, and perform health checks.


Implement fault tolerance

Apply fault tolerance, develop an API gateway for a series of microservices, and secure with JWT.


Secure microservices with JWT

Use the JSON Web Token specification to secure a microservice.


Create microservices with Red Hat OpenShift Application Runtimes

Receive an introduction to OpenShift Application Runtimes and Fabric8.


Install Red Hat OpenShift Container Platform

Install, monitor, and manage OpenShift Container Platform.


Customize source-to-image builds

Tailor source-to-image builds and migrate applications to Red Hat OpenShift.


Develop and deploy runtimes

Employ the WildFly Swarm, Vert.x, and Spring Boot runtimes to develop and deploy microservices.


Monitor microservices

Track the operation of a microservice using metrics, distributed tracing, and log aggregation.