Architecting Microservices with Kubernetes, Docker, and Continuous Integration Training

Location and Pricing

Most Accelebrate courses are taught as private, customized training for 3 or more attendees at our clients' sites worldwide. In addition, we offer live, private online classes for teams who may be in multiple locations or wish to save on travel costs. Please visit our client list for organizations for whom we have delivered onsite training. To receive a customized proposal and price quote for private on-site or online training, please contact us.

Microservices Training Objectives

All students will:

Confidently use the stack outlined in the course

Understand the various key components

Apply the knowledge to migrate applications to microservice architected solutions on Docker, Kubernetes, and Jenkins with OpenShift

Understand the various components in an OpenShift environment for CI/CD

Microservices Training Outline

Introduction

Docker

What is Docker
Where Can I Run Docker?
Installing Docker Container Engine
Docker Machine
Docker and Containerization on Linux
Linux Kernel Features: cgroups and namespaces
The Docker-Linux Kernel Interfaces
Docker Containers vs Traditional Virtualization
Docker as Platform-as-a-Service
Docker Integration
Docker Services
Docker Application Container Public Repository
Competing Systems
Docker Command Line
Starting, Inspecting, and Stopping Docker Containers
Docker Volume
Dockerfile
Docker Compose
Using Docker Compose
Dissecting docker-compose.yml
Specifying services
Dependencies between containers
Injecting Environment Variables

Introduction to Kubernetes

What is Kubernetes
What is a Container
Container – Uses
Container – Pros
Container – Cons
Composition of a Container
Control Groups
Namespaces
Union Filesystems
Popular Containerization Software
Microservices
Microservices and Containers / Clusters
Microservices and Orchestration
Microservices and Infrastructure-as-Code
Kubernetes Container Networking
Kubernetes Networking Options
Kubernetes Networking – Balanced Design

Kubernetes – From the Firehose

What is Kubernetes?
Container Orchestration
Kubernetes Basic Architecture
Kubernetes Detailed Architecture
Kubernetes Concepts
Cluster and Namespace
Node
Master
Pod
Label
Annotation
Label Selector
Replication Controller and Replica Set
Service
Storage Volume
Secret
Resource Quota
Authentication and Authorization
Routing
Registry
Using Docker Registry

Getting Started with OpenShift

What is OpenShift/OKD
Differences between OpenShift and Kubernetes
Where OpenShift Fits in the IT Landscape?
OpenShift Releases
OpenShift Architecture
OpenShift - Infrastructure
OpenShift - Nodes
OpenShift - Pods
OpenShift – Registry
OpenShift - Service layer
OpenShift Origin Installation
Firewall Configuration
OpenShift CLI
OpenShift CLI (Contd.)
OpenShift – Volumes
OpenShift – Secrets
OpenShift – Secrets (Contd.)

CI/CD with OpenShift, Jenkins, and Blue Ocean

