ਤੁਸੀਂ strangler-fig ਪੈਟਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ monolith ਨੂੰ microservices ਵਿਚ ਕਿਵੇਂ ਮਾਈਗ੍ਰੇਟ ਕਰਦੇ ਹੋ?

Question

Accepted Answer

The **strangler-fig pattern** ਵਧਦੀ ਤਰੀਕੇ ਨਾਲ ਮਾਈਗ੍ਰੇਟ ਕਰਦੀ ਹੈ: ਤੁਸੀਂ monolith ਨੂੰ routing layer ਨਾਲ ਲਪੇਟਦੇ ਹੋ, ਇੱਕ ਸਮਰੱਥਾ ਨੂੰ ਹਰ ਵਾਰ ਇੱਕ service ਵਿਚ ਨਿਕਾਲਦੇ ਹੋ, ਅਤੇ ਇਸ ਵੱਲ traffic ਨੂੰ ਮੁੜ-ਭੇਜਦੇ ਹੋ — ਜਦੋਂ ਤੱਕ monolith "strangle" ਨਹੀਂ ਹੋ ਜਾਂਦਾ। ਇਥੇ **ਕੋਈ big-bang rewrite** ਨਹੀਂ ਹੈ।

## ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ

```text
Step 1: route all traffic through a facade/proxy to the monolith
Step 2: extract ONE capability → new service
Step 3: route just that path to the new service
Step 4: repeat; delete that code from the monolith

Client ─▶ [ Proxy ] ─┬─▶ /orders  ─▶ NEW Orders service
                       └─▶ everything else ─▶ Monolith
```

## ਪਹਿਲਾਂ ਕੀ ਨਿਕਾਲਣਾ ਹੈ ਚੁਣਨਾ

```text
✓ A bounded context with clear boundaries
✓ Something that needs independent scaling or deploys
✓ A part with few inbound dependencies (low risk)
✗ Don't start with the tangled core
```

## ਸਾਂਝੇ ਡੇਟਾ ਨੂੰ ਸੰਭਾਲਣਾ

ਮੁਸ਼ਕਲ ਹਿੱਸਾ database ਹੈ। Service ਦੀਆਂ tables ਨੂੰ ਨਿਕਾਲੋ, ਫਿਰ events ਜਾਂ anti-corruption layer ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਾਂਝੇ-DB ਜੋੜ ਨੂੰ ਤੋੜੋ, ਅਕਸਰ **branch-by-abstraction** ਤਕਨੀਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਜਦੋਂ ਦੋਵੇਂ ਚਲ ਰਹੇ ਹਨ।

## ਟ੍ਰੇਡ-ਆਫਸ

```text
✓ Low risk — small, reversible steps, always shippable
✓ Value early, learn the seams as you go
✗ Slow; you run a hybrid system for a long time
✗ Temporary duplication and routing complexity
```

## ਇਹ ਜ਼ਰੂਰੀ ਕਿਉਂ ਹੈ

Big-bang rewrites ਮਸ਼ਹੂਰ ਤਰੀਕੇ ਨਾਲ ਫੇਲ ਹੁੰਦੇ ਹਨ — ਉਹ ਮਹੀਨਿਆਂ ਲਈ feature ਕੰਮ ਨੂੰ ਫ੍ਰੀਜ਼ ਕਰ ਦਿੰਦੇ ਹਨ ਅਤੇ ਇੱਕ ਜੋਖਮ ਭਰਿਆ all-at-once cutover ਚਲਾਈ ਦਿੰਦੇ ਹਨ।

The strangler-fig ਪੂਰੇ ਸਮੇਂ ਸਿਸਟਮ ਨੂੰ live ਅਤੇ releasable ਰੱਖਦੀ ਹੈ, ਤੁਹਾਨੂੰ ਕਿਸੇ ਵੀ ਬਿੰਦੂ 'ਤੇ ਰੋਕਣ ਜਾਂ ਮੁੜ-ਤਰਜੀਹ ਦੇਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਅਗਾਊਂ ਤੇ ਅਨੁਮਾਨ ਲਗਾਉਣ ਦੀ ਬਜਾਏ ਚਲਦੇ ਸਿਸਟਮ ਤੋਂ ਅਸਲ service ਸੀਮਾਵਾਂ ਨੂੰ ਖੋਜਣ ਲਈ ਮਜਬੂਰ ਕਰਦੀ ਹੈ।