Maxtrain.com - [email protected] - 513-322-8888 - 866-595-6863

WA-2684

Developing Microservices Training

Name: Developing Microservices Training
SKU: 19281
Price: 2995 USD
Availability: InStock

Add to Wishlist

Download PDF

Description

Developing Microservices

This five-day DevOps training class is loaded with practical real-world information. From the foremost Service-Oriented-Architecture/DevOps/Agile development training company, comes a course to move the dial on your organizations’ journey with this workshop. You will leave this course loaded with knowledge on the usage of this stack for Microservices. This class combines instructor-led and hands-on lab exercises.

TOPICS

Microservices
CI/CD
Microservice Container Management
Docker
Message-based microservices architecture
Couchbase schema on read for microservices

After completing this course, the student should be able to:

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 a containerized microservice environment for CI/CD

What are microservices?

The central idea behind microservices is that some types of applications become easier to build and maintain when they are broken down into smaller, composable pieces that work together.

Each component is continuously developed and separately maintained, and the application is then simply the sum of its constituent components. This is in contrast to a traditional, “monolithic” application which is all developed all in one piece.

Applications built as a set of modular components are easier to understand, easier to test, and most importantly easier to maintain over the life of the application. It enables organizations to achieve much higher agility and be able to vastly improve the time it takes to get working improvements to production. This approach has proven to be superior, especially for large enterprise applications that are developed by teams of geographically and culturally diverse developers.

There are other benefits:

Developer independence: Small teams work in parallel and can iterate faster than large teams.
Isolation and resilience: If a component dies, you spin up another while and the rest of the application continues to function.
Scalability: Smaller components take up fewer resources and can be scaled to meet increasing demand of that component only.
Lifecycle automation: Individual components are easier to fit into continuous delivery pipelines and complex deployment scenarios not possible with monoliths.
Relationship to the business: Microservice architectures are split along business domain boundaries, increasing independence and understanding across the organization.

Outline

Chapter 1. Microservice Development

What are Microservices?
Microservices vs Classic SOA
Principles of Microservices Architecture Design
Business Domain-Centric Design
Designing for failure
Microservices Architecture – Pros
Microservices Architecture – Cons
Docker and Microservices
Microservice Deployment with Docker – Workflow
Writing Dockerfile
Kubernetes
What is OpenShift
OpenShift Architecture
Microservices and Various Applications
Web Applications
Web Applications – Reference Architecture
Web Applications – When to use?
Rich Client Applications
Rich Client Applications – Reference Architecture
Rich Client Applications – When to use?
Rich Internet Applications
Rich Internet Applications – Reference Architecture
Rich Internet Applications – When to use?
Mobile Applications
Mobile Applications – Reference Architecture
Mobile Applications – When to use?
Service Applications
Service Applications – Reference Architecture
Service Applications – When to use?
Single Page Applications
Single Page Applications – Benefits
Traditional Enterprise Application Architecture
Sample Microservices Architecture
Serverless & Event-driven Microservice – AWS Lambda
Summary

Chapter 2. REST Services

Many Flavors of Services
Understanding REST
Principles of RESTful Services
REST Example – Create
REST Example – Retrieve
REST Example – Update
REST Example – Delete
REST Example – Client Generated ID
SOAP Equivalent Examples
REST Example – JSON
REST vs SOAP Communication
More REST vs SOAP
REST vs SOAP Summary
RESTful Services Usage
Additional Resources
Summary

Chapter 3. Advanced Objects and Functionality in JavaScript

JavaScript Evolution
Basic Objects
Constructor Function
More on the Constructor Function
Object Properties
Deleting a Property
The instanceof Operator
Object Properties
Constructor and Instance Objects
Constructor Level Properties
Namespace
Functions Are First-Class Objects
Closures
Closure Examples
Private Variables with Closures
Immediately Invoked Function Expression (IIFE)
The Module Pattern
Module Pattern Example
Prototype
Inheritance in JavaScript
The Prototype Chain
Traversing Prototype Property Hierarchy
Prototype Chain
Inheritance Using Prototype
Extending Inherited Behavior
Enhancing Constructors
Improving Constructor Performance
Inheritance with Object.create
The hasOwnProperty Method
Summary

Chapter 4. React Overview

What is React?
What's in a Name?
React Component Model
What React Is Not
What You Will Not Find in React
Motivation for Creating React
A React JavaScript Example
One-Way Data Flow
JSX
A JSX Example
The Virtual (Mock) DOM
Only Sub-components that Actually Change are Re-Rendered
React Libraries
Summary

Chapter 5. Programming with React API

