Generic filters
Search in title

Microservices Architecture Training

About the Training

The Microservices Architecture Training” provides comprehensive education on microservices architecture. This training covers the essential topics required for designing and developing microservices-based applications.

The training teaches the principles of microservices architecture, data management, fault tolerance, messaging, and other key concepts. Participants enhance their knowledge of microservices architecture through real-life examples and projects.

Additionally, the training explains which tools and technologies to use during the design and development process of microservices-based applications. Participants learn how to manage big data processing, real-time analytics, fault tolerance, and other features. They also gain an understanding of how to design and manage microservices-based applications.

The Microservices Architecture Training” covers the entire process of designing and developing microservices-based applications. Participants acquire the fundamental skills needed before they start designing and developing modern applications. Learning is facilitated through examples, hands-on applications, and projects, helping participants begin designing and developing microservices-based applications.

The training program starts with the fundamentals of microservices architecture. Participants learn key concepts such as data management, managing messaging systems, and fault tolerance. Additionally, they gain insights into the role of microservices architecture in designing and managing modern applications. These foundational topics provide the necessary building blocks for participants in the application design and development process.

The training focuses on the core features and components of microservices architecture. This gives participants the skills to handle real-time data processing, big data streams, and fault tolerance. Topics such as data flow, data management, and managing distributed systems are covered.

Lastly, we provide knowledge on how to develop an application based on microservices architecture. This process includes final testing, data management, and ultimately developing the application with a microservices-based approach. This knowledge helps participants successfully design and develop applications using microservices architecture.

What Will You Learn?

In the Microservices Architecture Training, participants will:
  • Microservices Concept: Learn what microservices are, how they work, and what their advantages are.
  • Microservices Architecture: Cover topics such as the design, implementation, and management of microservices architecture.
  • Data Flow and Communication: Learn about the data flow and communication mechanisms between microservices.
  • Performance and Reliability: Discuss how to address performance and reliability issues in microservices architecture.
  • Application Examples: Review application examples of microservices architecture and apply them through practical exercises.
  • Big Data and Cloud-Based Systems: Explore how to integrate microservices architecture with big data and cloud-based systems.

Prerequisites

Prerequisites for the Microservices Architecture Training:
  • Programming Languages: Knowledge of a programming language such as .Net, Java, Python, or a similar language is required.
  • Web Applications and RESTful Services: Understanding how web applications are built and how RESTful services are used is necessary.
  • Database Technologies: Knowledge of a database technology such as SQL or NoSQL is required.
  • Cloud-Based Technologies: Experience with cloud-based technologies like Amazon Web Services (AWS) or Microsoft Azure is beneficial.

Who Should Attend?

The following professional groups can participate in the Microservices Architecture Training:
  • Software Developers: Software developers who want to understand the processes of developing and deploying applications with microservices architecture.
  • DevOps: DevOps professionals who want to understand how cloud-based technologies and distributed systems are managed with microservices architecture.
  • R&D and Innovation: R&D and innovation professionals who want to understand how their ideas can be implemented using microservices architecture.
  • IT Managers: IT managers who want to understand how applications are designed, managed, and improved with microservices architecture.

Outline

Breaking Up Monoliths – Pros and Cons
  • Traditional Monolithic Applications and Their Place
  • Disadvantages of Monoliths
  • Developer’s Woes
  • Architecture Modernization
  • Architecture Modernization Challenges
  • Microservices Architecture is Not a Silver Bullet!
  • What May Help?
  • In-Class Discussion
  • Summary
Microservices
  • What is a “Microservice”?
  • Unix Analogy
  • Principles of Microservices
  • Services within an SOA vs Microservices
  • Properties and Attributes of Microservices
  • Benefits of Using Microservices
  • The Two-Pizza Teams
  • Beware of Microservices Cons
  • Anti-Pattern: Nanoservices
  • The Twelve-Factor App Methodology
  • The Select Factors
  • Serverless Computing
  • Microservices – Operational Aspects
  • Summary
Microservices Architecture Defined
  • The Microservices Architecture
  • SOA Promises and Expectations
  • Microservices Architecture vs SOA
  • The ESB Connection
  • Microservices Architecture Benefits
  • Microservices Architecture Choices and Attributes
  • Example: On-Line Banking Solution Based on MsA
  • Distributed Computing Challenges
  • Replaceable Component Architecture
  • The Actor Model
  • MapReduce Distributed Computing Framework
  • Hadoop’s MapReduce Word Count Job Example
  • What Can Make a Microservices Architecture Brittle?
  • 4+1 Architectural View Model
  • Summary
Containerization Systems for Microservices
  • Infrastructure as Code
  • Why Not Just Deploy My Code Manually?
  • What is Docker
  • Docker Containers vs Traditional Virtualization
  • Docker is a Platform-as-a-Service
  • Docker Integration
  • Docker Services
  • Docker Application Container Public Repository
  • Container Registries
  • Your Own Docker Image Registry
  • Starting, Inspecting, and Stopping Docker Containers
  • One Process per Container
  • The Dockerfile
  • Kubernetes
  • What is OpenShift
  • Summary
