Practical Microservices

3 days, hands-on. 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 Agile Architecture techniques you need to develop effective service APIs and good structure.

SKU: practical-microservices 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 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.
  • 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.

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

Map to the Venue

The Hillside Club, 2286 Cedar St., Berkeley, CA 94709

Event Details

Start time: 09:00 a.m.

End time: 05:00 p.m.

Venue: The Hillside Club, Berkeley CA

Coordinates: 37.8787828, -122.264877

Phone: +1 (510) 859-3620



There are no reviews yet.

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