React Programming Options
Components vs Elements
Three Ways to Create a React UI Component
React API On-Line Documentation
Setting Up the Libraries
The ReactDOM Object
The ReactDOM Object (Cont'd)
The React Object
The React.createElement Method
The ReactElement Object
The ReactElement Structure
The React.DOM Object
The React.PropTypes Object
The React.Children Object
The propTypes Object
Lifecycle Methods (Applied only to ES6 Classes)
Summary

Chapter 6. Basic Components and JSX

What is JSX?
JSX Transpilation to React Code Example
Running the Transpiled Code
Babel
Babel JavaScript Library
Script Import Skeleton Code
Playing Around in CodePen
React Components and Properties (Props)
Ways to Create UI Components
Creating a Functional Component Example
Component Names Must Be Capitalized
Creating a UI Component with React.createClass()
The render Method Object
Creating a UI Component Using ES6 Class Notation
Using ES6 Classes with React
Which UI Component Creation Syntax Should I Use?
Components vs Elements
Elements Are Immutable
Properties
Property Naming Convention
Properties Default to 'True'
Spread Attributes (an ES6 Feature)
Expressions
Summary

Chapter 7. Introduction to Node.js

What Is Node.js?
Application of Node.js
Installing Node.js and NPM
"Hello, Node World!"
How It Works
Built on JavaScript: Benefits
Traditional Server-Side I/O Model
Disadvantages of the Traditional Approach
Event-Driven, Non-Blocking I/O
Concurrency
Using Node Package Manager (NPM)
Express
Microservices with Node.js
The Express Package
Installing and Using Express
Defining Routing Rules in Express
Route Path
The Response Object
A Simple Web Service with Express Example
Composite Services
Example - Call an API Using a Promise
Using the callApi() Function
Summary

Chapter 8. Extending React

The Need to Extend React
Redux
Redux Design Ideas
React Router
React Router Code Examples
Issues With Manual Module Management
Webpack
Testing React Apps: ReactTestUtils
Testing React Apps: Jest
Testing with Jest and Enzyme
Summary

Chapter 9. React Component Concepts

Nesting JSX Elements
Example of JSX Nesting
Comments in JSX Code
JSX Escapes Values
Event Handling
Event Handler Example
Working with Lists of Items
Keys in Lists
Example List With Key
Container vs. Presentational Components
State
Types of State Data
State Hierarchy
Lift State Up
Props vs. State
Pass Down a Function
Immutability
Immutability – Why?
Virtual DOM and State
Setting state
Updating Input fields
Passing Props to Components
Passing Functions to Components
Event Binding - DOs
Event Binding – Don'ts
Passing Parameters to Event Handlers
App Development Workflow – 1/3
App Development Workflow – 2/3
App Development Workflow – 3/3
Summary

Chapter 10. Introduction to Spring Boot

What is Spring Boot?
Spring Boot Main Features
Spring Boot on the PaaS
Understanding Java Annotations
Spring MVC Annotations
Example of Spring MVC-based RESTful Web Service
Spring Booting Your RESTful Web Service
Spring Boot Skeletal Application Example
Converting a Spring Boot Application to a WAR File
Externalized Configuration
Starters
The 'pom.xml' File
Spring Boot Maven Plugin
HOWTO: Create a Spring Boot Application
Summary

Chapter 11. Spring MVC

Spring MVC
Spring Web Modules
Spring MVC Components
DispatcherServlet
Template Engines
Spring Boot MVC Example
Spring MVC Mapping of Requests
Advanced @RequestMapping
Composed Request Mappings
Spring MVC Annotation Controllers
Controller Handler Method Parameters
Controller Handler Method Return Types
View Resolution
Spring Boot Considerations
Summary

Chapter 12. Overview of Spring Database Integration

DAO Support in Spring
Spring Data Access Modules
Spring JDBC Module
Spring ORM Module
DataAccessException
@Repository Annotation
Using DataSources
DAO Templates
DAO Templates and Callbacks
ORM Tool Support in Spring
Summary

Chapter 13. Using Spring with JPA or Hibernate

Spring JPA
Benefits of Using Spring with ORM
Spring @Repository
Using JPA with Spring
Configure Spring Boot JPA EntityManagerFactory
Application JPA Code
"Classic" Spring ORM Usage
Spring JpaTemplate
Spring JpaCallback
JpaTemplate Convenience Features
Spring Boot Considerations
Spring Data JPA Repositories
Summary

Chapter 14. Spring REST Services

REST Services With Spring MVC
Spring MVC Components
Spring MVC @RequestMapping with REST
Working With the Request Body and Response Body
@RestController Annotation
Implementing JAX-RS Services and Spring
JAX-RS Annotations
Spring Security
Spring Security Options
Spring Security Features
Java Clients Using RestTemplate
RestTemplate Methods
Summary

Chapter 15. Spring Security

Securing Web Applications with Spring Security 3.0
Spring Security 3.0
Authentication and Authorization
Programmatic v Declarative Security
Getting Spring Security from Maven
Spring Security Configuration
Spring Security Configuration Example
Authentication Manager
Using Database User Authentication
LDAP Authentication
Summary

Chapter 16. Spring JMS

Spring JMS
JmsTemplate
Connection and Destination
JmsTemplate Configuration
Transaction Management
Example Transaction Configuration
Producer Example
Consumer Example
Converting Messages
Message Listener Containers
Message-Driven POJO's Async Receiver Example
Message-Driven POJO's Async Receiver Configuration
Spring Boot Considerations
Summary

Chapter 17. Introduction to Couchbase

What is Couchbase?
Key Components of Couchbase
Benefits of Couchbase
Basics of Data Modeling
Modeling One-to-many Relationship
Modeling Many-to-many
Doing a Query
About Query Index
Example MapReduce View
Summary

Chapter 18. Introduction to Couchbase Programming Using Java

Getting Started
Opening a Connection
Creating Index
Doing a Query Using MapReduce View
Doing an N1QL Query
Retrieve a Document by ID
Adding a Document
Updating a Document
Deleting a Document
Summary

Chapter 19. Introduction to KAFKA

Messaging Architectures – What is Messaging?
Messaging Architectures – Steps to Messaging
Messaging Architectures – Messaging Models
What is Kafka?
What is Kafka? (Contd.)
Kafka Overview
Kafka Overview (Contd.)
Need for Kafka
Kafka Partitions
Kafka Architecture
Core concepts in Kafka
Kafka Topic
Kafka Producer
Kafka Consumer
Kafka Broker
Kafka Cluster
Why Kafka Cluster?
Sample Multi-Broker Cluster
Overview of ZooKeeper
Kafka Cluster & ZooKeeper
Who Uses Kafka?
Summary

Chapter 20. Using Apache Kafka

Installing Apache Kafka
Configuration Files
Starting Kafka
Using Kafka Command Line Client Tools
Setting up a Multi-Broker Cluster
Using Multi-Broker Cluster
Kafka Connect
Kafka Connect – Configuration Files
Using Kafka Connect to Import/Export Data
Creating a Spring Boot Producer
Adding Kafka dependency to pom.xml
Defining a Spring Boot Service to Send Message(s)
Defining a Spring Boot Controller
Testing the Spring Boot Producer
Creating a Nodejs Consumer
Summary

Chapter 21. 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
Summary

Chapter 22. 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
Summary

Chapter 23. Docker Introduction

What is Docker
Where Can I Ran Docker?
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
Summary

Chapter 24. CI/CD with OpenShift, Jenkins, and Blue Ocean

What is OpenShift
OpenShift Online
OpenShift Origin
OpenShift Architecture
OpenShift Origin Installation
OpenShift CLI
OpenShift CLI (Contd.)
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
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
Summary

Chapter 25. Operational Readiness

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

Chapter 26. Application Modernization

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
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
Monolithic revisited
Monolithic vs. Microservices
Maintaining State in App Modernization
Cloud Service Fabric
Summary

Chapter 27. Introduction to Feign

What is Feign
Feign - Annotations
Creating a REST client with Feign
Benefits of using Feign
Feign – Default Beans
FeignFeign – Simple Example
Multiple Interfaces
Ribbon
Ribbon Load Balancing Architecture
Using Ribbon
Ribbon and Feign
Hystrix
Hystrix Dependency
Using Hystrix
Summary

Chapter 28. Activiti Workflow

Business Process Management
Business Process Model and Notation
BPMN (Contd.)
BPMN – Elements
BPMN 2.0
What is Activiti
Activiti – Components
Activiti – Alternative Modeling GUI
Activiti – Sample workflow in Activit Process Modeler
Using Spring Boot with Activiti
Spring Boot with Activiti – Getting Started
Spring Boot with Activiti – Simple Application
Spring Boot with Activiti – Add BPMN 2.0 process definition
Spring Boot with Activiti – Create a CommandLineRunner
Spring Boot with Activiti – Create a Bean
Spring Boot with Activiti – Start the Application
Summary

Lab Exercises

Lab 1. Setting Up a React Development Environment
Lab 2. Basic React Components
Lab 3. More React Component Concepts
Lab 4. A Simple RESTful API in Spring Boot
Lab 5. Use the Spring Web MVC Web Framework under Spring Boot
Lab 6. Use the Spring JDBCTemplate under Spring Boot
Lab 7. Use the Spring Data JPA under Spring Boot
Lab 8. Create a RESTful API with Spring Boot
Lab 9. Create a RESTful Client with Spring Boot
Lab 10. Enable Basic Security
Lab 11. Use AMQP Messaging with Spring Boot
Lab 12. Use Netflix Eureka for Service Discovery
Lab 13. Use Netflix Ribbon for Client-Side Load Balancing
Lab 14. Use Netflix Hystrix for the Circuit Breaker Pattern
Lab 15. Develop a Simple AWS Lambda Function
Lab 16. Create Microservice Using AWS Lambda and Couchbase
Lab 17. Kafka Basics
Lab 18. Apache Kafka with Spring Boot and Nodejs
Lab 19. Debugging a Node.js Application
Lab 20. Kubernetes Hello World
Lab 21. Secret Handling in Kubernetes
Lab 22. Create an OpenShift Jenkins Pipeline for a Microservice
Lab 23. Create an OpenShift Blue Ocean Pipeline for a Microservice
Lab 24. Creating a REST Client with Feign

PreRequisites

A desire to learn how this Microservices toolchain can improve your organization effectiveness, build & release processes, application architecture & development, and business continuity for greenfield and application modernization

Audience

This course will be particularly useful for architects, technology managers, and development leaders implementing or considering Microservices and DevOps for their organization including the following: