About the course
Monolithic systems often struggle to keep pace with the demand for faster change, continuous delivery, and scalable solutions. Microservices architecture offers a powerful alternative, enabling systems composed of small, independent services that can be developed, deployed, and scaled autonomously. This 3-day workshop provides Developers, Admins, and Software Architects with a strong understanding of Microservices architecture, equipping you with the knowledge needed before embarking on a development and deployment project.
The course explains the fundamental reasons why microservices are needed, exploring the challenges of change in traditional systems and how designing with microservices addresses these issues by fostering agility, resilience, and independent scaling. You will gain clarity on the relationship between Microservices and APIs, understanding how to define clear boundaries and interactions. A key focus is placed early on the necessity of designing a robust delivery pipeline, exploring how Continuous Integration and Continuous Deployment/Delivery (CI/CD) practices are essential enablers for microservices success.
You will explore various patterns for composing microservices, addressing the pitfalls of synchronous communication and building resilient systems through asynchronous messaging. The course covers defining data contracts with schemas and protocols, and delves into Event-Driven Architectures (EDA), system choreography, and powerful techniques like Stream Processing for materialized views and Event Sourcing for managing state with auditability. Practical topics include managing distributed transactions using process managers, testing event-based systems, and essential deployment considerations leveraging cloud platforms and containerisation. Through this, you will gain practical insight into the core principles and common patterns used in microservices.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
- Understand the fundamental challenges of monolithic systems and the core motivations for adopting Microservices architecture.
- Apply Microservices principles to design systems for increased agility, resilience, and independent deployability.
- Clearly define the relationship between Microservices and APIs and use APIs to establish service boundaries and interactions.
- Explain the critical role of CI/CD in enabling effective Microservices development and deployment.
- Choose appropriate communication patterns, contrasting synchronous approaches with asynchronous messaging for building resilient compositions.
- Define and enforce data contracts between services using schemas and message protocols.
- Understand Event-Driven Architectures (EDA) and Event Sourcing as powerful patterns for microservices composition and state management.
- Utilise Stream Processing concepts to build and manage materialized views from event streams.
- Understand how to manage distributed transactions and complex workflows using patterns like Sagas (Process Managers).
- Understand key considerations for deploying Microservices, including leveraging cloud platforms and containerisation.
-
This 3-day course is aimed at individuals involved in the design, development, or deployment of software systems who wish to gain a strong understanding of Microservices architecture before embarking on a project. It is ideal for:
Software Developers designing and building services.
Software Architects making system design decisions.
System Administrators and Operations Professionals involved in deploying and managing services.
Technical Leads guiding teams adopting microservices.
Anyone seeking a comprehensive overview of microservices principles and common patterns.
-
Participants should have:
Working knowledge of software development concepts.
Basic understanding of system architecture principles.
No prior experience with Microservices, Containerisation, or specific DevOps practices is required, as the course provides an introduction to these in context.
-
This Microservices Architecture course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
Understanding change in a system:
Explore the inherent challenges of evolving monolithic systems and why traditional architectures often hinder rapid change and innovation.
Designing for change in a system:
Learn how applying Microservices architecture principles enables you to design systems that are more adaptable, resilient, and independently deployable to accommodate ongoing business and technical change.
APIs vs Microservices:
Clarify the relationship between Microservices and APIs, understanding how APIs serve as the external interface for services and enable clear communication boundaries and contracts.
Designing a delivery pipeline for Microservices:
Understand the necessity and key considerations for creating automated Continuous Integration and Continuous Deployment (CI/CD) pipelines that are essential for the rapid and independent deployment of microservices.
RPCish Microservices and why they hurt you:
Examine the drawbacks and pitfalls of relying heavily on synchronous, request/response communication patterns between microservices, such as tight coupling, cascading failures, and reduced resilience.
Composing Microservices using MessagingBrokers and Point to Point:
Explore the benefits and patterns of using asynchronous communication to compose services, leveraging message brokers and point-to-point messaging for loose coupling, scalability, and resilience.
Schemas:
Understand the critical role of defining and enforcing data contracts using schemas (for both APIs and messages) to ensure compatibility and prevent integration issues between independent services.
Identify and defining Message Protocols:
Learn about different serialisation formats and protocols (e.g., JSON, Protobuf, Avro) used for defining the structure and content of messages exchanged between services.
Messaging State Machines:
Introduce the concept of using messaging to manage complex, long-running business processes or distributed transactions by modelling states and transitions triggered by messages.
Composing Microservices using Events:
Introduce the principles of Event-Driven Architectures (EDA), where services communicate by emitting and reacting to events, enabling significant decoupling and flexibility.
Event Driven Architectures: Explore the benefits, patterns, and characteristics of building systems organised around a flow of events.
Patterns for System Choreography: Understand how services can coordinate activities by reacting independently to events published by other services, contrasting this approach with centralised orchestration.
Stream Processing to materialise views of the system: Learn how stream processing technologies can be used to consume event streams and build denormalised, query-optimised materialized views of system state for read purposes.
Upgrading of views: Address the challenges and strategies involved in handling schema evolution and versioning for materialized views that are built from evolving event streams.
Event Sourcing:
Dive into Event Sourcing, an architectural pattern where application state is stored as a sequence of immutable domain events, providing a complete, auditable history and enabling powerful capabilities like temporal querying.
The Aggregate Root: Introduce this Domain-Driven Design concept often used in Event Sourcing to define consistency boundaries around a group of related objects that are managed via commands and events.
System Commands: Understand how commands represent intentions to perform an action and how they trigger the validation of business rules and the emission of events in an Event Sourced system.
Understanding System State as an audit log: Explore the inherent benefit of Event Sourcing in providing a complete, auditable history of all state changes, which can be invaluable for debugging, compliance, and analytics.
Combining with Stream Processing:
Understand how stream processing is frequently used in conjunction with Event Sourcing, for example, to build read models (materialized views) or react to events emitted by aggregate roots in real-time.
Snapshotting: Learn about snapshotting as a performance optimisation technique in Event Sourcing to avoid replaying the entire event history every time an aggregate root's state needs to be reconstructed.
Transactions using Process Managers:
Explore how Process Managers or Orchestrators can be used to coordinate activities across multiple services to manage distributed transactions (often referred to as Sagas) and ensure eventual consistency across the system.
Event based testing techniques:
Learn strategies and patterns for effectively testing individual microservices and their interactions, particularly in systems leveraging asynchronous communication and events.
Cloud Deployment:
Understand key considerations for deploying Microservices in cloud environments, including scalability, resilience, service discovery, API Gateways, and configuration management in the cloud context.
Containerisation for development process and deployment:
Learn about Containerisation, specifically using Docker, and how it simplifies the development workflow (providing consistent, isolated environments) and deployment (packaging, portability, isolation) for microservices.
-
Martin Fowler's Microservices Article: A widely referenced seminal article defining the characteristics of Microservices. https://martinfowler.com/articles/microservices.html
Docker Documentation: Official documentation for Containerisation, a key technology for building and deploying microservices. https://docs.docker.com/
Apache Kafka Documentation: Official documentation for a leading distributed messaging and stream processing platform, highly relevant for asynchronous communication and Event-Driven Architectures. https://kafka.apache.org/documentation/
Jenkins Documentation: Official documentation for a popular open-source automation server often used for CI/CD pipelines in Microservices development. https://www.jenkins.io/doc/
AWS Microservices Overview: Amazon Web Services' perspective and guidance on building microservices on their cloud platform. https://aws.amazon.com/microservices/
Trusted by
