Visão Geral

Este Curso Technical Microservices Foundation, ajudará você a entender a proposta de valor e os aspectos técnicos dos microsserviços, um conceito novo e bastante difuso usado para descrever serviços rapidamente provisionados e de implantação independente com funcionalidade restrita e distinta.  

Objetivo

Após realizar este Curso Technical Microservices Foundation, você será capaz de:

• Uma compreensão fundamental de microsserviços e experiência prática na implementação de microsserviços usando diferentes pilhas de tecnologia.
• Este curso é complementado por laboratórios práticos que ajudam os participantes a reforçar seu conhecimento teórico do material aprendido.
• Microsserviços
• Janela de encaixe
• Serviços Web RESTful
• Node.js
• Spring Boot
• Kubernetes
• OpenShift

Publico Alvo

• Arquitetos de TI,
• Designers de software
• Desenvolvedores
  

Pre-Requisitos

• Conhecimento básico de princípios de programação e design de software.
  

Materiais

Conteúdo Programatico

Chapter 1. Breaking Up Monoliths – Pros and Cons

1. Traditional Monolithic Applications and Their Place
2. Disadvantages of Monoliths
3. Developer's Woes
4. Architecture Modernization
5. Architecture Modernization Challenges
6. Microservices Architecture is Not a Silver Bullet!
7. What May Help?
8. In-Class Discussion
9. Summary

Chapter 2. Microservice Development

1. What are Microservices?
2. Microservices vs Classic SOA
3. Principles of Microservices Architecture Design
4. Domain-Driven Design
5. Domain-Driven Design - Benefits
6. Microservices and Domain-Driven Design
7. Designing for failure
8. Microservices Architecture – Pros
9. Microservices Architecture – Cons
10. Docker and Microservices
11. Microservice Deployment with Docker – Workflow
12. Writing Dockerfile
13. Kubernetes
14. What is OpenShift
15. OpenShift Architecture
16. Microservices and Various Applications
17. Web Applications
18. Web Applications – Reference Architecture
19. Web Applications – When to use?
20. Single Page Applications
21. Single Page Applications – Benefits
22. Traditional Enterprise Application Architecture
23. Sample Microservices Architecture
24. Serverless & Event-driven Microservice – AWS Lambda
25. Summary

Chapter 3. Twelve-factor Applications

1. Twelve-factor Applications
2. Twelve Factors, Microservices, and App Modernization
3. The Twelve Factors
4. Categorizing the 12 Factors
5. 12-Factor Microservice Codebase
6. 12-Factor Microservice Dependencies
7. 12-Factor Microservice Config
8. 12-Factor Microservice Backing Services
9. 12-Factor Microservice Build, Release, Run
10. 12-Factor Microservice Processes
11. 12-Factor Microservice Port Binding
12. 12-Factor Microservice Concurrency
13. 12-Factor Microservice Disposability
14. 12-Factor Microservice Dev/Prod Parity
15. 12-Factor Microservice Logs
16. 12-Factor Microservice Admin Processes
17. Kubernetes and the Twelve Factors - 1 Codebase
18. Kubernetes and the Twelve Factors - 2 Dependencies
19. Kubernetes and the Twelve Factors - 3 Config
20. Kubernetes and the Twelve Factors - 4 Backing Services
21. Kubernetes and the Twelve Factors - 5 Build, Release, Run
22. Kubernetes and the Twelve Factors - 6 Processes
23. Kubernetes and the Twelve Factors - 7 Port Binding
24. Kubernetes and the Twelve Factors - 8 Concurrency
25. Kubernetes and the Twelve Factors - 9 Disposability
26. Kubernetes and the Twelve Factors - 10 Dev/Prod Parity
27. Kubernetes and the Twelve Factors - 11 Logs
28. Kubernetes and the Twelve Factors - 12 Admin Processes
29. Summary

Chapter 4. REST Services

1. Many Flavors of Services
2. Understanding REST
3. Principles of RESTful Services
4. REST Example – Create
5. REST Example – Retrieve
6. REST Example – Update
7. REST Example – Delete
8. REST Example – Client Generated ID
9. SOAP Equivalent Examples
10. REST Example – JSON
11. Famous RESTful Services
12. Additional Resources
13. What is gRPC?
14. Protocol Buffers
15. REST vs. gRPC
16. Protobuf vs. JSON
17. HTTP/2 vs. HTTP 1.1
18. HTTP/2 vs. HTTP 1.1 (Contd.)
19. Messages vs. Resources and Verbs
20. Streaming vs. Request-Response
21. Strong Typing vs. Serialization
22. Web Browser Support
23. REST vs. gRPC – In a Nutshell
24. Summary

Chapter 5. Microservices with Node.js

1. What is Node.js?
2. Node's Value Proposition
3. Example of a Node.js App: a Simple Web Server
4. Node.js Project Types
5. Managing Large Applications
6. Core Modules
7. Why Node.js uses JavaScript?
8. The Traditional Concurrency Support Model
9. Disadvantages of the Traditional Approach
10. Event-Driven, Non-Blocking I/O
11. The Success Callback Function
12. Using Node Package Manager (NPM)
13. NPM Registry (Repository)
14. NPM Enterprise
15. Package Life-Cycle Management
16. Local and Global Package Installation Options
17. Listing and Using Module Versions
18. The Express Package
19. Installing and Using Express
20. Defining Routing Rules in Express
21. Route Path
22. The Response Object
23. A Simple Web Service with Express Example
24. The MEAN Stack
25. Summary

Chapter 6. Introduction to Spring Boot for Non-Java Developers

1. What is Spring Boot?
2. Spring Boot Main Features
3. Spring Boot vs DropWizard
4. Spring Boot on the PaaS
5. Understanding Java Annotations
6. Spring MVC Annotations
7. Example of Spring MVC-based RESTful Web Service
8. Spring Booting Your RESTful Web Service
9. Spring Boot Skeletal Application Example
10. Converting a Spring Boot Application to a WAR File
11. Summary

Chapter 7. Spring REST Services

1. Many Flavors of Services
2. Understanding REST
3. RESTful Services
4. REST Resource Examples
5. REST vs SOAP
6. REST Services With Spring MVC
7. Spring MVC @RequestMapping with REST
8. Working With the Request Body and Response Body
9. @RestController Annotation
10. Implementing JAX-RS Services and Spring
11. JAX-RS Annotations
12. Java Clients Using RestTemplate
13. RestTemplate Methods
14. Summary

Chapter 8. Spring Security

1. Securing Web Applications with Spring Security 3.0
2. Spring Security 3.0
3. Authentication and Authorization
4. Programmatic v Declarative Security
5. Getting Spring Security Gradle or Maven
6. Spring Security Configuration
7. Spring Security Configuration Example
8. Authentication Manager
9. Using Database User Authentication
10. LDAP Authentication
11. What is Security Assertion Markup Language (SAML)?
12. What is a SAML Provider?
13. Spring SAML2.0 Web SSO Authentication
14. Setting Up an SSO Provider
15. Adding SAML Dependencies to a Project
16. Dealing with the State
17. How Can I Maintain State?
18. SAML vs. OAuth2
19. OAuth2 Overview
20. OAuth – Facebook Sample Flow
21. OAuth Versions
22. OAuth2 Components
23. OAuth2 – End Points
24. OAuth2 – Tokens
25. OAuth – Grants
26. Authenticating Against an OAuth2 API
27. OAuth2 using Spring Boot – Dependencies
28. OAuth2 using Spring Boot – application.yml
29. OAuth2 using Spring Boot – Main Class
30. OAuth2 using Spring Boot – SPA Client
31. JSON Web Tokens
32. JSON Web Token Architecture
33. How JWT Works
34. JWT Header
35. JWT Payload
36. JWT Example Payload
37. JWT Example Signature
38. How JWT Tokens are Used
39. Adding JWT to HTTP Header
40. How The Server Makes Use of JWT Tokens
41. What are “Scopes”?
42. JWT with Spring Boot – Dependencies
43. JWT with Spring Boot – Main Class
44. Summary

Chapter 9. AWS Lambda

1. What is AWS Lambda?
2. Supported Languages
3. Getting Your Code Up And Running in Lambda
4. Examples of the Base Lambda Function
5. Use Cases
6. How It Works
7. Example: Processing S3 Source Events with Lambda
8. The Programming Model
9. Configuring Lambda Functions
10. Configure Triggers Page
11. Lambda Function Blueprints
12. How Do I Troubleshoot and Monitor My Lambda Functions?
13. Developing Lambda in Java
14. Summary

Chapter 10. Consuming REST Services from a Client

1. Accessing REST Services using jQuery - GET Example
2. Accessing REST Services using jQuery - GET Example (Contd.)
3. Accessing REST Services using jQuery - POST Example
4. Accessing REST Services in React - Component
5. Accessing REST Services in React - componentDidMount
6. Accessing REST Services in React - render
7. Accessing REST Services in React - POST Method
8. The Angular HTTP Client
9. Using The HTTP Client - Overview
10. Importing HttpClientModule
11. Simple Example
12. Service Using HttpClient
13. ES6 Import Statements
14. Making a GET Request
15. What does an Observable Object do?
16. Using the Service in a Component
17. The PeopleService Client Component
18. Error Handling
19. Making a POST Request
20. Making a PUT Request
21. Making a DELETE Request
22. Summary

Chapter 11. Docker Introduction

1. What is Docker
2. Where Can I Run Docker?
3. Installing Docker Container Engine
4. Docker Machine
5. Docker and Containerization on Linux
6. Linux Kernel Features: cgroups and namespaces
7. The Docker-Linux Kernel Interfaces
8. Docker Containers vs Traditional Virtualization
9. Docker Integration
10. Docker Services
11. Docker Application Container Public Repository
12. Competing Systems
13. Docker Command Line
14. Starting, Inspecting, and Stopping Docker Containers
15. Docker Volume
16. Dockerfile
17. Docker Compose
18. Using Docker Compose
19. Dissecting docker-compose.yml
20. Specifying services
21. Dependencies between containers
22. Injecting Environment Variables
23. runC Overview
24. runC Features
25. Using runC
26. Running a Container using runC
27. Summary