Jenkins Continuous Integration
Jenkins Features
Running Jenkins
Downloading and Installing Jenkins
Running Jenkins as a Stand-Alone Application
Running Jenkins on an Application Server
Installing Jenkins as a Windows Service
Different types of Jenkins job
Configuring Source Code Management(SCM)
Working with Subversion
Working with Subversion (cont'd)
Working with Git
Build Triggers
Schedule Build Jobs
Polling the SCM
Maven Build Steps
Configuring Jenkins to Access OpenShift/Kubernetes
Jenkins / OpenShift Pipeline
Jenkins / OpenShift Pipeline Output
Installing Jenkins Plugins
The Blue Ocean Plugin
Blue Ocean Plugin Features
New modern user experience
Advanced Pipeline visualizations with built-in failure diagnosis
Branch and Pull Request awareness
Personalized View
OpenShift Pipeline Output
Creating OpenShift Blue Ocean Pipeline

Operational Readiness

What is Operational Readiness
Telemetry
End-to-end Requirements Traceability
Log Strategy
Monitoring Strategy
Runbooks

Application Modernization

Next Generation Methodologies, Approaches, Tools, and Applications
What is Application Modernization
Typical App Modernization Projects
Why Modernization?
Goals for Application Modernization
Modernization Process
Modernization in a Nutshell
Modernization in a Nutshell - Analyze
Modernization in a Nutshell - Rationalize
Modernization in a Nutshell - Modernize
Modernization in a Nutshell – Supervise
What Can Be Done to Modernize Applications?
So, How Can Microservices Help Me?
The Data Exchange Interoperability Consideration
Microservices in Their Purest Form: AWS Lambdas
The Microservices Architecture Design Principles
Decentralized Processing
Crossing Process Boundary is Expensive!
Managing Microservices
Traditional Enterprise Application Architecture (Simplified)
Monolithic revisited
Monolithic vs. Microservices
Microservices Architecture Example (Simplified)
Maintaining State in App Modernization
Twelve-factor Applications
Twelve Factors, Microservices, and App Modernization
12-Factor Microservice Codebase
12-Factor Microservice Dependencies
12-Factor Microservice Config
12-Factor Microservice Backing Services
12-Factor Microservice Continuous Delivery
12-Factor Microservice Processes
12-Factor Microservice Data Isolation
12-Factor Microservice Concurrency
12-Factor Microservice Disposability
12-Factor Microservice Environment Parity
12-Factor Microservice Logs
12-Factor Microservice Admin Processes
Design for Failure
Fault Injection During System Testing
Messaging Architectures – Messaging Models
What is Kafka?
Kafka Architecture
Need for Kafka

Security in Microservices

Why Microservice Security?
Security Testing in Microservices
Security Topology
Authorization and Authentication
J2EE Security Refresh
Role-based Access Control in a Nutshell
Claim-based Access Control in a Nutshell
Sharing Sessions
Session Cookie
JSON Web Token (JWT)
Spring Security

Conclusion

Alabama

Birmingham

Huntsville

Montgomery

Alaska

Anchorage

Arizona

Phoenix

Tucson

Arkansas

Fayetteville

Little Rock

California

Los Angeles

Oakland

Orange County

Sacramento

San Diego

San Francisco

San Jose

Colorado

Boulder

Colorado Springs

Denver

Connecticut

Hartford

Washington

Florida

Fort Lauderdale

Jacksonville

Miami

Orlando

Tampa

Georgia

Atlanta

Augusta

Savannah

Hawaii

Honolulu

Idaho

Boise

Illinois

Chicago

Indiana

Indianapolis

Iowa

Ceder Rapids

Des Moines

Kansas

Wichita

Kentucky

Lexington

Louisville

Louisiana

New Orleans

Maine

Portland

Maryland

Annapolis

Baltimore

Frederick

Hagerstown

Massachusetts

Boston

Cambridge

Springfield

Michigan

Ann Arbor

Detroit

Grand Rapids

Minnesota

Minneapolis

Saint Paul

Mississippi

Jackson

Missouri

Kansas City

St. Louis

Nebraska

Lincoln

Omaha

Nevada

Las Vegas

Reno

New Jersey

Princeton

New Mexico

Albuquerque

New York

Albany

Buffalo

New York City

White Plains

North Carolina

Charlotte

Durham

Raleigh

Ohio

Akron

Canton

Cincinnati

Cleveland

Columbus

Dayton

Oklahoma

Oklahoma City

Tulsa

Oregon

Portland

Pennsylvania

Philadelphia

Pittsburgh

Rhode Island

Providence

South Carolina

Charleston

Columbia

Greenville

Tennessee

Knoxville

Memphis

Nashville

Texas

Austin

Dallas

El Paso

Houston

San Antonio

Utah

Salt Lake City

Virginia

Alexandria

Arlington

Norfolk

Richmond

Washington

Seattle

Tacoma

West Virginia

Charleston

Wisconsin

Madison

Milwaukee

Alberta

Calgary

Edmonton

British Columbia

Vancouver

Manitoba

Winnipeg

Nova Scotia

Halifax

Ontario

Ottawa

Toronto

Quebec

Montreal

Puerto Rico

San Juan

Architecting Microservices with Kubernetes, Docker, and Continuous Integration

Microservices Training Overview

Location and Pricing

Microservices Training Objectives

Microservices Training Outline

50%

50%

Course Number:

Duration:

Prerequisites:

Training Materials:

Software Requirements:

Contact Us:

Subscribe to our Newsletter:

Recent Training Locations