skilld
All skills
wshobson avatar

/microservices-patterns

@be57c0b
by Seth Hobsonwshobson/agents40k stars
4,281

Design microservices architectures with service boundaries, event-driven communication, and resilience patterns. Use when building distributed systems, decomposing monoliths, or implementing microservices.

Ask your Agent

Use this Skill: https://skilld.dev/gh/wshobson/agents/microservices-patterns

This session only. Nothing lands on disk.

SKILL.md

≈57 tokens always: the name and description. ≈467 when used: this file. ≈3.6k more on demand in 1 file.

Microservices Patterns

Master microservices architecture patterns including service boundaries, inter-service communication, data management, and resilience patterns for building distributed systems.

When to Use This Skill

  • Decomposing monoliths into microservices
  • Designing service boundaries and contracts
  • Implementing inter-service communication
  • Managing distributed data and transactions
  • Building resilient distributed systems
  • Implementing service discovery and load balancing
  • Designing event-driven architectures

Core Concepts

1. Service Decomposition Strategies

By Business Capability

  • Organize services around business functions
  • Each service owns its domain
  • Example: OrderService, PaymentService, InventoryService

By Subdomain (DDD)

  • Core domain, supporting subdomains
  • Bounded contexts map to services
  • Clear ownership and responsibility

Strangler Fig Pattern

  • Gradually extract from monolith
  • New functionality as microservices
  • Proxy routes to old/new systems

2. Communication Patterns

Synchronous (Request/Response)

  • REST APIs
  • gRPC
  • GraphQL

Asynchronous (Events/Messages)

  • Event streaming (Kafka)
  • Message queues (RabbitMQ, SQS)
  • Pub/Sub patterns

3. Data Management

Database Per Service

  • Each service owns its data
  • No shared databases
  • Loose coupling

Saga Pattern

  • Distributed transactions
  • Compensating actions
  • Eventual consistency

4. Resilience Patterns

Circuit Breaker

  • Fail fast on repeated errors
  • Prevent cascade failures

Retry with Backoff

  • Transient fault handling
  • Exponential backoff

Bulkhead

  • Isolate resources
  • Limit impact of failures

Detailed patterns and worked examples

Detailed pattern documentation lives in references/details.md. Read that file when the navigation tier above is insufficient.

Source: SKILL.md on GitHub

Third-party checks

No alerts16d5 checks · Risk SAFE
  • Gen Agent Trust Hub16d

    The skill provides safe documentation and python patterns for designing microservices architectures.

  • Socket16d

    No alerts

  • Snyk16d

    Risk: LOW · No issues

  • Runlayer6mo

    1 file scanned · No issues

  • ZeroLeaks5mo

    Score: 93/100 · 2 sections analyzed

Provenance

Signed by skilld at be57c0b. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 3 days ago.

Activeupdated 4 months ago

Topics

  • microservices
  • architecture
  • service-boundaries
  • distributed-systems
  • event-driven
  • resilience
  • saga-pattern
  • circuit-breaker
  • ddd

README badge

README badge for wshobson/agents/microservices-patterns

What it does

Teaches microservices architecture patterns including service decomposition, inter-service communication, data management, and resilience techniques like circuit breakers and sagas. Use when decomposing monoliths, designing service boundaries, or building event-driven distributed systems.

Generated from the current SKILL.md.

Frequently asked

Does this skill cover event-driven architecture patterns?
Yes. The skill includes asynchronous communication patterns using Kafka, message queues (RabbitMQ, SQS), and pub/sub, as well as the saga pattern for distributed transactions with eventual consistency.
What resilience patterns are included?
The skill covers circuit breaker, retry with exponential backoff, and bulkhead patterns for handling transient faults and preventing cascade failures in distributed systems.
Does this address data management across services?
Yes. It covers the database-per-service pattern for loose coupling and the saga pattern for handling distributed transactions across service boundaries.
Can I use this for decomposing a monolith?
Yes. The skill includes service decomposition strategies (by business capability, DDD subdomains) and the strangler fig pattern for gradual migration from monolith to microservices.

Generated from the current SKILL.md. These answers refresh after source changes.