Technical Introduction to Microservices Training

Technical Introduction to Microservices Training Courseware (WA2579)

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.

Publisher: Web Age Solutions

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
    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
  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
  3. Twelve-factor Applications
    1. Twelve-factor Applications
    2. Twelve Factors, Microservices, and App Modernization
    3. The Twelve Factors
    4. Categorizing the 12 Factors
      1. Microservice Codebase
      2. Microservice Dependencies
      3. Microservice Config
      4. Microservice Backing Services
      5. Microservice Build, Release, Run
      6. Microservice Processes
      7. Microservice Port Binding
      8. Microservice Concurrency
      9. Microservice Disposability
      10. Microservice Dev/Prod Parity
      11. Microservice Logs
      12. Microservice Admin Processes
    5. Kubernetes and the Twelve Factors
      1. Codebase
      2. Dependencies
      3. Config
      4. Backing Services
      5. Build, Release, Run
      6. Processes
      7. Port Binding
      8. Concurrency
      9. Disposability
      10. Dev/Prod Parity
      11. Logs
      12. Admin Processes
  4. REST Services
    1. Many Flavors of Services
    2. Understanding REST
    3. Understanding REST
    4. Principles of RESTful Services
    5. REST Example — Create
    6. REST Example — Retrieve
    7. REST Example — Update
    8. REST Example — Delete
    9. REST Example — Client Generated ID
    10. SOAP Equivalent Examples
    11. REST Example — JSON
    12. Famous RESTful Services
    13. Additional Resources
    14. What is gRPC?
    15. Protocol Buffers
    16. REST vs. gRPC
    17. Protobuf vs. JSON
    18. HTTP/2 vs. HTTP 1.1
    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
  5. Microservices with Node.js
    1. What is Node.js?
      1. Node's Value Proposition
    2. Example of a Node.js App: a Simple Web Server
    3. Node.js Project Types
    4. Managing Large Applications
    5. Core Modules
    6. Why Node.js uses JavaScript?
    7. The Traditional Concurrency Support Model
    8. Disadvantages of the Traditional Approach
    9. Event-Driven, Non-Blocking I/O
    10. The Success Callback Function
    11. Using Node Package Manager (NPM)
    12. NPM Registry (Repository)
    13. NPM Enterprise
    14. Package Life-Cycle Management
    15. Local and Global Package Installation Options
    16. Listing and Using Module Versions
    17. The Express Package
    18. Installing and Using Express
    19. Defining Routing Rules in Express
    20. Route Path
    21. The Response Object
    22. A Simple Web Service with Express Example
    23. The MEAN Stack
  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
  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
  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
  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
      1. How Do I Troubleshoot and Monitor My Lambda Functions?
    12. Developing Lambda in Java
  10. Consuming REST Services from a Client
    1. Accessing REST Services using jQuery - GET Example
    2. Accessing REST Services using jQuery - POST Example
    3. Accessing REST Services in React - Component
    4. Accessing REST Services in React - componentDidMount
    5. Accessing REST Services in React - render
    6. Accessing REST Services in React - POST Method
    7. The Angular HTTP Client
    8. Using The HTTP Client - Overview
    9. Importing HttpClientModule
    10. Simple Example
    11. Service Using HttpClient
    12. ES6 Import Statements
    13. Making a GET Request
    14. What does an Observable Object do?
    15. Using the Service in a Component
    16. The PeopleService Client Component
    17. Error Handling
    18. Making a POST Request
    19. Making a PUT Request
    20. Making a DELETE Request
  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 Containers vs Traditional Virtualization
    10. Docker Integration
    11. Docker Services
    12. Docker Application Container Public Repository
    13. Competing Systems
    14. Docker Command Line
    15. Starting, Inspecting, and Stopping Docker Containers
    16. Docker Volume
    17. Dockerfile
    18. Docker Compose
    19. Using Docker Compose
    20. Dissecting docker-compose.yml
      1. 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
  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
  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. Jenkins Continuous Integration
    8. Jenkins Features
    9. Running Jenkins
    10. Downloading and Installing Jenkins
    11. Running Jenkins as a Stand-Alone Application
    12. Running Jenkins on an Application Server
    13. Installing Jenkins as a Windows Service
    14. Different types of Jenkins job
    15. Configuring Source Code Management(SCM)
    16. Working with Subversion
    17. Working with Git
    18. Build Triggers
    19. Schedule Build Jobs
    20. Polling the SCM
    21. Maven Build Steps
    22. Jenkins / OpenShift Pipeline
    23. Jenkins / OpenShift Pipeline Output
    24. Installing Jenkins Plugins
    25. The Blue Ocean Plugin
    26. Blue Ocean Plugin Features
    27. New modern user experience
    28. Advanced Pipeline visualizations with built-in failure diagnosis
    29. Branch and Pull Request awareness
    30. Personalized View
    31. OpenShift Pipeline Output
    32. Creating OpenShift Blue Ocean Pipeline
  14. Appendix A - 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
  15. Appendix B - Appendix B: Traffic Routing Patterns
    1. Edge Proxy Server
    2. Request Handling
    3. Filters
    4. Filter Architecture
    5. API Gateway for Routing Requests
    6. API Gateway — Example
    7. Rate Limiting
    8. Rate Limiting — Business Cases
    9. Configuring Rate Limiting in NGINX
    10. Circuit Breaker
    11. Design Principles
    12. Design Principles (continued)
    13. Cascading Failures
    14. Bulkhead Pattern
    15. Circuit Breaker Pattern
    16. Thread Pooling
    17. Request Caching
    18. Request Collapsing
    19. Fail-Fast
    20. Fallback
    21. Circuit Breaker Solutions
    22. Load Balancing in Microservices
    23. Server-side load balance
    24. Client-side Load Balance
    25. Architecture
    26. Service Mesh
    27. Service Mesh Solutions
    28. Content Delivery Network (CDN)
    29. How does a CDN Work?
    30. Benefits of using a CDN
    31. CDN Solutions
  16. Lab Exercises
    1. Monolith vs Microservices Design
    2. Getting Started With Node.js
    3. Getting Started with Spring Boot
    4. Enable Basic Security
    5. Using AWS Lambda
    6. Angular Communication with REST Services
    7. Creating a Docker Account and Obtain an Access Token
    8. Getting Started with Docker
    9. Getting Started with Kubernetes
    10. CI/CD with Jenkins, Docker, and OpenShift

Required Prerequisites

  • Foundational knowledge of programming and software design principles.
License

Length: 2 days | $150.00 per copy

LicenseRequest More InformationRequest Trainer Evaluation Copy