Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

microservices

/microservices

Pomaga zdecydować, czy i jak podzielić system na usługi: granice, komunikacja, dane rozproszone, sagi i koszt operacyjny sieci.

Licencja
MIT
Ostatnia zmiana repozytorium
24.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 24.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Pomaga zdecydować, czy i jak podzielić system na usługi: granice, komunikacja, dane rozproszone, sagi i koszt operacyjny sieci.

Wyzwalacze z opisu

should we split the monolithextract this into a serviceour services are too coupled
Oryginalny opis (EN)

Use when decomposing a system into services, or deciding whether to. Covers service boundaries, inter-service communication, distributed data, saga patterns, and the operational cost of the network. Trigger on "should we split the monolith", "extract this into a service", "our services are too coupled". Do not use for broker and event design — see the event-driven-architecture skill; for pre-build system design, see the system-design skill.

Jak działa

  1. Purpose
  2. When to Use
  3. Capabilities
  4. Inputs
  5. Outputs
  6. Workflow
  7. Best Practices
  8. Examples
  9. Notes
Sekcje z nagłówków SKILL.md, w oryginale · 86 linii, 673 słów
Podgląd SKILL.md
---
name: microservices
description: Use when decomposing a system into services, or deciding whether to. Covers service boundaries, inter-service communication, distributed data, saga patterns, and the operational cost of the network. Trigger on "should we split the monolith", "extract this into a service", "our services are too coupled". Do not use for broker and event design — see the event-driven-architecture skill; for pre-build system design, see the system-design skill.
metadata:
  category: backend
  version: 1.0.0
  tags: [microservices, distributed-systems, saga, boundaries]
---

# Microservices

## Purpose

Decide where service boundaries belong — and whether you need them at all. Splitting a system converts function calls into network calls, and every network call is a new failure mode you must design for.

## When to Use

- Considering extracting a service from a monolith.
- Defining boundaries for a system that will be built as services.
- Diagnosing a distributed system that has become a "distributed monolith".
- Designing a transaction that spans services.

## Capabilities

- Boundary identification along business capabilities and data ownership.
- Communication design: synchronous versus asynchronous, and when each is correct.
- Distributed data: the outbox pattern, sagas, eventual consistency.
- Resilience: timeouts, retries with backoff, circuit breakers, bulkheads.
- Observability: correlation IDs and distributed tracing.

## Inputs

- The current system and the concrete problem services are meant to solve.
- Team topology — services follow team boundaries whether you intend them to or not.
- Consistency requirements per operation.

## Outputs

- Service boundaries with owned data and a published contract.
- A communication pattern per interaction, chosen deliberately.
- Failure behavior for each cross-service call.

## Workflow

1. **Justify the split** — The valid reasons are independent deployability, independent scaling, and team autonomy. "Microservices are best practice" is not a reason.
2. **Draw boundaries around data** — A service owns its data exclusively. If two services need the same table, they are one service.
3. **Prefer asynchronous** — A synchronous call chain of five services has the availability of the least available one, multiplied. Events decouple.
4. **Design the failure** — For every synchronous call: timeout, retry policy, circuit breaker, and a defined degraded behavior.
5. **Solve distributed writes with the outbox** — Write the state change and the event in one local transaction; publish from the outbox. Two-phase commit across services is not available to you.
6. **Trace everything** — Correlation ID propagated through every hop. Without it, a distributed system is undebuggable.

## Best Practices

- Start with a modular monolith. Enforce module boundaries in code; extract a service only when a module has a genuinely different deployment or scaling need.
- Shared databases between services are the single most common way a microservice architecture becomes worse than the monolith it replaced.
- Retries without idempotency cause duplicate side effects. Retries without backoff cause outages. Both are required, together.
- A synchronous call inside a request path adds its latency and its failure probability to yours. Count the hops.
- Do not build a service per entity. `UserService`, `OrderService`, `ProductService` is a database schema wearing a network.
- Version events. An event schema is a contract with consumers you cannot deploy in lockstep with.

## Examples

**Transactional outbox — the state change and the event commit atomically:**

```sql
BEGIN;
  UPDATE orders SET status = 'paid' WHERE id = $1;

  INSERT INTO outbox (id, aggregate_id, type, payload, created_at)
  VALUES (gen_random_uuid(), $1, 'order.paid',
          jsonb_build_object('order_id', $1, 'amount_cents', $2, 'version', 1),
          now());
COMMIT;
```

A separate relay polls `outbox`, publishes to the broker, and marks rows as sent. If the publish fails, the row remains and is retried; if the transaction rolls back, no event is emitted. The state and the event can never disagree.

**Saga compensation for a booking spanning three services:**

```text
1. Reserve inventory   -> compensate: release inventory
2. Charge payment      -> compensate: refund payment
3. Confirm shipment    -> compensate: cancel shipment

Failure at step 3 runs compensations for 2 and 1, in reverse order.
Each compensation must be idempotent — it will be retried.
```

## Notes

- Eventual consistency is a product decision, not just a technical one. Someone must decide what a user sees during the window, and that decision belongs in the design document.
- Circuit breakers need a defined behavior when open: fail fast, serve stale, or degrade. An open breaker with no fallback is just a faster failure.
- If the team cannot operate one service well — no tracing, no alerting, no runbook — ten services will not go better.

Wersje

RepozytoriumWynikLicencja
Ta strona · nimadorostkar/Claude-Skills-collection100MIT
krzysztofsurdy/code-virtuoso100MIT
SkillMedev/skills100MIT
G1Joshi/Agent-Skills100MIT
MARUCIE/openclaw-foundry100MIT
Tyler-R-Kendrick/agent-skills100MIT
kid-sid/codex-spellbook100MIT
j4flmao/agent-skills95MIT
andreibesleaga/gabbe90CC-BY-4.0

Migawka bazy z 13.11.2026 · wersja paczki 33982c65b4cd (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90microservices-architect
    Projektuje systemy rozproszone i mikroserwisy: granice usług, DDD, wzorce sag, event sourcing, service mesh i śledzenie rozproszone.
  • 80role-backend:microservices
    Projektuje mikroserwisy: podział monolitu, komunikację REST i gRPC, sagi, wyłączniki obwodu oraz śledzenie rozproszone.
  • 100microservices-patterns
    Dzieli systemy na mikroserwisy i stosuje wzorce rozproszone: granice usług, wybór między mikroserwisami a modularnym monolitem, sagi, outbox, CQRS, event sourcing, API gateway i odporność.
  • 95microservices-patterns
    Projektuje architekturę mikroserwisów: granice usług, komunikację zdarzeniową i wzorce odporności przy rozbijaniu monolitu.
  • 95architecture-microservices-patterns
    Decyduje, czy rozbić monolit na usługi, i stosuje wzorce: sagi, wyłączniki obwodu, bramę API oraz migrację strangler fig.
  • 100microservices-architect
    Projektuje architekturę systemów rozproszonych, dzieli monolit na usługi według bounded context i tworzy diagramy granic oraz strategie odporności.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.