Commonly Used Patterns
  • Why Use Patterns?
  • Performance-Related Patterns
  • More Performance-Related Patterns
  • Pagination vs. Infinite Scrolling – UX Lazy Loading
  • Integration Patterns
  • More Integration Patterns
  • The Service Mesh Integration Pattern
  • Mesh Pros and Cons
  • Service-to-Service Communication with Mesh
  • Resilience-Related Patterns
  • Summary
API Management
  • API Management Defined
  • The Traditional Point-to-point Integration Example
  • It Raises Some Questions …
  • The Facade Design Pattern
  • API Management Conceptual Diagram
  • Complimentary Services for Microservices
  • What Else is Needed?
  • The Driving Forces
  • API Management Offerings
  • The Mashery API Management System Overview
  • AWS API Gateway Call Flow
  • Summary
Designing and Implementing Microservices
  • Two Types of IT Projects
  • What is In Scope for a Robust Microservices Design?
  • Scoping Your Microservice via the Bounded Context
  • Scoping Your Solution’s Microservices Architecture
  • External / Shared and Internal Service Models
  • General Architectural and Software Process Organizational Principles
  • Loose Coupling, the OOD Perspective
  • Crossing Process Boundary is Expensive!
  • Cross Cutting Concerns
  • More Cross Cutting Concerns
  • To Centralize or Decentralize Client Access?
  • Decentralized Client Access
  • Centralized Client Access
  • The Facade Pattern
  • The Facade Service Conceptual Diagram
  • The Naked Objects Architectural Pattern
  • When to Use Naked Objects Pattern
  • Dealing with the State
  • How Can I Maintain State?
  • Micro Front-ends (a.k.a. MicroUI)
  • How can MicroUI Help Me?
  • Your Clients Are Diverse
  • The “Rich Client” – “Thin Server” Paradigm
  • The “Rich Client” – “Thin Server” Architecture
  • RIA as a Driving Force to Turn the “Thin Server” into a Set of Microservices
  • Design for Failure
  • Managing Failures Effectively
  • The Immutable Infrastructure Principle
  • Implementing Microservices
  • JAX-RS
  • Microservice-Oriented Application Frameworks and Platforms
  • Embedding Databases
  • Embedded Java Databases
  • Summary
Microservices Integration
  • One Common Observation
  • The “One Service – One Host” Deployment
  • Things to Consider when Integrating
  • Technology Options
  • The Data Exchange Interoperability Options
  • The Correlation ID
  • Enterprise Integration Patterns
  • Asynchronous Communication
  • Benefits of Message-Oriented Middleware (MOM)
  • Asynchronous Communication Models
  • Message Brokers
  • A Message Broker Diagram
  • Asynchronous Message Consumption Patterns
  • Popular Messaging Systems
  • Challenges of Managing Microservices
  • Options for Managing Microservices
  • In-Class Discussion
  • Summary
Working with Data in Microservices
  • Monolithic Databases
  • The Traditional Two-phase Commit (2PC) Protocol
  • Table Sharding and Partitioning
  • The CAP Theorem
  • Mechanisms to Guarantee a Single CAP Property
  • The CAP Triangle
  • Eventual Consistency
  • Handling Transactions in Microservices Architecture
  • The Event-Driven Data Sharing Diagram
  • The Saga Pattern
  • The Saga Log and Execution Coordinator
  • The Saga Happy Path
  • A Saga Compensatory Request Example
  • In-Class Discussion
  • The Need for Micro Databases
  • Migrating Data from Existing Databases (Breaking up the Monolith Database)
  • One Data Migration Approach
  • One Data Migration Approach (Cont’d)
  • In-Class Discussion
  • Command Query Responsibility Segregation (CQRS)
  • The CQRS Communications Diagram
  • A Word of Caution
  • The Event Sourcing Pattern
  • Event Sourcing Example
  • Applying Efficiencies to Event Sourcing
  • Summary
Robust Microservices
  • What Can Make a Microservices Architecture Brittle?
  • Making it Resilient – Mechanisms
  • Techniques and Patterns for Making Your Microservices Robust
  • Fail Fast or Quiesce?
  • Synchronous Communication Timeouts / Retries
  • Asynchronous Communication Timeouts / Retries
  • In-Class Discussion
  • The Circuit Breaker Pattern
  • The Circuit Breaker Pattern Diagram
  • The Bulkhead Pattern
  • Factor IX of the 12 App Methodology
  • Feature Enablement
  • Designing for Test and Failure
  • Making Microservices Testable
  • Test for Failure
  • Continuous Testing and Integration
  • Continuous Release and Deployment
  • SLAs
  • Where and What to Monitor
  • Logging and Monitoring
  • Summary

Training Request Form

Microservices Training

The Microservices Training provides participants with the knowledge and skills necessary to understand and implement microservices architecture. This training covers the transition from monolithic architecture

Eğitimi İncele »