Practical Microservices

1 day lecture, or 3-4 day workshop. In this class, 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 architectural techniques you need to develop effective service APIs and good structure. (The workshop combines lecture with Incremental Architecture, so that you can experience designing a microservice hands on.)

SKU: practical-microservices-1 Category:

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 cooperating 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 doing it wrong is both disastrous and expensive. Many things you think you know about server-side programming are just wrong in this context.

This class is deep dive into practical microservice architecture at both the structural and implementation levels. 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 including lightweight messaging, 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.
  • You’ll understand various approaches to service architectures, both orchestrated and choreographed.
  • You’ll understand how to design effective service-based APIs around your problem domain.
  • You’ll understand how to get large clouds of cooperating services to interact effectively and reliably.
  • You’ll understand the real-world issues surrounding service construction, deployment, and maintenance.
  • You’ll understand the pitfalls of microservice-based systems and how to correct for them.

This classes gives you everything 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. (One caveat: this is not a Kubernetes class. We cover architecture, not specific implementation technologies.)

This is a lecture class. We strongly recommend combining this class with Incremental Architecture, so that you can get hands-on experience designing a microservice.

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
  • Startup (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


There are no reviews yet.

Only logged in customers who have purchased this product may leave a review.