In this hands-on workshop, you’ll learn everything you need to build microservices for the real world. You’ll learn both the nuts-and bolts implementation details and also the Agile Architecture techniques you need to develop effective service APIs and good structure.
Server-side monoliths (single programs that provide all back-end services) just don’t work. They are hard to build, impossible to maintain, difficult to test and deploy, and gradually accrete so much baggage that forward development slows to a crawl. Agile development is impossible over this sort of system.
Microservices – systems of small, co-operating server-side agents – solve these problems, but building a microservice system is not as easy as you might think. They’re nothing like typical web (SOA) services, and getting it wrong is both disastrous and expensive. Many things you think you know about server-side programming are just inappropriate in this context.
This class is a deep dive into practical microservice architecture and implementation. You’ll learn lots of practical details and common pitfalls that can cause you months of delay or even outright failure. You’ll learn everything you need to be successful building platform-independent, vendor and language neutral microservice systems. You’ll learn about optimal microservice architecture and principles, appropriate service-API and UI design, effective interservice communication, and robust failure-handling techniques. Leverage this knowledge to build robust and resilient, secure, platform-independent services with no false starts and rework.
When we’re done, you’ll understand:
- Exactly what a microservice is and how to build one.
- Various approaches to service architectures, both orchestrated and choreographed.
- How to design effective service-based APIs around your problem domain.
- How to get large clouds of co-operating services to interact effectively and reliably.
- The real-world issues surrounding service construction, deployment, and maintenance.
- The pitfalls of microservice-based systems and how to correct for them.
This workshop will give you everything that you need to succeed, whether you’re starting from scratch or refactoring an existing system. It covers essential details that are far from obvious, and will save you from making critical mistakes that could subvert your system.
What we’ll cover:
What is a Microservice?
- The characteristics of a microservice
- How small is it?
- The good, the bad, and the ugly
- Agile and other volatile-requirements environments
- Impact on the development organization and processes
- Testing difficulties and deployment strategies
- Moving from the monolith
- Conway’s Law
- Mini, micro, or nano?
- Domain-focused architecture
- Reactive services vs. objects
- Essential design principles and patterns – responsibility-based design, single responsibility, stories to architecture
- Orchestrated (synchronous) – HTTP transport, handling failures
- Choreographed (event driven)
- Inter-service communication – REST-less communication, lightweight messaging, ZeroMQ compared to Rabbit and Kafka, PubSub vs push/pull, Brokerless, point-to-point communication
- Swarming architectures (decentralized self-scaling fabrics) – eliminating single points of failure, emergence, decentralized discovery (registries) and scaling, start-up (cloning), shutdown
- UI architectures – presentation/abstraction/control, agents
- Hot updates
- Bounded contexts
- Tolerant reader
- Semantic versioning
- Active Object (actor)
- Eventual consistency
- Incremental design and development
- Going from stories to code – problem statements, story definition, extracting a logical architecture from the stories
- Inappropriate infrastructure (languages, etc.)
- Interfacing to the outside world
- Communications infrastructure and messaging
- UI architectures – Presentation/Abstraction/Control
- Scaling strategies
- Deployment issues
- Microservice-architecture patterns – Lambda (single-method cloud services), Reactive, Proxy, Router Mesh, Fabric, Swarm
- Deployment – Service independence, VMs, Containers (Docker)
Breaking Up the Monolith
- The Strangler pattern
- Teasing apart the database
- Blue/Green Releases
- Canary Releases
Reporting and Monitoring
- Self-healing (Kubernetes)
- Circuit Breakers
- Every service is an attack surface
Allen is a world-class expert in Agile process, software architecture, and OO design. He's built full-stack web applications, Microservices, compilers, database servers, real-time operating systems, and more. He provides guidance and training for all sizes of organizations, working with everyone from C-levels to developers. Allen has also written a number of books (including Holub on Patterns) and hundreds of technical articles, and has taught for the University of California Berkeley Extension. He’s been a regular speaker at SDD events for several years.