Logo

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

WA-2684

Developing Microservices Training

Add to Wishlist
Alert Me

Description

Microservices TrainingDeveloping 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:

  • Architects
  • Software Reliability Engineers
  • Operations
  • Lead Application Developers
  • Application Developers
  • Technology Managers
$2995.00 List Price

5 Days Course

Class Dates

Request a Date or a Private Class below.


Add to Wishlist
MAX Educ. Savings
Category:
Loading ...