Technical Introduction to Microservices Training

Technical Introduction to Microservices Training

This Technical Introduction to Microservices training course will help you understand the value proposition and technical aspects of microservices, a new and rather fuzzy concept used to describe rapidly provisionable, independently deployable services with narrow and distinct functionality.

Benefits

  • Gain a fundamental understanding of microservices and practical experience in implementing microservices using different technology stacks.

Outline

  1. Breaking Up Monoliths — Pros and Cons
  2. Traditional Monolithic Applications and Their Place
  3. Disadvantages of Monoliths
  4. Developer's Woes
  5. Architecture Modernization
  6. Architecture Modernization Challenges
  7. Microservices Architecture is Not a Silver Bullet!
  8. What May Help?
  9. In-Class Discussion
  10. Microservice Development
  11. What are Microservices?
  12. Microservices vs Classic SOA
  13. Principles of Microservices Architecture Design
  14. Domain-Driven Design
  15. Domain-Driven Design - Benefits
  16. Microservices and Domain-Driven Design
  17. Designing for failure
  18. Microservices Architecture — Pros
  19. Microservices Architecture — Cons
  20. Docker and Microservices
  21. Microservice Deployment with Docker — Workflow
  22. Writing Dockerfile
  23. Kubernetes
  24. What is OpenShift
  25. OpenShift Architecture
  26. Microservices and Various Applications
  27. Web Applications
  28. Web Applications — Reference Architecture
  29. Web Applications — When to use?
  30. Single Page Applications
  31. Single Page Applications — Benefits
  32. Traditional Enterprise Application Architecture
  33. Sample Microservices Architecture
  34. Serverless & Event-driven Microservice — AWS Lambda
  35. Twelve-factor Applications
  36. Twelve-factor Applications
  37. Twelve Factors, Microservices, and App Modernization
  38. The Twelve Factors
  39. Categorizing the 12 Factors
  40. Microservice Codebase
  41. Microservice Dependencies
  42. Microservice Config
  43. Microservice Backing Services
  44. Microservice Build, Release, Run
  45. Microservice Processes
  46. Microservice Port Binding
  47. Microservice Concurrency
  48. Microservice Disposability
  49. Microservice Dev/Prod Parity
  50. Microservice Logs
  51. Microservice Admin Processes
  52. Kubernetes and the Twelve Factors
  53. Codebase
  54. Dependencies
  55. Config
  56. Backing Services
  57. Build, Release, Run
  58. Processes
  59. Port Binding
  60. Concurrency
  61. Disposability
  62. Dev/Prod Parity
  63. Logs
  64. Admin Processes
  65. REST Services
  66. Many Flavors of Services
  67. Understanding REST
  68. Understanding REST
  69. Principles of RESTful Services
  70. REST Example — Create
  71. REST Example — Retrieve
  72. REST Example — Update
  73. REST Example — Delete
  74. REST Example — Client Generated ID
  75. SOAP Equivalent Examples
  76. REST Example — JSON
  77. Famous RESTful Services
  78. Additional Resources
  79. What is gRPC?
  80. Protocol Buffers
  81. REST vs. gRPC
  82. Protobuf vs. JSON
  83. HTTP/2 vs. HTTP 1.1
  84. Messages vs. Resources and Verbs
  85. Streaming vs. Request-Response
  86. Strong Typing vs. Serialization
  87. Web Browser Support
  88. REST vs. gRPC — In a Nutshell
  89. Microservices with Node.js
  90. What is Node.js?
  91. Node's Value Proposition
  92. Example of a Node.js App: a Simple Web Server
  93. Node.js Project Types
  94. Managing Large Applications
  95. Core Modules
  96. Why Node.js uses JavaScript?
  97. The Traditional Concurrency Support Model
  98. Disadvantages of the Traditional Approach
  99. Event-Driven, Non-Blocking I/O
  100. The Success Callback Function
  101. Using Node Package Manager (NPM)
  102. NPM Registry (Repository)
  103. NPM Enterprise
  104. Package Life-Cycle Management
  105. Local and Global Package Installation Options
  106. Listing and Using Module Versions
  107. The Express Package
  108. Installing and Using Express
  109. Defining Routing Rules in Express
  110. Route Path
  111. The Response Object
  112. A Simple Web Service with Express Example
  113. The MEAN Stack
  114. Introduction to Spring Boot for Non-Java Developers
  115. What is Spring Boot?
  116. Spring Boot Main Features
  117. Spring Boot vs DropWizard
  118. Spring Boot on the PaaS
  119. Understanding Java Annotations
  120. Spring MVC Annotations
  121. Example of Spring MVC-based RESTful Web Service
  122. Spring Booting Your RESTful Web Service
  123. Spring Boot Skeletal Application Example
  124. Converting a Spring Boot Application to a WAR File
  125. Spring REST Services
  126. Many Flavors of Services
  127. Understanding REST
  128. RESTful Services
  129. REST Resource Examples
  130. REST vs SOAP
  131. REST Services With Spring MVC
  132. Spring MVC @RequestMapping with REST
  133. Working With the Request Body and Response Body
  134. @RestController Annotation
  135. Implementing JAX-RS Services and Spring
  136. JAX-RS Annotations
  137. Java Clients Using RestTemplate
  138. RestTemplate Methods
  139. Spring Security
  140. Securing Web Applications with Spring Security 3.0
  141. Spring Security 3.0
  142. Authentication and Authorization
  143. Programmatic v Declarative Security
  144. Getting Spring Security Gradle or Maven
  145. Spring Security Configuration
  146. Spring Security Configuration Example
  147. Authentication Manager
  148. Using Database User Authentication
  149. LDAP Authentication
  150. What is Security Assertion Markup Language (SAML)?
  151. What is a SAML Provider?
  152. Spring SAML2.0 Web SSO Authentication
  153. Setting Up an SSO Provider
  154. Adding SAML Dependencies to a Project
  155. Dealing with the State
  156. How Can I Maintain State?
  157. SAML vs. OAuth2
  158. OAuth2 Overview
  159. OAuth — Facebook Sample Flow
  160. OAuth Versions
  161. OAuth2 Components
  162. OAuth2 — End Points
  163. OAuth2 — Tokens
  164. OAuth — Grants
  165. Authenticating Against an OAuth2 API
  166. OAuth2 using Spring Boot — Dependencies
  167. OAuth2 using Spring Boot — application.yml
  168. OAuth2 using Spring Boot — Main Class
  169. OAuth2 using Spring Boot — SPA Client
  170. JSON Web Tokens
  171. JSON Web Token Architecture
  172. How JWT Works
  173. JWT Header
  174. JWT Payload
  175. JWT Example Payload
  176. JWT Example Signature
  177. How JWT Tokens are Used
  178. Adding JWT to HTTP Header
  179. How The Server Makes Use of JWT Tokens
  180. What are Scopes?
  181. JWT with Spring Boot — Dependencies
  182. JWT with Spring Boot — Main Class
  183. AWS Lambda
  184. What is AWS Lambda?
  185. Supported Languages
  186. Getting Your Code Up And Running in Lambda
  187. Examples of the Base Lambda Function
  188. Use Cases
  189. How It Works
  190. Example: Processing S3 Source Events with Lambda
  191. The Programming Model
  192. Configuring Lambda Functions
  193. Configure Triggers Page
  194. Lambda Function Blueprints
  195. How Do I Troubleshoot and Monitor My Lambda Functions?
  196. Developing Lambda in Java
  197. Consuming REST Services from a Client
  198. Accessing REST Services using jQuery - GET Example
  199. Accessing REST Services using jQuery - POST Example
  200. Accessing REST Services in React - Component
  201. Accessing REST Services in React - componentDidMount
  202. Accessing REST Services in React - render
  203. Accessing REST Services in React - POST Method
  204. The Angular HTTP Client
  205. Using The HTTP Client - Overview
  206. Importing HttpClientModule
  207. Simple Example
  208. Service Using HttpClient
  209. ES6 Import Statements
  210. Making a GET Request
  211. What does an Observable Object do?
  212. Using the Service in a Component
  213. The PeopleService Client Component
  214. Error Handling
  215. Making a POST Request
  216. Making a PUT Request
  217. Making a DELETE Request
  218. Docker Introduction
  219. What is Docker
  220. Where Can I Run Docker?
  221. Installing Docker Container Engine
  222. Docker Machine
  223. Docker and Containerization on Linux
  224. Linux Kernel Features: cgroups and namespaces
  225. The Docker-Linux Kernel Interfaces
  226. Docker Containers vs Traditional Virtualization
  227. Docker Containers vs Traditional Virtualization
  228. Docker Integration
  229. Docker Services
  230. Docker Application Container Public Repository
  231. Competing Systems
  232. Docker Command Line
  233. Starting, Inspecting, and Stopping Docker Containers
  234. Docker Volume
  235. Dockerfile
  236. Docker Compose
  237. Using Docker Compose
  238. Dissecting docker-compose.yml
  239. Specifying services
  240. Dependencies between containers
  241. Injecting Environment Variables
  242. runC Overview
  243. runC Features
  244. Using runC
  245. Running a Container using runC
  246. Introduction to Kubernetes
  247. What is Kubernetes
  248. What is a Container
  249. Container — Uses
  250. Container — Pros
  251. Container — Cons
  252. Composition of a Container
  253. Control Groups
  254. Namespaces
  255. Union Filesystems
  256. Popular Containerization Software
  257. Microservices
  258. Microservices and Containers / Clusters
  259. Microservices and Orchestration
  260. Microservices and Infrastructure-as-Code
  261. Kubernetes Container Networking
  262. Kubernetes Networking Options
  263. Kubernetes Networking — Balanced Design
  264. CI/CD with OpenShift, Jenkins, and Blue Ocean
  265. What is OpenShift
  266. OpenShift Online
  267. OpenShift Origin
  268. OpenShift Architecture
  269. OpenShift Origin Installation
  270. OpenShift CLI
  271. Jenkins Continuous Integration
  272. Jenkins Features
  273. Running Jenkins
  274. Downloading and Installing Jenkins
  275. Running Jenkins as a Stand-Alone Application
  276. Running Jenkins on an Application Server
  277. Installing Jenkins as a Windows Service
  278. Different types of Jenkins job
  279. Configuring Source Code Management(SCM)
  280. Working with Subversion
  281. Working with Git
  282. Build Triggers
  283. Schedule Build Jobs
  284. Polling the SCM
  285. Maven Build Steps
  286. Jenkins / OpenShift Pipeline
  287. Jenkins / OpenShift Pipeline Output
  288. Installing Jenkins Plugins
  289. The Blue Ocean Plugin
  290. Blue Ocean Plugin Features
  291. New modern user experience
  292. Advanced Pipeline visualizations with built-in failure diagnosis
  293. Branch and Pull Request awareness
  294. Personalized View
  295. OpenShift Pipeline Output
  296. Creating OpenShift Blue Ocean Pipeline
  297. Appendix A - Appendix A: Leading Practices for Microservice Logging
  298. Logging Challenges
  299. Leading Practices
  300. Correlate Requests with a Unique ID
  301. Include a Unique ID in the Response
  302. Send Logs to a Central Location
  303. Structure Your Log Data
  304. Add Context to Every Record
  305. Examples of Content
  306. Write Logs to Local Storage
  307. Collecting Logs with Fluentd
  308. Leading Practices for Microservice Logging Summary
  309. Metrics Using Prometheus
  310. Overview
  311. Prometheus
  312. Prometheus Architecture
  313. Service Discovery
  314. File-based Service Discovery
  315. Istio and Prometheus
  316. Exposing Metrics in Services
  317. Querying in Prometheus
  318. Grafana
  319. Business Metrics
  320. Metrics Using Prometheus Summary
  321. Tracing Using Jaeger
  322. OpenTracing
  323. Jaeger
  324. Jaeger Architecture Diagram
  325. Jaeger Client Libraries
  326. Jaeger Sampling
  327. Jaeger Agent
  328. Jaeger Collector
  329. Query and Ingester Services
  330. Jaeger UI Example
  331. Jaeger and Prometheus
  332. Jaeger and Istio
  333. Tracing Using Jaeger Summary
  334. Appendix B - Appendix B: Traffic Routing Patterns
  335. Edge Proxy Server
  336. Request Handling
  337. Filters
  338. Filter Architecture
  339. API Gateway for Routing Requests
  340. API Gateway — Example
  341. Rate Limiting
  342. Rate Limiting — Business Cases
  343. Configuring Rate Limiting in NGINX
  344. Circuit Breaker
  345. Design Principles
  346. Design Principles (continued)
  347. Cascading Failures
  348. Bulkhead Pattern
  349. Circuit Breaker Pattern
  350. Thread Pooling
  351. Request Caching
  352. Request Collapsing
  353. Fail-Fast
  354. Fallback
  355. Circuit Breaker Solutions
  356. Load Balancing in Microservices
  357. Server-side load balance
  358. Client-side Load Balance
  359. Architecture
  360. Service Mesh
  361. Service Mesh Solutions
  362. Content Delivery Network (CDN)
  363. How does a CDN Work?
  364. Benefits of using a CDN
  365. CDN Solutions
  366. Lab Exercises
  367. Monolith vs Microservices Design
  368. Getting Started With Node.js
  369. Getting Started with Spring Boot
  370. Enable Basic Security
  371. Using AWS Lambda
  372. Angular Communication with REST Services
  373. Creating a Docker Account and Obtain an Access Token
  374. Getting Started with Docker
  375. Getting Started with Kubernetes
  376. CI/CD with Jenkins, Docker, and OpenShift

Required Prerequisites

  • Foundational knowledge of programming and software design principles.

Register Now
numbers
CWWA2579
timer
Duration:
14
hours
payment
1497,00
(excluded VAT)
groups
Remote
notifications_active
Reg. deadline:
calendar_month
From 
to 

[

Contact us

]

info@esamatic.it
+39
349 64 30 690