Practical microservices

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

Logical Architecture

  • 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

Implementation hiding

  • Active Object (actor)
  • Eventual consistency
  • Statelessness
  • Incremental design and development
  • Going from stories to code – problem statements, story definition, extracting a logical architecture from the stories

Physical architecture

  • 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
  • Anti-patterns

Testing Strategies

  • Blue/Green Releases
  • Canary Releases

Reporting and Monitoring

Deployment

Discovery

Reliability

  • Logging
  • Monitoring
  • Self-healing (Kubernetes)
  • Heartbeats
  • Circuit Breakers
  • Bulkheads
  • Testing

Security

  • User
  • Inter-service
  • Every service is an attack surface

Allen Holub

Allen Holub

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.

Visit website

Follow Allen on Twitter

Click here to register