Chapter 12. Introduction to Kubernetes

1. What is Kubernetes
2. What is a Container
3. Container – Uses
4. Container – Pros
5. Container – Cons
6. Composition of a Container
7. Control Groups
8. Namespaces
9. Union Filesystems
10. Popular Containerization Software
11. Microservices
12. Microservices and Containers / Clusters
13. Microservices and Orchestration
14. Microservices and Infrastructure-as-Code
15. Kubernetes Container Networking
16. Kubernetes Networking Options
17. Kubernetes Networking – Balanced Design
18. Summary

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

1. What is OpenShift
2. OpenShift Online
3. OpenShift Origin
4. OpenShift Architecture
5. OpenShift Origin Installation
6. OpenShift CLI
7. OpenShift CLI (Contd.)
8. Jenkins Continuous Integration
9. Jenkins Features
10. Running Jenkins
11. Downloading and Installing Jenkins
12. Running Jenkins as a Stand-Alone Application
13. Running Jenkins on an Application Server
14. Installing Jenkins as a Windows Service
15. Different types of Jenkins job
16. Configuring Source Code Management(SCM)
17. Working with Subversion
18. Working with Subversion (cont'd)
19. Working with Git
20. Build Triggers
21. Schedule Build Jobs
22. Polling the SCM
23. Maven Build Steps
24. Jenkins / OpenShift Pipeline
25. Jenkins / OpenShift Pipeline Output
26. Installing Jenkins Plugins
27. The Blue Ocean Plugin
28. Blue Ocean Plugin Features
29. New modern user experience
30. Advanced Pipeline visualizations with built-in failure diagnosis
31. Branch and Pull Request awareness
32. Personalized View
33. OpenShift Pipeline Output
34. Creating OpenShift Blue Ocean Pipeline
35. Summary

Chapter 14. Appendix A: Leading Practices for Microservice Logging

1. Logging Challenges
2. Leading Practices
3. Correlate Requests with a Unique ID
4. Include a Unique ID in the Response
5. Send Logs to a Central Location
6. Structure Your Log Data
7. Add Context to Every Record
8. Examples of Content
9. Write Logs to Local Storage
10. Collecting Logs with Fluentd
11. Leading Practices for Microservice Logging Summary
12. Metrics Using Prometheus
13. Overview
14. Prometheus
15. Prometheus Architecture
16. Service Discovery
17. File-based Service Discovery
18. Istio and Prometheus
19. Exposing Metrics in Services
20. Querying in Prometheus
21. Grafana
22. Business Metrics
23. Metrics Using Prometheus Summary
24. Tracing Using Jaeger
25. OpenTracing
26. Jaeger
27. Jaeger Architecture Diagram
28. Jaeger Client Libraries
29. Jaeger Sampling
30. Jaeger Agent
31. Jaeger Collector
32. Query and Ingester Services
33. Jaeger UI Example
34. Jaeger and Prometheus
35. Jaeger and Istio
36. Tracing Using Jaeger Summary
37. Chapter 15. Appendix B: Traffic Routing Patterns
38. Edge Proxy Server
39. Request Handling
40. Filters
41. Filter Architecture
42. API Gateway for Routing Requests
43. API Gateway for Routing Requests (Contd.)
44. API Gateway – Example
45. Rate Limiting
46. Rate Limiting – Business Cases
47. Configuring Rate Limiting in NGINX
48. Circuit Breaker
49. Design Principles
50. Design Principles (continued)
51. Cascading Failures
52. Bulkhead Pattern
53. Circuit Breaker Pattern
54. Thread Pooling
55. Request Caching
56. Request Collapsing
57. Fail-Fast
58. Fallback
59. Circuit Breaker Solutions
60. Load Balancing in Microservices
61. Server-side load balance
62. Client-side Load Balance
63. Architecture
64. Service Mesh
65. Service Mesh (Contd.)
66. Service Mesh Solutions
67. Content Delivery Network (CDN)
68. How does a CDN Work?
69. Benefits of using a CDN
70. CDN Solutions
71. Summary

Lab Exercises

• Lab 1. Monolith vs Microservices Design
• Lab 2. Getting Started With Node.js
• Lab 3. Getting Started with Spring Boot
• Lab 4. Enable Basic Security
• Lab 5. Using AWS Lambda
• Lab 6. Angular Communication with REST Services
• Lab 7. Creating a Docker Account and Obtain an Access Token
• Lab 8. Getting Started with Docker
• Lab 9. Getting Started with Kubernetes
• Lab 10. CI/CD with Jenkins, Docker, and OpenShift