Strangler-fig வடிவத்தைப் பயன்படுத்தி monolith ஐ microservices ஆக மாற்றுவது எப்படி?

Question

Accepted Answer

**Strangler-fig** வடிவம் படிப்படியாக மாற்றுகிறது: நீங்கள் monolith ஐ ஒரு ரூட்டிங் அடுக்குடன் சுற்றிக் கொண்டு, ஒரு திறனை ஒரு முறை ஒரு சேவையாக எடுத்து, அதற்கு ட்ராஃபிக்கை திருப்பி விடுவீர்கள் — monolith "அடிமையாக" இருக்கும் வரை. **பெரும் மீண்டும் எழுதல் இல்லை**.

## இது எவ்வாறு செயல்படுகிறது

```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
```

## பகிரப்பட்ட தரவு கையாளுதல்

கடினமான பகுதி தரவுத்தளம் ஆகும். சேவையின் அட்டவணைகளை பிரித்தெடுக்கவும், பின்னர் நிகழ்வுகள் அல்லது ஒரு ஊழல் வாரியின் மூலம் பகிரப்பட்ட-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
```

## இது ஏன் முக்கியமானது

பெரும் மீண்டும் எழுதல் கவனிக்கப்பட்ட முறையில் தோல்வியுறுகிறது — அவை மாத கால பைசா செயல்களை உறையச் செய்து ஒரு அபாய இணைவு வளைவு அனுப்புகின்றன।

Strangler-fig வடிவம் முழு நேரம் கணினிசாலை உயிருடன் மற்றும் வெளியிடப்பட்ட வைத்திருக்கிறது, எப்போது வேண்டுமென்றாலும் நிறுத்த அல்லது மீண்டும் முன்னுரிமை கொடுக்க அனுமதிக்கிறது, மற்றும் உங்களைக் கண்டறிய வேண்டிய உண்மையான சேவை எல்லைகளை செயல்படும் கணினிசாலையிலிருந்து கண்டறிய தக்க செய்கிறது.